Subversion Repositories SmartDukaan

Rev

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

Rev Author Line No. Line
94 ashish 1 
#
3431 rajveer 2 
# Autogenerated by Thrift Compiler (0.7.0)
94 ashish 3 
#
4 
# DO NOT EDIT UNLESS YOU ARE SURE THAT YOU KNOW WHAT YOU ARE DOING
5 
#
6 
 
7 
from thrift.Thrift import *
3376 rajveer 8 
import shop2020.thriftpy.generic.GenericService
94 ashish 9 
from ttypes import *
10 
from thrift.Thrift import TProcessor
11 
from thrift.transport import TTransport
3431 rajveer 12 
from thrift.protocol import TBinaryProtocol, TProtocol
94 ashish 13 
try:
14 
  from thrift.protocol import fastbinary
15 
except:
16 
  fastbinary = None
17 
 
18 
 
3376 rajveer 19 
class Iface(shop2020.thriftpy.generic.GenericService.Iface):
94 ashish 20 
  def createTransaction(self, transaction):
21 
    """
22 
    Parameters:
23 
     - transaction
24 
    """
25 
    pass
26 
 
27 
  def getTransaction(self, id):
28 
    """
29 
    Parameters:
30 
     - id
31 
    """
32 
    pass
33 
 
34 
  def getTransactionsForCustomer(self, customerId, from_date, to_date, status):
35 
    """
36 
    Parameters:
37 
     - customerId
38 
     - from_date
39 
     - to_date
40 
     - status
41 
    """
42 
    pass
43 
 
132 ashish 44 
  def getTransactionsForShoppingCartId(self, shoppingCartId):
45 
    """
46 
    Parameters:
47 
     - shoppingCartId
48 
    """
49 
    pass
50 
 
94 ashish 51 
  def getTransactionStatus(self, transactionId):
52 
    """
53 
    Parameters:
54 
     - transactionId
55 
    """
56 
    pass
57 
 
58 
  def changeTransactionStatus(self, transactionId, status, description):
59 
    """
60 
    Parameters:
61 
     - transactionId
62 
     - status
63 
     - description
64 
    """
65 
    pass
66 
 
1398 varun.gupt 67 
  def enqueueTransactionInfoEmail(self, transactionId):
1382 varun.gupt 68 
    """
69 
    Parameters:
70 
     - transactionId
71 
    """
72 
    pass
73 
 
4801 anupam.sin 74 
  def getAllOrders(self, statuses, from_date, to_date, warehouse_id):
94 ashish 75 
    """
76 
    Parameters:
4801 anupam.sin 77 
     - statuses
483 rajveer 78 
     - from_date
79 
     - to_date
80 
     - warehouse_id
94 ashish 81 
    """
82 
    pass
83 
 
4133 chandransh 84 
  def getOrdersInBatch(self, statuses, offset, limit, warehouse_id):
85 
    """
86 
    Returns at most 'limit' orders with the given statuses for the given warehouse starting from the given offset.
87 
    Pass the status as null and the limit as 0 to ignore them.
88 
 
89 
    Parameters:
90 
     - statuses
91 
     - offset
92 
     - limit
93 
     - warehouse_id
94 
    """
95 
    pass
96 
 
97 
  def getOrderCount(self, statuses, warehouseId):
98 
    """
99 
    Returns the count of orders with the given statuses assigned to the given warehouse.
100 
 
101 
    Parameters:
102 
     - statuses
103 
     - warehouseId
104 
    """
105 
    pass
106 
 
999 varun.gupt 107 
  def getOrdersByBillingDate(self, status, start_billing_date, end_billing_date, warehouse_id):
108 
    """
1132 chandransh 109 
    Returns orders within a range of their billing dates
3431 rajveer 110 
 
999 varun.gupt 111 
    Parameters:
112 
     - status
113 
     - start_billing_date
114 
     - end_billing_date
115 
     - warehouse_id
116 
    """
117 
    pass
118 
 
3451 chandransh 119 
  def getOrdersByShippingDate(self, fromShippingDate, toShippingDate, providerId, warehouseId, cod):
3427 chandransh 120 
    """
121 
    Returns orders for a particular provider and warehouse which were shipped between the given dates.
3451 chandransh 122 
    Returned orders comprise of COD orders if cod parameter is true. It comprises of prepaid orders otherwise.
123 
    Pass providerId and warehouseId as -1 to ignore both these parameters.
3431 rajveer 124 
 
3427 chandransh 125 
    Parameters:
126 
     - fromShippingDate
127 
     - toShippingDate
128 
     - providerId
129 
     - warehouseId
3451 chandransh 130 
     - cod
3427 chandransh 131 
    """
132 
    pass
133 
 
1382 varun.gupt 134 
  def getReturnableOrdersForCustomer(self, customer_id, limit):
135 
    """
136 
    Returns order ids for orders which can be returned
3431 rajveer 137 
 
1382 varun.gupt 138 
    Parameters:
139 
     - customer_id
140 
     - limit
141 
    """
142 
    pass
143 
 
144 
  def getCancellableOrdersForCustomer(self, customer_id, limit):
145 
    """
146 
    Returns order ids for orders which can be cancelled
3431 rajveer 147 
 
1382 varun.gupt 148 
    Parameters:
149 
     - customer_id
150 
     - limit
151 
    """
152 
    pass
153 
 
483 rajveer 154 
  def changeOrderStatus(self, orderId, status, description):
94 ashish 155 
    """
156 
    Parameters:
483 rajveer 157 
     - orderId
158 
     - status
159 
     - description
94 ashish 160 
    """
161 
    pass
162 
 
1528 ankur.sing 163 
  def getOrdersForTransaction(self, transactionId, customerId):
94 ashish 164 
    """
1528 ankur.sing 165 
    Returns list of orders for given transaction Id. Also filters based on customer Id so that
166 
    only user who owns the transaction can view its order details.
3431 rajveer 167 
 
94 ashish 168 
    Parameters:
169 
     - transactionId
1528 ankur.sing 170 
     - customerId
94 ashish 171 
    """
172 
    pass
173 
 
3014 chandransh 174 
  def getOrdersForCustomer(self, customerId, from_date, to_date, statuses):
94 ashish 175 
    """
3014 chandransh 176 
    Returns list of orders for the given customer created between the given dates and having the given statuses.
177 
    Pass and empty list to ignore filtering on statuses.
3431 rajveer 178 
 
94 ashish 179 
    Parameters:
483 rajveer 180 
     - customerId
181 
     - from_date
182 
     - to_date
3014 chandransh 183 
     - statuses
94 ashish 184 
    """
185 
    pass
186 
 
483 rajveer 187 
  def createOrder(self, order):
94 ashish 188 
    """
189 
    Parameters:
483 rajveer 190 
     - order
94 ashish 191 
    """
192 
    pass
193 
 
483 rajveer 194 
  def getOrder(self, id):
94 ashish 195 
    """
196 
    Parameters:
483 rajveer 197 
     - id
94 ashish 198 
    """
199 
    pass
200 
 
483 rajveer 201 
  def getLineItemsForOrder(self, orderId):
94 ashish 202 
    """
203 
    Parameters:
483 rajveer 204 
     - orderId
94 ashish 205 
    """
206 
    pass
207 
 
1528 ankur.sing 208 
  def getOrderForCustomer(self, orderId, customerId):
209 
    """
210 
    Returns an order for the order Id. Also checks if the order belongs to the customer whose Id is passed.
211 
    Throws exception if either order Id is invalid or order does not below to the customer whose Id is passed.
3431 rajveer 212 
 
1528 ankur.sing 213 
    Parameters:
214 
     - orderId
215 
     - customerId
216 
    """
217 
    pass
218 
 
4444 rajveer 219 
  def getAlerts(self, type, warehouseId, status, timestamp):
3064 chandransh 220 
    """
221 
    Parameters:
4394 rajveer 222 
     - type
4444 rajveer 223 
     - warehouseId
4394 rajveer 224 
     - status
225 
     - timestamp
3064 chandransh 226 
    """
227 
    pass
228 
 
4444 rajveer 229 
  def addAlert(self, type, warehouseId, description):
3064 chandransh 230 
    """
231 
    Parameters:
232 
     - type
4444 rajveer 233 
     - warehouseId
4394 rajveer 234 
     - description
3064 chandransh 235 
    """
236 
    pass
237 
 
4444 rajveer 238 
  def markAlertsAsSeen(self, warehouseId):
239 
    """
240 
    Parameters:
241 
     - warehouseId
242 
    """
243 
    pass
244 
 
3064 chandransh 245 
  def getValidOrderCount(self, ):
246 
    """
247 
    Return the number of valid orders. (OrderStatus >= OrderStatus.SUBMITTED_FOR_PROCESSING)
248 
    """
249 
    pass
250 
 
251 
  def getNoOfCustomersWithSuccessfulTransaction(self, ):
252 
    """
253 
    Returns the number of distinct customers who have done successful transactions
254 
    """
255 
    pass
256 
 
257 
  def getValidOrdersAmountRange(self, ):
258 
    """
259 
    Returns the minimum and maximum amounts of a valid order. (OrderStatus >= OrderStatus.SUBMITTED_FOR_PROCESSING)
260 
    List contains two values, first minimum amount and second maximum amount.
261 
    """
262 
    pass
263 
 
264 
  def getValidOrders(self, limit):
265 
    """
266 
    Returns list of Orders in descending order by Order creation date. List is restricted to limit Orders.
267 
    If limit is passed as 0, then all valid Orders are returned.
3431 rajveer 268 
 
3064 chandransh 269 
    Parameters:
270 
     - limit
271 
    """
272 
    pass
273 
 
1220 chandransh 274 
  def batchOrders(self, warehouseId):
275 
    """
276 
    Create a batch of all the pending orders for the given warehouse.
277 
    The returned list is orderd by created_timestamp.
278 
    If there are no pending orders, an empty list is returned.
3431 rajveer 279 
 
1220 chandransh 280 
    Parameters:
281 
     - warehouseId
282 
    """
283 
    pass
284 
 
1208 chandransh 285 
  def markOrderAsOutOfStock(self, orderId):
286 
    """
287 
    Mark the given order as out of stock. Throws an exception if the order with the given Id couldn't be found.
3431 rajveer 288 
 
1208 chandransh 289 
    Parameters:
290 
     - orderId
291 
    """
292 
    pass
293 
 
3064 chandransh 294 
  def verifyOrder(self, orderId):
759 chandransh 295 
    """
3064 chandransh 296 
    Marks the given order as SUBMITTED_FOR_PROCESSING and updates the verified
297 
    timestamp. It is intended to be used for COD orders but can be harmlessly
298 
    used for all other orders as well.
299 
    Throws an exception if no such order exists.
3431 rajveer 300 
 
759 chandransh 301 
    Parameters:
3064 chandransh 302 
     - orderId
303 
    """
304 
    pass
305 
 
306 
  def acceptOrder(self, orderId):
307 
    """
308 
    Marks the given order as ACCEPTED and updates the accepted timestamp. If the
309 
    given order is not a COD order, it also captures the payment if the same has
310 
    not been captured.
311 
    Throws an exception if no such order exists.
3431 rajveer 312 
 
3064 chandransh 313 
    Parameters:
314 
     - orderId
315 
    """
316 
    pass
317 
 
4763 rajveer 318 
  def addBillingDetails(self, orderId, invoice_number, serialNumber, itemNumber, billed_by, jacketNumber, billingType, vendorId, authorize):
3064 chandransh 319 
    """
320 
    Add billing details such as the bill number and the biller to the Order.
4658 mandeep.dh 321 
    Adds jacket number, item number and Serial no. to the order. Doesn't update
3064 chandransh 322 
    the IMEI no. if a -1 is supplied.
323 
    Also, it generates an invoice number for the order, marks the order as
324 
    BILLED and sets the billing timestamp.
325 
    Returns false if it doesn't find the order with the given ID.
3431 rajveer 326 
 
3064 chandransh 327 
    Parameters:
328 
     - orderId
4283 anupam.sin 329 
     - invoice_number
4658 mandeep.dh 330 
     - serialNumber
3064 chandransh 331 
     - itemNumber
4283 anupam.sin 332 
     - billed_by
333 
     - jacketNumber
3064 chandransh 334 
     - billingType
4283 anupam.sin 335 
     - vendorId
4763 rajveer 336 
     - authorize
3064 chandransh 337 
    """
338 
    pass
339 
 
4763 rajveer 340 
  def addInvoiceNumber(self, orderId, invoiceNumber, color):
4579 rajveer 341 
    """
342 
    Add the invoice number to the order.
343 
 
344 
    Parameters:
345 
     - orderId
346 
     - invoiceNumber
4763 rajveer 347 
     - color
4579 rajveer 348 
    """
349 
    pass
350 
 
3064 chandransh 351 
  def markOrdersAsManifested(self, warehouseId, providerId, cod):
352 
    """
353 
    Depending on the third parameter, marks either all prepaid or all cod orders BILLED by the
4410 rajveer 354 
    given warehouse and were picked up by the given provider as MANIFESTED.
355 
 
356 
    Parameters:
357 
     - warehouseId
358 
     - providerId
359 
     - cod
360 
    """
361 
    pass
362 
 
4789 rajveer 363 
  def markOrdersAsShippedFromWarehouse(self, warehouseId, providerId, cod, orderIds):
4410 rajveer 364 
    """
365 
    Depending on the third parameter, marks either all prepaid or all cod orders BILLED and marked as MANIFESTED by the
3064 chandransh 366 
    given warehouse and were picked up by the given provider as SHIPPED_FROM_WH.
3431 rajveer 367 
 
3064 chandransh 368 
    Parameters:
759 chandransh 369 
     - warehouseId
370 
     - providerId
3064 chandransh 371 
     - cod
4789 rajveer 372 
     - orderIds
759 chandransh 373 
    """
374 
    pass
375 
 
1113 chandransh 376 
  def markOrdersAsPickedUp(self, providerId, pickupDetails):
377 
    """
378 
    Marks all SHIPPED_FROM_WH orders of the previous day for a provider as SHIPPED_TO_LOGISTICS.
379 
    Returns a list of orders that were shipped from warehouse but did not appear in the pick-up report.
380 
    Raises an exception if we encounter report for an AWB number that we did not ship.
3431 rajveer 381 
 
1113 chandransh 382 
    Parameters:
383 
     - providerId
384 
     - pickupDetails
385 
    """
386 
    pass
387 
 
1132 chandransh 388 
  def markOrdersAsDelivered(self, providerId, deliveredOrders):
389 
    """
390 
    Marks all orders with AWBs in the given map as delivered. Also sets the delivery timestamp and
391 
    the name of the receiver.
392 
    Raises an exception if we encounter report for an AWB number that we did not ship.
3431 rajveer 393 
 
1132 chandransh 394 
    Parameters:
395 
     - providerId
396 
     - deliveredOrders
397 
    """
398 
    pass
399 
 
1135 chandransh 400 
  def markOrdersAsFailed(self, providerId, returnedOrders):
401 
    """
402 
    Mark all orders with AWBs in the given map as failed. Also sets the delivery timestamp.
403 
    Raises an exception if we encounter report for an AWB number that we did not ship.
3431 rajveer 404 
 
1135 chandransh 405 
    Parameters:
406 
     - providerId
407 
     - returnedOrders
408 
    """
409 
    pass
410 
 
1246 chandransh 411 
  def updateNonDeliveryReason(self, providerId, undeliveredOrders):
412 
    """
413 
    Update the status description of orders whose AWB numbers are keys of the Map.
4581 phani.kuma 414 
    Returns a list of orders that were picked up or shipped four days ago but did not get delivered.
3431 rajveer 415 
 
1246 chandransh 416 
    Parameters:
417 
     - providerId
418 
     - undeliveredOrders
419 
    """
420 
    pass
421 
 
1408 ankur.sing 422 
  def getUndeliveredOrders(self, providerId, warehouseId):
423 
    """
424 
    Returns the list of orders whose delivery time has passed but have not been
425 
    delivered yet for the given provider and warehouse. To get a complete list of
426 
    undelivered orders, pass them as -1.
427 
    Returns an empty list if no such orders exist.
3431 rajveer 428 
 
1408 ankur.sing 429 
    Parameters:
430 
     - providerId
431 
     - warehouseId
432 
    """
433 
    pass
434 
 
4783 phani.kuma 435 
  def getUndeliveredOrdersExpectedDeliveryDateNotMet(self, ):
436 
    """
437 
    Returns the list of orders whose expected delivery date has passed but have not been
438 
    delivered yet.
439 
    Returns an empty list if no such orders exist.
440 
    """
441 
    pass
442 
 
2536 chandransh 443 
  def toggleDOAFlag(self, orderId):
444 
    """
445 
    Toggle the DOA flag of an order. This should be used to flag an order for follow-up and unflag it when the follow-up is complete.
446 
    Returns the final flag status.
447 
    Throws an exception if the order with the given id couldn't be found or if the order status is not DELVIERY_SUCCESS.
3431 rajveer 448 
 
2536 chandransh 449 
    Parameters:
450 
     - orderId
451 
    """
452 
    pass
1886 ankur.sing 453 
 
4712 rajveer 454 
  def markOrderAsDelivered(self, orderId, deliveryTimestamp, receiver):
455 
    """
456 
    Parameters:
457 
     - orderId
458 
     - deliveryTimestamp
459 
     - receiver
460 
    """
461 
    pass
462 
 
4454 rajveer 463 
  def markOrderDoaRequestReceived(self, orderId):
464 
    """
465 
    Once user raise the request for a DOA, order status will be changed from DELVIERY_SUCCESS to DOA_REQUEST_RECEIVED
466 
 
467 
    Parameters:
468 
     - orderId
469 
    """
470 
    pass
471 
 
472 
  def markOrderDoaRequestAuthorized(self, orderId, isAuthorized):
473 
    """
474 
    CRM person can authorize or deny the request reised by customer. If he authorizes order will change from DOA_REQUEST_RECEIVED
475 
    to DOA_REQUEST_AUTHORIZED. If he denies, status will be changed back to DELVIERY_SUCCESS.
476 
 
477 
    Parameters:
478 
     - orderId
479 
     - isAuthorized
480 
    """
481 
    pass
482 
 
4488 rajveer 483 
  def markOrderReturnRequestReceived(self, orderId):
484 
    """
485 
    Once user raise the request for a RET, order status will be changed from DELVIERY_SUCCESS to RET_REQUEST_RECEIVED
486 
 
487 
    Parameters:
488 
     - orderId
489 
    """
490 
    pass
491 
 
492 
  def markOrderReturnRequestAuthorized(self, orderId, isAuthorized):
493 
    """
494 
    CRM person can authorize or deny the request reised by customer. If he authorizes order will change from RET_REQUEST_RECEIVED
495 
    to RET_REQUEST_AUTHORIZED. If he denies, status will be changed back to DELVIERY_SUCCESS.
496 
 
497 
    Parameters:
498 
     - orderId
499 
     - isAuthorized
500 
    """
501 
    pass
502 
 
4579 rajveer 503 
  def requestPickupNumber(self, orderId, providerId):
2536 chandransh 504 
    """
505 
    Sends out an email to the account manager of the original courier provider used to ship the order.
4452 rajveer 506 
    If the order status was DELIVERY_SUCCESS, it is changed to be DOA_PICKUP_REQUEST_RAISED.
507 
    If the order status was DOA_PICKUP_REQUEST_RAISED, it is left unchanged.
2536 chandransh 508 
    For any other status, it returns false.
509 
    Throws an exception if the order with the given id couldn't be found.
3431 rajveer 510 
 
2536 chandransh 511 
    Parameters:
512 
     - orderId
4579 rajveer 513 
     - providerId
2536 chandransh 514 
    """
515 
    pass
516 
 
4602 rajveer 517 
  def authorizePickup(self, orderId, pickupNumber, providerId):
2536 chandransh 518 
    """
4452 rajveer 519 
    If the order status is DOA_PICKUP_REQUEST_RAISED, it does the following
2536 chandransh 520 
    	1. Sends out an email to the customer with the dispatch advice that he has to print as an attachment.
521 
    	2. Changes order status to be DOA_PICKUP_AUTHORIZED.
522 
    	3. Returns true
2591 chandransh 523 
    If the order is in any other status, it returns false.
2536 chandransh 524 
    Throws an exception if the order with the given id couldn't be found.
3431 rajveer 525 
 
2536 chandransh 526 
    Parameters:
527 
     - orderId
528 
     - pickupNumber
4602 rajveer 529 
     - providerId
2536 chandransh 530 
    """
531 
    pass
532 
 
2764 chandransh 533 
  def markDoasAsPickedUp(self, providerId, pickupDetails):
534 
    """
535 
    Marks all DOA_PICKUP_AUTHORIZED orders of the previous day for a provider as DOA_RETURN_IN_TRANSIT.
536 
    Returns a list of orders that were authorized for pickup but did not appear in the pick-up report.
3431 rajveer 537 
 
2764 chandransh 538 
    Parameters:
539 
     - providerId
540 
     - pickupDetails
541 
    """
542 
    pass
543 
 
4741 phani.kuma 544 
  def markReturnOrdersAsPickedUp(self, providerId, pickupDetails):
545 
    """
546 
    Marks all RET_PICKUP_CONFIRMED orders of the previous day for a provider as RET_RETURN_IN_TRANSIT.
547 
    Returns a list of orders that were authorized for pickup but did not appear in the pick-up report.
548 
 
549 
    Parameters:
550 
     - providerId
551 
     - pickupDetails
552 
    """
553 
    pass
554 
 
4479 rajveer 555 
  def receiveReturn(self, orderId, receiveCondition):
2591 chandransh 556 
    """
4452 rajveer 557 
    If the order status is DOA_PICKUP_CONFIRMED or DOA_RETURN_IN_TRANSIT, marks the order status as DOA_RECEIVED_PRESTINE and returns true.
4484 rajveer 558 
    If the order status is RTO_IN_TRANSIT, marks the order status as RTO_RECEIVED_PRESTINE and returns true.
2591 chandransh 559 
    If the order is in any other state, it returns false.
560 
    Throws an exception if the order with the given id couldn't be found.
3431 rajveer 561 
 
2591 chandransh 562 
    Parameters:
563 
     - orderId
4479 rajveer 564 
     - receiveCondition
2591 chandransh 565 
    """
566 
    pass
2536 chandransh 567 
 
2591 chandransh 568 
  def validateDoa(self, orderId, isValid):
569 
    """
4452 rajveer 570 
    Used to validate the DOA certificate for an order in the DOA_RECEIVED_PRESTINE state. If the certificate is valid,
2616 chandransh 571 
    the order state is changed to DOA_CERT_VALID. If the certificate is invalid, the order state is changed to DOA_CERT_INVALID.
2591 chandransh 572 
    If the order is in any other state, it returns false.
573 
    Throws an exception if the order with the given id couldn't be found.
3431 rajveer 574 
 
2591 chandransh 575 
    Parameters:
576 
     - orderId
577 
     - isValid
578 
    """
579 
    pass
580 
 
4495 rajveer 581 
  def validateReturnProduct(self, orderId, isUsable):
582 
    """
583 
    Parameters:
584 
     - orderId
585 
     - isUsable
586 
    """
587 
    pass
588 
 
2616 chandransh 589 
  def reshipOrder(self, orderId):
590 
    """
4484 rajveer 591 
    If the order is in RTO_RECEIVED_PRESTINE or DOA_CERT_INVALID state, it does the following:
2616 chandransh 592 
    	1. Creates a new order for processing in the BILLED state. All billing information is saved.
4484 rajveer 593 
    	2. Marks the current order as one of the final states RTO_RESHIPPED and DOA_INVALID_RESHIPPED depending on what state the order started in.
2616 chandransh 594 
 
595 
    If the order is in DOA_CERT_VALID state, it does the following:
596 
    	1. Creates a new order for processing in the SUBMITTED_FOR_PROCESSING state.
597 
    	2. Creates a return order for the warehouse executive to return the DOA material.
4452 rajveer 598 
    	3. Marks the current order as the final DOA_VALID_RESHIPPED state.
3431 rajveer 599 
 
2616 chandransh 600 
    Returns the id of the newly created order.
3431 rajveer 601 
 
2616 chandransh 602 
    Throws an exception if the order with the given id couldn't be found.
3431 rajveer 603 
 
2616 chandransh 604 
    Parameters:
605 
     - orderId
606 
    """
607 
    pass
2591 chandransh 608 
 
3226 chandransh 609 
  def refundOrder(self, orderId, refundedBy, reason):
2616 chandransh 610 
    """
4484 rajveer 611 
    If the order is in RTO_RECEIVED_PRESTINE, DOA_CERT_VALID or DOA_CERT_INVALID state, it does the following:
2616 chandransh 612 
    	1. Creates a refund request for batch processing.
613 
    	2. Creates a return order for the warehouse executive to return the shipped material.
4484 rajveer 614 
    	3. Marks the current order as RTO_REFUNDED, DOA_VALID_REFUNDED or DOA_INVALID_REFUNDED final states.
3431 rajveer 615 
 
2616 chandransh 616 
    If the order is in SUBMITTED_FOR_PROCESSING or INVENTORY_LOW state, it does the following:
617 
    	1. Creates a refund request for batch processing.
3226 chandransh 618 
    	2. Cancels the reservation of the item in the warehouse.
619 
    	3. Marks the current order as the REFUNDED final state.
3431 rajveer 620 
 
3226 chandransh 621 
    For all COD orders, if the order is in INIT, SUBMITTED_FOR_PROCESSING or INVENTORY_LOW state, it does the following:
622 
    	1. Cancels the reservation of the item in the warehouse.
623 
    	2. Marks the current order as CANCELED.
624 
 
625 
    In all cases, it updates the reason for cancellation or refund and the person who performed the action.
626 
 
2616 chandransh 627 
    Returns True if it is successful, False otherwise.
3431 rajveer 628 
 
2616 chandransh 629 
    Throws an exception if the order with the given id couldn't be found.
3431 rajveer 630 
 
2616 chandransh 631 
    Parameters:
632 
     - orderId
3226 chandransh 633 
     - refundedBy
634 
     - reason
2616 chandransh 635 
    """
636 
    pass
637 
 
2690 chandransh 638 
  def getReturnOrders(self, warehouseId, fromDate, toDate):
639 
    """
640 
    Get all return orders created between the from and to dates for the given warehouse.
641 
    Ignores the warehouse if it is passed as -1.
3431 rajveer 642 
 
2690 chandransh 643 
    Parameters:
644 
     - warehouseId
645 
     - fromDate
646 
     - toDate
647 
    """
648 
    pass
2616 chandransh 649 
 
2700 chandransh 650 
  def getReturnOrder(self, id):
651 
    """
652 
    Returns the ReturnOrder corresponding to the given id.
653 
    Throws an exception if the return order with the given id couldn't be found.
3431 rajveer 654 
 
2700 chandransh 655 
    Parameters:
656 
     - id
657 
    """
658 
    pass
659 
 
2690 chandransh 660 
  def processReturn(self, returnOrderId):
661 
    """
662 
    Marks the return order with the given id as processed. Raises an exception if no such return order exists.
3431 rajveer 663 
 
2690 chandransh 664 
    Parameters:
665 
     - returnOrderId
666 
    """
667 
    pass
668 
 
3451 chandransh 669 
  def updateWeight(self, orderId, weight):
670 
    """
671 
    Set the weight of the given order to the provided value. Will attempt to update the weight of the item in the catalog as well.
2819 chandransh 672 
 
3451 chandransh 673 
    Parameters:
674 
     - orderId
675 
     - weight
676 
    """
677 
    pass
678 
 
3469 chandransh 679 
  def changeItem(self, orderId, itemId):
680 
    """
681 
    Change the item to be shipped for this order. Also adjusts the reservation in the inventory accordingly.
682 
    Currently, it also ensures that only a different color of the given item is shipped.
3451 chandransh 683 
 
3469 chandransh 684 
    Parameters:
685 
     - orderId
686 
     - itemId
687 
    """
688 
    pass
689 
 
690 
  def shiftToWarehouse(self, orderId, warehouseId):
691 
    """
692 
    Moves the given order to the given warehouse. Also adjusts the inventory reservations accordingly.
693 
 
694 
    Parameters:
695 
     - orderId
696 
     - warehouseId
697 
    """
698 
    pass
699 
 
4647 rajveer 700 
  def addDelayReason(self, orderId, delayReason, furtherDelay, delayReasonText):
3553 chandransh 701 
    """
702 
    Adds the given delay reason to the given order.
3986 chandransh 703 
    Increases the expected delivery time of the given order by the given no. of days.
3553 chandransh 704 
    Raises an exception if no order with the given id can be found.
3469 chandransh 705 
 
3553 chandransh 706 
    Parameters:
707 
     - orderId
708 
     - delayReason
3986 chandransh 709 
     - furtherDelay
4647 rajveer 710 
     - delayReasonText
3553 chandransh 711 
    """
712 
    pass
713 
 
3956 chandransh 714 
  def reconcileCodCollection(self, collectedAmountMap, xferBy, xferTxnId, xferDate):
715 
    """
716 
    Marks the COD orders with given AWB nos. as having been processed.
717 
    Updates the captured amount for the corresponding payment.
3553 chandransh 718 
 
3956 chandransh 719 
    Returns a map of AWBs which were not processed and the associated reason. An AWB is not processed if:
720 
    1. There is no order corresponding to an AWB number.
721 
    2. The captured amount for a payment exceeds the total payment.
722 
    3. The order corresponding to an AWB no. is in a state prior to DELIVERY_SUCCESS.
723 
 
724 
    Parameters:
725 
     - collectedAmountMap
726 
     - xferBy
727 
     - xferTxnId
728 
     - xferDate
729 
    """
730 
    pass
731 
 
4008 mandeep.dh 732 
  def getTransactionsRequiringExtraProcessing(self, category):
733 
    """
4065 mandeep.dh 734 
    Returns the list of transaction ids that require some extra processing and
4008 mandeep.dh 735 
    which belong to a particular category. This is currently used by CRM
4065 mandeep.dh 736 
    application. If no such transaction ids are present, it returns an empty list.
3956 chandransh 737 
 
4008 mandeep.dh 738 
    Parameters:
739 
     - category
740 
    """
741 
    pass
742 
 
743 
  def markTransactionAsProcessed(self, transactionId, category):
744 
    """
745 
    Marks a particular transaction as processed for a particular cateogory.
4065 mandeep.dh 746 
    It essentially deletes the transaction id record for a particular
747 
    processing type category (if present) from DB.
748 
    This is currently used by CRM application.
4008 mandeep.dh 749 
 
750 
    Parameters:
751 
     - transactionId
752 
     - category
753 
    """
754 
    pass
755 
 
4018 chandransh 756 
  def getItemWiseRiskyOrdersCount(self, ):
757 
    """
758 
    Returns a map containing the number of risky orders keyed by item id. A risky order
759 
    is defined as one whose shipping date is about to expire.
760 
    """
761 
    pass
4008 mandeep.dh 762 
 
4295 varun.gupt 763 
  def getOrdersForItemIds(self, itemIds):
764 
    """
765 
    Returns a list of all orders which have items with given id
766 
 
767 
    Parameters:
768 
     - itemIds
769 
    """
770 
    pass
771 
 
4247 rajveer 772 
  def markOrderCancellationRequestReceived(self, orderId):
773 
    """
774 
    Mark order as cancellation request received. If customer sends request of cancellation of
775 
    a particular order, this method will be called. It will just change status of the order
776 
    depending on its current status. It also records the previous status, so that we can move
777 
    back to that status if cancellation request is denied.
4018 chandransh 778 
 
4247 rajveer 779 
    Parameters:
780 
     - orderId
781 
    """
782 
    pass
783 
 
784 
  def markOrderCancellationRequestConfirmed(self, orderId):
785 
    """
786 
    If we decide to to cancel order, CRM will call this method to move the status of order to
787 
    cancellation request confirmed. After this OM will be able to cancel the order.
788 
 
789 
    Parameters:
790 
     - orderId
791 
    """
792 
    pass
793 
 
794 
  def markOrderCancellationRequestDenied(self, orderId):
795 
    """
796 
    If we decide to not to cancel order, we will move the order ro previous status.
797 
 
798 
    Parameters:
799 
     - orderId
800 
    """
801 
    pass
802 
 
4258 rajveer 803 
  def markTransactionAsPaymentFlagRemoved(self, transactionId):
4247 rajveer 804 
    """
4258 rajveer 805 
    If we and/or payment gateway has decided to accept the payment, this method needs to be called.
806 
    Changed transaction and all orders status to payment accepted.
4247 rajveer 807 
 
808 
    Parameters:
4258 rajveer 809 
     - transactionId
4247 rajveer 810 
    """
811 
    pass
812 
 
4259 anupam.sin 813 
  def refundTransaction(self, transactionId, refundedBy, reason):
814 
    """
815 
    This method is called when a flagged payment is deemed unserviceable and the corresponding orders
816 
    need to be cancelled
4247 rajveer 817 
 
4259 anupam.sin 818 
    Parameters:
819 
     - transactionId
820 
     - refundedBy
821 
     - reason
822 
    """
823 
    pass
824 
 
4324 mandeep.dh 825 
  def updateShipmentAddress(self, orderId, addressId):
826 
    """
827 
    Updates shipment address of an order. Delivery and shipping date estimates
828 
    etc. are also updated here.
829 
 
830 
    Throws TransactionServiceException in case address change is not
831 
    possible due to certain reasons such as new pincode in address is
832 
    not serviceable etc.
833 
 
834 
    Parameters:
835 
     - orderId
836 
     - addressId
837 
    """
838 
    pass
839 
 
4285 rajveer 840 
  def acceptOrdersForItemId(self, itemId, inventory):
841 
    """
842 
    Marks the orders as ACCEPTED for the given itemId and inventory. It also updates the accepted timestamp. If the
843 
    given order is not a COD order, it also captures the payment if the same has not been captured.
4259 anupam.sin 844 
 
4285 rajveer 845 
    Parameters:
846 
     - itemId
847 
     - inventory
848 
    """
849 
    pass
850 
 
4369 rajveer 851 
  def markOrdersAsPORaised(self, vendorId, itemId, quantity, estimate, isReminder):
4303 rajveer 852 
    """
853 
    Parameters:
854 
     - vendorId
855 
     - itemId
856 
     - quantity
857 
     - estimate
4369 rajveer 858 
     - isReminder
4303 rajveer 859 
    """
860 
    pass
4285 rajveer 861 
 
4369 rajveer 862 
  def markOrdersAsReversalInitiated(self, vendorId, itemId, quantity, estimate, isReminder):
4303 rajveer 863 
    """
864 
    Parameters:
865 
     - vendorId
866 
     - itemId
867 
     - quantity
868 
     - estimate
4369 rajveer 869 
     - isReminder
4303 rajveer 870 
    """
871 
    pass
872 
 
4369 rajveer 873 
  def markOrdersAsNotAvailabke(self, vendorId, itemId, quantity, estimate, isReminder):
4303 rajveer 874 
    """
875 
    Parameters:
876 
     - vendorId
877 
     - itemId
878 
     - quantity
879 
     - estimate
4369 rajveer 880 
     - isReminder
4303 rajveer 881 
    """
882 
    pass
883 
 
4369 rajveer 884 
  def markOrdersAsTimeout(self, vendorId):
885 
    """
886 
    Parameters:
887 
     - vendorId
888 
    """
889 
    pass
4303 rajveer 890 
 
4662 rajveer 891 
  def markOrderAsLostInTransit(self, orderId):
892 
    """
893 
    Mark order as LOST_IN_TRANSIT
894 
 
895 
    Parameters:
896 
     - orderId
897 
    """
898 
    pass
899 
 
4386 anupam.sin 900 
  def getOrderForAwb(self, awb):
901 
    """
902 
    Returns the order corresponding to an AWB number
4369 rajveer 903 
 
4386 anupam.sin 904 
    Parameters:
905 
     - awb
906 
    """
907 
    pass
908 
 
4506 phani.kuma 909 
  def getOrdersForProviderForStatus(self, logistics_provider_id, order_status):
910 
    """
911 
    Returns the order corresponding to a logistics provider id for a given order status
4386 anupam.sin 912 
 
4506 phani.kuma 913 
    Parameters:
914 
     - logistics_provider_id
915 
     - order_status
916 
    """
917 
    pass
918 
 
4600 varun.gupt 919 
  def getBilledOrdersForVendor(self, vendorId, billingDateFrom, billingDateTo):
920 
    """
921 
    Returns list of orders fullfiled from a certain vendor and billed in a given date range
4506 phani.kuma 922 
 
4600 varun.gupt 923 
    Parameters:
924 
     - vendorId
925 
     - billingDateFrom
926 
     - billingDateTo
927 
    """
928 
    pass
929 
 
4607 rajveer 930 
  def getSlippedSippingDateOrders(self, ):
931 
    pass
932 
 
4709 rajveer 933 
  def getCancelledOrders(self, cancelDateFrom, cancelDateTo):
934 
    """
935 
    Parameters:
936 
     - cancelDateFrom
937 
     - cancelDateTo
938 
    """
939 
    pass
940 
 
4600 varun.gupt 941 
  def saveBluedartSettlements(self, mapAWBAndAmount):
942 
    """
943 
    Parameters:
944 
     - mapAWBAndAmount
945 
    """
946 
    pass
947 
 
948 
  def savePaymentSettlements(self, settlementDate, paymentGatewayId, paymentId, serviceTax, otherCharges, netCollection):
949 
    """
950 
    Parameters:
951 
     - settlementDate
952 
     - paymentGatewayId
953 
     - paymentId
954 
     - serviceTax
955 
     - otherCharges
956 
     - netCollection
957 
    """
958 
    pass
959 
 
4875 varun.gupt 960 
  def saveCODPaymentSettlement(self, orderId, settlementDate, collection):
961 
    """
962 
    Parameters:
963 
     - orderId
964 
     - settlementDate
965 
     - collection
966 
    """
967 
    pass
968 
 
4600 varun.gupt 969 
  def saveEBSSettlementSummary(self, settlementId, settlementDate, transactionDateFrom, transactionDateTo, amount):
970 
    """
971 
    Parameters:
972 
     - settlementId
973 
     - settlementDate
974 
     - transactionDateFrom
975 
     - transactionDateTo
976 
     - amount
977 
    """
978 
    pass
979 
 
980 
  def getSettlementForPaymentId(self, paymentId):
981 
    """
982 
    Parameters:
983 
     - paymentId
984 
    """
985 
    pass
986 
 
987 
  def getEBSSettlementSummaries(self, ):
988 
    pass
989 
 
990 
  def markEBSSettlementUploaded(self, settlementId):
991 
    """
992 
    Parameters:
993 
     - settlementId
994 
    """
995 
    pass
996 
 
997 
  def getEBSSettlementDate(self, settlementId):
998 
    """
999 
    Parameters:
1000 
     - settlementId
1001 
    """
1002 
    pass
1003 
 
4715 varun.gupt 1004 
  def getSettlementsByDate(self, settlementDateFrom, settlementDateTo, isRefund):
1005 
    """
1006 
    Parameters:
1007 
     - settlementDateFrom
1008 
     - settlementDateTo
1009 
     - isRefund
1010 
    """
1011 
    pass
4600 varun.gupt 1012 
 
4715 varun.gupt 1013 
  def getReshippedOrderIds(self, orderIds):
1014 
    """
1015 
    Returns list of Order Ids, which belong to reshiped orders, shortlisted from a given list of Order Ids
1016 
 
1017 
    Parameters:
1018 
     - orderIds
1019 
    """
1020 
    pass
1021 
 
4757 mandeep.dh 1022 
  def updateOrdersAsPORaised(self, itemIdQuantityMap, purchaseOrderId, warehouseId):
1023 
    """
1024 
    Updates orders as PO raised. Also updates purchase order id in orders. Pass a map of items mapped to
1025 
    the quantities for which the PO is raised.
4715 varun.gupt 1026 
 
4757 mandeep.dh 1027 
    Parameters:
1028 
     - itemIdQuantityMap
1029 
     - purchaseOrderId
1030 
     - warehouseId
1031 
    """
1032 
    pass
1033 
 
4875 varun.gupt 1034 
  def getOrdersWhereVendorNotPaid(self, vendorId):
1035 
    """
1036 
    Parameters:
1037 
     - vendorId
1038 
    """
1039 
    pass
4757 mandeep.dh 1040 
 
4875 varun.gupt 1041 
 
3376 rajveer 1042 
class Client(shop2020.thriftpy.generic.GenericService.Client, Iface):
94 ashish 1043 
  def __init__(self, iprot, oprot=None):
3376 rajveer 1044 
    shop2020.thriftpy.generic.GenericService.Client.__init__(self, iprot, oprot)
94 ashish 1045 
 
1046 
  def createTransaction(self, transaction):
1047 
    """
1048 
    Parameters:
1049 
     - transaction
1050 
    """
1051 
    self.send_createTransaction(transaction)
132 ashish 1052 
    return self.recv_createTransaction()
94 ashish 1053 
 
1054 
  def send_createTransaction(self, transaction):
1055 
    self._oprot.writeMessageBegin('createTransaction', TMessageType.CALL, self._seqid)
1056 
    args = createTransaction_args()
1057 
    args.transaction = transaction
1058 
    args.write(self._oprot)
1059 
    self._oprot.writeMessageEnd()
1060 
    self._oprot.trans.flush()
1061 
 
1062 
  def recv_createTransaction(self, ):
1063 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1064 
    if mtype == TMessageType.EXCEPTION:
1065 
      x = TApplicationException()
1066 
      x.read(self._iprot)
1067 
      self._iprot.readMessageEnd()
1068 
      raise x
1069 
    result = createTransaction_result()
1070 
    result.read(self._iprot)
1071 
    self._iprot.readMessageEnd()
3431 rajveer 1072 
    if result.success is not None:
132 ashish 1073 
      return result.success
3431 rajveer 1074 
    if result.ex is not None:
94 ashish 1075 
      raise result.ex
132 ashish 1076 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "createTransaction failed: unknown result");
94 ashish 1077 
 
1078 
  def getTransaction(self, id):
1079 
    """
1080 
    Parameters:
1081 
     - id
1082 
    """
1083 
    self.send_getTransaction(id)
1084 
    return self.recv_getTransaction()
1085 
 
1086 
  def send_getTransaction(self, id):
1087 
    self._oprot.writeMessageBegin('getTransaction', TMessageType.CALL, self._seqid)
1088 
    args = getTransaction_args()
1089 
    args.id = id
1090 
    args.write(self._oprot)
1091 
    self._oprot.writeMessageEnd()
1092 
    self._oprot.trans.flush()
1093 
 
1094 
  def recv_getTransaction(self, ):
1095 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1096 
    if mtype == TMessageType.EXCEPTION:
1097 
      x = TApplicationException()
1098 
      x.read(self._iprot)
1099 
      self._iprot.readMessageEnd()
1100 
      raise x
1101 
    result = getTransaction_result()
1102 
    result.read(self._iprot)
1103 
    self._iprot.readMessageEnd()
3431 rajveer 1104 
    if result.success is not None:
94 ashish 1105 
      return result.success
3431 rajveer 1106 
    if result.ex is not None:
94 ashish 1107 
      raise result.ex
1108 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getTransaction failed: unknown result");
1109 
 
1110 
  def getTransactionsForCustomer(self, customerId, from_date, to_date, status):
1111 
    """
1112 
    Parameters:
1113 
     - customerId
1114 
     - from_date
1115 
     - to_date
1116 
     - status
1117 
    """
1118 
    self.send_getTransactionsForCustomer(customerId, from_date, to_date, status)
1119 
    return self.recv_getTransactionsForCustomer()
1120 
 
1121 
  def send_getTransactionsForCustomer(self, customerId, from_date, to_date, status):
1122 
    self._oprot.writeMessageBegin('getTransactionsForCustomer', TMessageType.CALL, self._seqid)
1123 
    args = getTransactionsForCustomer_args()
1124 
    args.customerId = customerId
1125 
    args.from_date = from_date
1126 
    args.to_date = to_date
1127 
    args.status = status
1128 
    args.write(self._oprot)
1129 
    self._oprot.writeMessageEnd()
1130 
    self._oprot.trans.flush()
1131 
 
1132 
  def recv_getTransactionsForCustomer(self, ):
1133 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1134 
    if mtype == TMessageType.EXCEPTION:
1135 
      x = TApplicationException()
1136 
      x.read(self._iprot)
1137 
      self._iprot.readMessageEnd()
1138 
      raise x
1139 
    result = getTransactionsForCustomer_result()
1140 
    result.read(self._iprot)
1141 
    self._iprot.readMessageEnd()
3431 rajveer 1142 
    if result.success is not None:
94 ashish 1143 
      return result.success
3431 rajveer 1144 
    if result.ex is not None:
94 ashish 1145 
      raise result.ex
1146 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getTransactionsForCustomer failed: unknown result");
1147 
 
132 ashish 1148 
  def getTransactionsForShoppingCartId(self, shoppingCartId):
1149 
    """
1150 
    Parameters:
1151 
     - shoppingCartId
1152 
    """
1153 
    self.send_getTransactionsForShoppingCartId(shoppingCartId)
1154 
    return self.recv_getTransactionsForShoppingCartId()
1155 
 
1156 
  def send_getTransactionsForShoppingCartId(self, shoppingCartId):
1157 
    self._oprot.writeMessageBegin('getTransactionsForShoppingCartId', TMessageType.CALL, self._seqid)
1158 
    args = getTransactionsForShoppingCartId_args()
1159 
    args.shoppingCartId = shoppingCartId
1160 
    args.write(self._oprot)
1161 
    self._oprot.writeMessageEnd()
1162 
    self._oprot.trans.flush()
1163 
 
1164 
  def recv_getTransactionsForShoppingCartId(self, ):
1165 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1166 
    if mtype == TMessageType.EXCEPTION:
1167 
      x = TApplicationException()
1168 
      x.read(self._iprot)
1169 
      self._iprot.readMessageEnd()
1170 
      raise x
1171 
    result = getTransactionsForShoppingCartId_result()
1172 
    result.read(self._iprot)
1173 
    self._iprot.readMessageEnd()
3431 rajveer 1174 
    if result.success is not None:
132 ashish 1175 
      return result.success
3431 rajveer 1176 
    if result.ex is not None:
132 ashish 1177 
      raise result.ex
1178 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getTransactionsForShoppingCartId failed: unknown result");
1179 
 
94 ashish 1180 
  def getTransactionStatus(self, transactionId):
1181 
    """
1182 
    Parameters:
1183 
     - transactionId
1184 
    """
1185 
    self.send_getTransactionStatus(transactionId)
1186 
    return self.recv_getTransactionStatus()
1187 
 
1188 
  def send_getTransactionStatus(self, transactionId):
1189 
    self._oprot.writeMessageBegin('getTransactionStatus', TMessageType.CALL, self._seqid)
1190 
    args = getTransactionStatus_args()
1191 
    args.transactionId = transactionId
1192 
    args.write(self._oprot)
1193 
    self._oprot.writeMessageEnd()
1194 
    self._oprot.trans.flush()
1195 
 
1196 
  def recv_getTransactionStatus(self, ):
1197 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1198 
    if mtype == TMessageType.EXCEPTION:
1199 
      x = TApplicationException()
1200 
      x.read(self._iprot)
1201 
      self._iprot.readMessageEnd()
1202 
      raise x
1203 
    result = getTransactionStatus_result()
1204 
    result.read(self._iprot)
1205 
    self._iprot.readMessageEnd()
3431 rajveer 1206 
    if result.success is not None:
94 ashish 1207 
      return result.success
3431 rajveer 1208 
    if result.ex is not None:
94 ashish 1209 
      raise result.ex
1210 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getTransactionStatus failed: unknown result");
1211 
 
1212 
  def changeTransactionStatus(self, transactionId, status, description):
1213 
    """
1214 
    Parameters:
1215 
     - transactionId
1216 
     - status
1217 
     - description
1218 
    """
1219 
    self.send_changeTransactionStatus(transactionId, status, description)
1220 
    return self.recv_changeTransactionStatus()
1221 
 
1222 
  def send_changeTransactionStatus(self, transactionId, status, description):
1223 
    self._oprot.writeMessageBegin('changeTransactionStatus', TMessageType.CALL, self._seqid)
1224 
    args = changeTransactionStatus_args()
1225 
    args.transactionId = transactionId
1226 
    args.status = status
1227 
    args.description = description
1228 
    args.write(self._oprot)
1229 
    self._oprot.writeMessageEnd()
1230 
    self._oprot.trans.flush()
1231 
 
1232 
  def recv_changeTransactionStatus(self, ):
1233 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1234 
    if mtype == TMessageType.EXCEPTION:
1235 
      x = TApplicationException()
1236 
      x.read(self._iprot)
1237 
      self._iprot.readMessageEnd()
1238 
      raise x
1239 
    result = changeTransactionStatus_result()
1240 
    result.read(self._iprot)
1241 
    self._iprot.readMessageEnd()
3431 rajveer 1242 
    if result.success is not None:
94 ashish 1243 
      return result.success
3431 rajveer 1244 
    if result.ex is not None:
94 ashish 1245 
      raise result.ex
1246 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "changeTransactionStatus failed: unknown result");
1247 
 
1398 varun.gupt 1248 
  def enqueueTransactionInfoEmail(self, transactionId):
1382 varun.gupt 1249 
    """
1250 
    Parameters:
1251 
     - transactionId
1252 
    """
1398 varun.gupt 1253 
    self.send_enqueueTransactionInfoEmail(transactionId)
1254 
    return self.recv_enqueueTransactionInfoEmail()
1382 varun.gupt 1255 
 
1398 varun.gupt 1256 
  def send_enqueueTransactionInfoEmail(self, transactionId):
1257 
    self._oprot.writeMessageBegin('enqueueTransactionInfoEmail', TMessageType.CALL, self._seqid)
1258 
    args = enqueueTransactionInfoEmail_args()
1382 varun.gupt 1259 
    args.transactionId = transactionId
1260 
    args.write(self._oprot)
1261 
    self._oprot.writeMessageEnd()
1262 
    self._oprot.trans.flush()
1263 
 
1398 varun.gupt 1264 
  def recv_enqueueTransactionInfoEmail(self, ):
1382 varun.gupt 1265 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1266 
    if mtype == TMessageType.EXCEPTION:
1267 
      x = TApplicationException()
1268 
      x.read(self._iprot)
1269 
      self._iprot.readMessageEnd()
1270 
      raise x
1398 varun.gupt 1271 
    result = enqueueTransactionInfoEmail_result()
1382 varun.gupt 1272 
    result.read(self._iprot)
1273 
    self._iprot.readMessageEnd()
3431 rajveer 1274 
    if result.success is not None:
1382 varun.gupt 1275 
      return result.success
3431 rajveer 1276 
    if result.ex is not None:
1382 varun.gupt 1277 
      raise result.ex
1398 varun.gupt 1278 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "enqueueTransactionInfoEmail failed: unknown result");
1382 varun.gupt 1279 
 
4801 anupam.sin 1280 
  def getAllOrders(self, statuses, from_date, to_date, warehouse_id):
94 ashish 1281 
    """
1282 
    Parameters:
4801 anupam.sin 1283 
     - statuses
483 rajveer 1284 
     - from_date
1285 
     - to_date
1286 
     - warehouse_id
94 ashish 1287 
    """
4801 anupam.sin 1288 
    self.send_getAllOrders(statuses, from_date, to_date, warehouse_id)
483 rajveer 1289 
    return self.recv_getAllOrders()
94 ashish 1290 
 
4801 anupam.sin 1291 
  def send_getAllOrders(self, statuses, from_date, to_date, warehouse_id):
483 rajveer 1292 
    self._oprot.writeMessageBegin('getAllOrders', TMessageType.CALL, self._seqid)
1293 
    args = getAllOrders_args()
4801 anupam.sin 1294 
    args.statuses = statuses
483 rajveer 1295 
    args.from_date = from_date
1296 
    args.to_date = to_date
1297 
    args.warehouse_id = warehouse_id
94 ashish 1298 
    args.write(self._oprot)
1299 
    self._oprot.writeMessageEnd()
1300 
    self._oprot.trans.flush()
1301 
 
483 rajveer 1302 
  def recv_getAllOrders(self, ):
94 ashish 1303 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1304 
    if mtype == TMessageType.EXCEPTION:
1305 
      x = TApplicationException()
1306 
      x.read(self._iprot)
1307 
      self._iprot.readMessageEnd()
1308 
      raise x
483 rajveer 1309 
    result = getAllOrders_result()
94 ashish 1310 
    result.read(self._iprot)
1311 
    self._iprot.readMessageEnd()
3431 rajveer 1312 
    if result.success is not None:
94 ashish 1313 
      return result.success
3431 rajveer 1314 
    if result.ex is not None:
94 ashish 1315 
      raise result.ex
483 rajveer 1316 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAllOrders failed: unknown result");
94 ashish 1317 
 
4133 chandransh 1318 
  def getOrdersInBatch(self, statuses, offset, limit, warehouse_id):
1319 
    """
1320 
    Returns at most 'limit' orders with the given statuses for the given warehouse starting from the given offset.
1321 
    Pass the status as null and the limit as 0 to ignore them.
1322 
 
1323 
    Parameters:
1324 
     - statuses
1325 
     - offset
1326 
     - limit
1327 
     - warehouse_id
1328 
    """
1329 
    self.send_getOrdersInBatch(statuses, offset, limit, warehouse_id)
1330 
    return self.recv_getOrdersInBatch()
1331 
 
1332 
  def send_getOrdersInBatch(self, statuses, offset, limit, warehouse_id):
1333 
    self._oprot.writeMessageBegin('getOrdersInBatch', TMessageType.CALL, self._seqid)
1334 
    args = getOrdersInBatch_args()
1335 
    args.statuses = statuses
1336 
    args.offset = offset
1337 
    args.limit = limit
1338 
    args.warehouse_id = warehouse_id
1339 
    args.write(self._oprot)
1340 
    self._oprot.writeMessageEnd()
1341 
    self._oprot.trans.flush()
1342 
 
1343 
  def recv_getOrdersInBatch(self, ):
1344 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1345 
    if mtype == TMessageType.EXCEPTION:
1346 
      x = TApplicationException()
1347 
      x.read(self._iprot)
1348 
      self._iprot.readMessageEnd()
1349 
      raise x
1350 
    result = getOrdersInBatch_result()
1351 
    result.read(self._iprot)
1352 
    self._iprot.readMessageEnd()
1353 
    if result.success is not None:
1354 
      return result.success
1355 
    if result.ex is not None:
1356 
      raise result.ex
1357 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getOrdersInBatch failed: unknown result");
1358 
 
1359 
  def getOrderCount(self, statuses, warehouseId):
1360 
    """
1361 
    Returns the count of orders with the given statuses assigned to the given warehouse.
1362 
 
1363 
    Parameters:
1364 
     - statuses
1365 
     - warehouseId
1366 
    """
1367 
    self.send_getOrderCount(statuses, warehouseId)
1368 
    return self.recv_getOrderCount()
1369 
 
1370 
  def send_getOrderCount(self, statuses, warehouseId):
1371 
    self._oprot.writeMessageBegin('getOrderCount', TMessageType.CALL, self._seqid)
1372 
    args = getOrderCount_args()
1373 
    args.statuses = statuses
1374 
    args.warehouseId = warehouseId
1375 
    args.write(self._oprot)
1376 
    self._oprot.writeMessageEnd()
1377 
    self._oprot.trans.flush()
1378 
 
1379 
  def recv_getOrderCount(self, ):
1380 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1381 
    if mtype == TMessageType.EXCEPTION:
1382 
      x = TApplicationException()
1383 
      x.read(self._iprot)
1384 
      self._iprot.readMessageEnd()
1385 
      raise x
1386 
    result = getOrderCount_result()
1387 
    result.read(self._iprot)
1388 
    self._iprot.readMessageEnd()
1389 
    if result.success is not None:
1390 
      return result.success
1391 
    if result.ex is not None:
1392 
      raise result.ex
1393 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getOrderCount failed: unknown result");
1394 
 
999 varun.gupt 1395 
  def getOrdersByBillingDate(self, status, start_billing_date, end_billing_date, warehouse_id):
1396 
    """
1132 chandransh 1397 
    Returns orders within a range of their billing dates
3431 rajveer 1398 
 
999 varun.gupt 1399 
    Parameters:
1400 
     - status
1401 
     - start_billing_date
1402 
     - end_billing_date
1403 
     - warehouse_id
1404 
    """
1405 
    self.send_getOrdersByBillingDate(status, start_billing_date, end_billing_date, warehouse_id)
1406 
    return self.recv_getOrdersByBillingDate()
1407 
 
1408 
  def send_getOrdersByBillingDate(self, status, start_billing_date, end_billing_date, warehouse_id):
1409 
    self._oprot.writeMessageBegin('getOrdersByBillingDate', TMessageType.CALL, self._seqid)
1410 
    args = getOrdersByBillingDate_args()
1411 
    args.status = status
1412 
    args.start_billing_date = start_billing_date
1413 
    args.end_billing_date = end_billing_date
1414 
    args.warehouse_id = warehouse_id
1415 
    args.write(self._oprot)
1416 
    self._oprot.writeMessageEnd()
1417 
    self._oprot.trans.flush()
1418 
 
1419 
  def recv_getOrdersByBillingDate(self, ):
1420 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1421 
    if mtype == TMessageType.EXCEPTION:
1422 
      x = TApplicationException()
1423 
      x.read(self._iprot)
1424 
      self._iprot.readMessageEnd()
1425 
      raise x
1426 
    result = getOrdersByBillingDate_result()
1427 
    result.read(self._iprot)
1428 
    self._iprot.readMessageEnd()
3431 rajveer 1429 
    if result.success is not None:
999 varun.gupt 1430 
      return result.success
3431 rajveer 1431 
    if result.ex is not None:
999 varun.gupt 1432 
      raise result.ex
1433 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getOrdersByBillingDate failed: unknown result");
1434 
 
3451 chandransh 1435 
  def getOrdersByShippingDate(self, fromShippingDate, toShippingDate, providerId, warehouseId, cod):
3427 chandransh 1436 
    """
1437 
    Returns orders for a particular provider and warehouse which were shipped between the given dates.
3451 chandransh 1438 
    Returned orders comprise of COD orders if cod parameter is true. It comprises of prepaid orders otherwise.
1439 
    Pass providerId and warehouseId as -1 to ignore both these parameters.
3431 rajveer 1440 
 
3427 chandransh 1441 
    Parameters:
1442 
     - fromShippingDate
1443 
     - toShippingDate
1444 
     - providerId
1445 
     - warehouseId
3451 chandransh 1446 
     - cod
3427 chandransh 1447 
    """
3451 chandransh 1448 
    self.send_getOrdersByShippingDate(fromShippingDate, toShippingDate, providerId, warehouseId, cod)
3427 chandransh 1449 
    return self.recv_getOrdersByShippingDate()
1450 
 
3451 chandransh 1451 
  def send_getOrdersByShippingDate(self, fromShippingDate, toShippingDate, providerId, warehouseId, cod):
3427 chandransh 1452 
    self._oprot.writeMessageBegin('getOrdersByShippingDate', TMessageType.CALL, self._seqid)
1453 
    args = getOrdersByShippingDate_args()
1454 
    args.fromShippingDate = fromShippingDate
1455 
    args.toShippingDate = toShippingDate
1456 
    args.providerId = providerId
1457 
    args.warehouseId = warehouseId
3451 chandransh 1458 
    args.cod = cod
3427 chandransh 1459 
    args.write(self._oprot)
1460 
    self._oprot.writeMessageEnd()
1461 
    self._oprot.trans.flush()
1462 
 
1463 
  def recv_getOrdersByShippingDate(self, ):
1464 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1465 
    if mtype == TMessageType.EXCEPTION:
1466 
      x = TApplicationException()
1467 
      x.read(self._iprot)
1468 
      self._iprot.readMessageEnd()
1469 
      raise x
1470 
    result = getOrdersByShippingDate_result()
1471 
    result.read(self._iprot)
1472 
    self._iprot.readMessageEnd()
3431 rajveer 1473 
    if result.success is not None:
3427 chandransh 1474 
      return result.success
3431 rajveer 1475 
    if result.ex is not None:
3427 chandransh 1476 
      raise result.ex
1477 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getOrdersByShippingDate failed: unknown result");
1478 
 
1382 varun.gupt 1479 
  def getReturnableOrdersForCustomer(self, customer_id, limit):
1480 
    """
1481 
    Returns order ids for orders which can be returned
3431 rajveer 1482 
 
1382 varun.gupt 1483 
    Parameters:
1484 
     - customer_id
1485 
     - limit
1486 
    """
1487 
    self.send_getReturnableOrdersForCustomer(customer_id, limit)
1488 
    return self.recv_getReturnableOrdersForCustomer()
1489 
 
1490 
  def send_getReturnableOrdersForCustomer(self, customer_id, limit):
1491 
    self._oprot.writeMessageBegin('getReturnableOrdersForCustomer', TMessageType.CALL, self._seqid)
1492 
    args = getReturnableOrdersForCustomer_args()
1493 
    args.customer_id = customer_id
1494 
    args.limit = limit
1495 
    args.write(self._oprot)
1496 
    self._oprot.writeMessageEnd()
1497 
    self._oprot.trans.flush()
1498 
 
1499 
  def recv_getReturnableOrdersForCustomer(self, ):
1500 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1501 
    if mtype == TMessageType.EXCEPTION:
1502 
      x = TApplicationException()
1503 
      x.read(self._iprot)
1504 
      self._iprot.readMessageEnd()
1505 
      raise x
1506 
    result = getReturnableOrdersForCustomer_result()
1507 
    result.read(self._iprot)
1508 
    self._iprot.readMessageEnd()
3431 rajveer 1509 
    if result.success is not None:
1382 varun.gupt 1510 
      return result.success
3431 rajveer 1511 
    if result.ex is not None:
1382 varun.gupt 1512 
      raise result.ex
1513 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getReturnableOrdersForCustomer failed: unknown result");
1514 
 
1515 
  def getCancellableOrdersForCustomer(self, customer_id, limit):
1516 
    """
1517 
    Returns order ids for orders which can be cancelled
3431 rajveer 1518 
 
1382 varun.gupt 1519 
    Parameters:
1520 
     - customer_id
1521 
     - limit
1522 
    """
1523 
    self.send_getCancellableOrdersForCustomer(customer_id, limit)
1524 
    return self.recv_getCancellableOrdersForCustomer()
1525 
 
1526 
  def send_getCancellableOrdersForCustomer(self, customer_id, limit):
1527 
    self._oprot.writeMessageBegin('getCancellableOrdersForCustomer', TMessageType.CALL, self._seqid)
1528 
    args = getCancellableOrdersForCustomer_args()
1529 
    args.customer_id = customer_id
1530 
    args.limit = limit
1531 
    args.write(self._oprot)
1532 
    self._oprot.writeMessageEnd()
1533 
    self._oprot.trans.flush()
1534 
 
1535 
  def recv_getCancellableOrdersForCustomer(self, ):
1536 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1537 
    if mtype == TMessageType.EXCEPTION:
1538 
      x = TApplicationException()
1539 
      x.read(self._iprot)
1540 
      self._iprot.readMessageEnd()
1541 
      raise x
1542 
    result = getCancellableOrdersForCustomer_result()
1543 
    result.read(self._iprot)
1544 
    self._iprot.readMessageEnd()
3431 rajveer 1545 
    if result.success is not None:
1382 varun.gupt 1546 
      return result.success
3431 rajveer 1547 
    if result.ex is not None:
1382 varun.gupt 1548 
      raise result.ex
1549 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getCancellableOrdersForCustomer failed: unknown result");
1550 
 
483 rajveer 1551 
  def changeOrderStatus(self, orderId, status, description):
94 ashish 1552 
    """
1553 
    Parameters:
483 rajveer 1554 
     - orderId
1555 
     - status
1556 
     - description
94 ashish 1557 
    """
483 rajveer 1558 
    self.send_changeOrderStatus(orderId, status, description)
1559 
    return self.recv_changeOrderStatus()
94 ashish 1560 
 
483 rajveer 1561 
  def send_changeOrderStatus(self, orderId, status, description):
1562 
    self._oprot.writeMessageBegin('changeOrderStatus', TMessageType.CALL, self._seqid)
1563 
    args = changeOrderStatus_args()
1564 
    args.orderId = orderId
1565 
    args.status = status
1566 
    args.description = description
94 ashish 1567 
    args.write(self._oprot)
1568 
    self._oprot.writeMessageEnd()
1569 
    self._oprot.trans.flush()
1570 
 
483 rajveer 1571 
  def recv_changeOrderStatus(self, ):
94 ashish 1572 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1573 
    if mtype == TMessageType.EXCEPTION:
1574 
      x = TApplicationException()
1575 
      x.read(self._iprot)
1576 
      self._iprot.readMessageEnd()
1577 
      raise x
483 rajveer 1578 
    result = changeOrderStatus_result()
94 ashish 1579 
    result.read(self._iprot)
1580 
    self._iprot.readMessageEnd()
3431 rajveer 1581 
    if result.success is not None:
94 ashish 1582 
      return result.success
3431 rajveer 1583 
    if result.ex is not None:
94 ashish 1584 
      raise result.ex
483 rajveer 1585 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "changeOrderStatus failed: unknown result");
94 ashish 1586 
 
1528 ankur.sing 1587 
  def getOrdersForTransaction(self, transactionId, customerId):
94 ashish 1588 
    """
1528 ankur.sing 1589 
    Returns list of orders for given transaction Id. Also filters based on customer Id so that
1590 
    only user who owns the transaction can view its order details.
3431 rajveer 1591 
 
94 ashish 1592 
    Parameters:
1593 
     - transactionId
1528 ankur.sing 1594 
     - customerId
94 ashish 1595 
    """
1528 ankur.sing 1596 
    self.send_getOrdersForTransaction(transactionId, customerId)
483 rajveer 1597 
    return self.recv_getOrdersForTransaction()
94 ashish 1598 
 
1528 ankur.sing 1599 
  def send_getOrdersForTransaction(self, transactionId, customerId):
483 rajveer 1600 
    self._oprot.writeMessageBegin('getOrdersForTransaction', TMessageType.CALL, self._seqid)
1601 
    args = getOrdersForTransaction_args()
94 ashish 1602 
    args.transactionId = transactionId
1528 ankur.sing 1603 
    args.customerId = customerId
94 ashish 1604 
    args.write(self._oprot)
1605 
    self._oprot.writeMessageEnd()
1606 
    self._oprot.trans.flush()
1607 
 
483 rajveer 1608 
  def recv_getOrdersForTransaction(self, ):
94 ashish 1609 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1610 
    if mtype == TMessageType.EXCEPTION:
1611 
      x = TApplicationException()
1612 
      x.read(self._iprot)
1613 
      self._iprot.readMessageEnd()
1614 
      raise x
483 rajveer 1615 
    result = getOrdersForTransaction_result()
94 ashish 1616 
    result.read(self._iprot)
1617 
    self._iprot.readMessageEnd()
3431 rajveer 1618 
    if result.success is not None:
94 ashish 1619 
      return result.success
3431 rajveer 1620 
    if result.ex is not None:
94 ashish 1621 
      raise result.ex
483 rajveer 1622 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getOrdersForTransaction failed: unknown result");
94 ashish 1623 
 
3014 chandransh 1624 
  def getOrdersForCustomer(self, customerId, from_date, to_date, statuses):
94 ashish 1625 
    """
3014 chandransh 1626 
    Returns list of orders for the given customer created between the given dates and having the given statuses.
1627 
    Pass and empty list to ignore filtering on statuses.
3431 rajveer 1628 
 
94 ashish 1629 
    Parameters:
483 rajveer 1630 
     - customerId
1631 
     - from_date
1632 
     - to_date
3014 chandransh 1633 
     - statuses
94 ashish 1634 
    """
3014 chandransh 1635 
    self.send_getOrdersForCustomer(customerId, from_date, to_date, statuses)
483 rajveer 1636 
    return self.recv_getOrdersForCustomer()
94 ashish 1637 
 
3014 chandransh 1638 
  def send_getOrdersForCustomer(self, customerId, from_date, to_date, statuses):
483 rajveer 1639 
    self._oprot.writeMessageBegin('getOrdersForCustomer', TMessageType.CALL, self._seqid)
1640 
    args = getOrdersForCustomer_args()
1641 
    args.customerId = customerId
1642 
    args.from_date = from_date
1643 
    args.to_date = to_date
3014 chandransh 1644 
    args.statuses = statuses
94 ashish 1645 
    args.write(self._oprot)
1646 
    self._oprot.writeMessageEnd()
1647 
    self._oprot.trans.flush()
1648 
 
483 rajveer 1649 
  def recv_getOrdersForCustomer(self, ):
94 ashish 1650 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1651 
    if mtype == TMessageType.EXCEPTION:
1652 
      x = TApplicationException()
1653 
      x.read(self._iprot)
1654 
      self._iprot.readMessageEnd()
1655 
      raise x
483 rajveer 1656 
    result = getOrdersForCustomer_result()
94 ashish 1657 
    result.read(self._iprot)
1658 
    self._iprot.readMessageEnd()
3431 rajveer 1659 
    if result.success is not None:
94 ashish 1660 
      return result.success
3431 rajveer 1661 
    if result.ex is not None:
94 ashish 1662 
      raise result.ex
483 rajveer 1663 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getOrdersForCustomer failed: unknown result");
94 ashish 1664 
 
483 rajveer 1665 
  def createOrder(self, order):
94 ashish 1666 
    """
1667 
    Parameters:
483 rajveer 1668 
     - order
94 ashish 1669 
    """
483 rajveer 1670 
    self.send_createOrder(order)
1671 
    return self.recv_createOrder()
94 ashish 1672 
 
483 rajveer 1673 
  def send_createOrder(self, order):
1674 
    self._oprot.writeMessageBegin('createOrder', TMessageType.CALL, self._seqid)
1675 
    args = createOrder_args()
1676 
    args.order = order
94 ashish 1677 
    args.write(self._oprot)
1678 
    self._oprot.writeMessageEnd()
1679 
    self._oprot.trans.flush()
1680 
 
483 rajveer 1681 
  def recv_createOrder(self, ):
94 ashish 1682 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1683 
    if mtype == TMessageType.EXCEPTION:
1684 
      x = TApplicationException()
1685 
      x.read(self._iprot)
1686 
      self._iprot.readMessageEnd()
1687 
      raise x
483 rajveer 1688 
    result = createOrder_result()
94 ashish 1689 
    result.read(self._iprot)
1690 
    self._iprot.readMessageEnd()
3431 rajveer 1691 
    if result.success is not None:
94 ashish 1692 
      return result.success
3431 rajveer 1693 
    if result.ex is not None:
94 ashish 1694 
      raise result.ex
483 rajveer 1695 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "createOrder failed: unknown result");
94 ashish 1696 
 
483 rajveer 1697 
  def getOrder(self, id):
94 ashish 1698 
    """
1699 
    Parameters:
483 rajveer 1700 
     - id
94 ashish 1701 
    """
483 rajveer 1702 
    self.send_getOrder(id)
1703 
    return self.recv_getOrder()
94 ashish 1704 
 
483 rajveer 1705 
  def send_getOrder(self, id):
1706 
    self._oprot.writeMessageBegin('getOrder', TMessageType.CALL, self._seqid)
1707 
    args = getOrder_args()
1708 
    args.id = id
94 ashish 1709 
    args.write(self._oprot)
1710 
    self._oprot.writeMessageEnd()
1711 
    self._oprot.trans.flush()
1712 
 
483 rajveer 1713 
  def recv_getOrder(self, ):
94 ashish 1714 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1715 
    if mtype == TMessageType.EXCEPTION:
1716 
      x = TApplicationException()
1717 
      x.read(self._iprot)
1718 
      self._iprot.readMessageEnd()
1719 
      raise x
483 rajveer 1720 
    result = getOrder_result()
94 ashish 1721 
    result.read(self._iprot)
1722 
    self._iprot.readMessageEnd()
3431 rajveer 1723 
    if result.success is not None:
94 ashish 1724 
      return result.success
3431 rajveer 1725 
    if result.ex is not None:
94 ashish 1726 
      raise result.ex
483 rajveer 1727 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getOrder failed: unknown result");
94 ashish 1728 
 
483 rajveer 1729 
  def getLineItemsForOrder(self, orderId):
94 ashish 1730 
    """
1731 
    Parameters:
483 rajveer 1732 
     - orderId
94 ashish 1733 
    """
483 rajveer 1734 
    self.send_getLineItemsForOrder(orderId)
1735 
    return self.recv_getLineItemsForOrder()
94 ashish 1736 
 
483 rajveer 1737 
  def send_getLineItemsForOrder(self, orderId):
1738 
    self._oprot.writeMessageBegin('getLineItemsForOrder', TMessageType.CALL, self._seqid)
1739 
    args = getLineItemsForOrder_args()
1740 
    args.orderId = orderId
94 ashish 1741 
    args.write(self._oprot)
1742 
    self._oprot.writeMessageEnd()
1743 
    self._oprot.trans.flush()
1744 
 
483 rajveer 1745 
  def recv_getLineItemsForOrder(self, ):
94 ashish 1746 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1747 
    if mtype == TMessageType.EXCEPTION:
1748 
      x = TApplicationException()
1749 
      x.read(self._iprot)
1750 
      self._iprot.readMessageEnd()
1751 
      raise x
483 rajveer 1752 
    result = getLineItemsForOrder_result()
94 ashish 1753 
    result.read(self._iprot)
1754 
    self._iprot.readMessageEnd()
3431 rajveer 1755 
    if result.success is not None:
94 ashish 1756 
      return result.success
3431 rajveer 1757 
    if result.ex is not None:
94 ashish 1758 
      raise result.ex
483 rajveer 1759 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getLineItemsForOrder failed: unknown result");
94 ashish 1760 
 
1528 ankur.sing 1761 
  def getOrderForCustomer(self, orderId, customerId):
1762 
    """
1763 
    Returns an order for the order Id. Also checks if the order belongs to the customer whose Id is passed.
1764 
    Throws exception if either order Id is invalid or order does not below to the customer whose Id is passed.
3431 rajveer 1765 
 
1528 ankur.sing 1766 
    Parameters:
1767 
     - orderId
1768 
     - customerId
1769 
    """
1770 
    self.send_getOrderForCustomer(orderId, customerId)
1771 
    return self.recv_getOrderForCustomer()
1772 
 
1773 
  def send_getOrderForCustomer(self, orderId, customerId):
1774 
    self._oprot.writeMessageBegin('getOrderForCustomer', TMessageType.CALL, self._seqid)
1775 
    args = getOrderForCustomer_args()
1776 
    args.orderId = orderId
1777 
    args.customerId = customerId
1778 
    args.write(self._oprot)
1779 
    self._oprot.writeMessageEnd()
1780 
    self._oprot.trans.flush()
1781 
 
1782 
  def recv_getOrderForCustomer(self, ):
1783 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1784 
    if mtype == TMessageType.EXCEPTION:
1785 
      x = TApplicationException()
1786 
      x.read(self._iprot)
1787 
      self._iprot.readMessageEnd()
1788 
      raise x
1789 
    result = getOrderForCustomer_result()
1790 
    result.read(self._iprot)
1791 
    self._iprot.readMessageEnd()
3431 rajveer 1792 
    if result.success is not None:
1528 ankur.sing 1793 
      return result.success
3431 rajveer 1794 
    if result.ex is not None:
1528 ankur.sing 1795 
      raise result.ex
1796 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getOrderForCustomer failed: unknown result");
1797 
 
4444 rajveer 1798 
  def getAlerts(self, type, warehouseId, status, timestamp):
3064 chandransh 1799 
    """
1800 
    Parameters:
4394 rajveer 1801 
     - type
4444 rajveer 1802 
     - warehouseId
4394 rajveer 1803 
     - status
1804 
     - timestamp
3064 chandransh 1805 
    """
4444 rajveer 1806 
    self.send_getAlerts(type, warehouseId, status, timestamp)
3064 chandransh 1807 
    return self.recv_getAlerts()
1808 
 
4444 rajveer 1809 
  def send_getAlerts(self, type, warehouseId, status, timestamp):
3064 chandransh 1810 
    self._oprot.writeMessageBegin('getAlerts', TMessageType.CALL, self._seqid)
1811 
    args = getAlerts_args()
4394 rajveer 1812 
    args.type = type
4444 rajveer 1813 
    args.warehouseId = warehouseId
4394 rajveer 1814 
    args.status = status
1815 
    args.timestamp = timestamp
3064 chandransh 1816 
    args.write(self._oprot)
1817 
    self._oprot.writeMessageEnd()
1818 
    self._oprot.trans.flush()
1819 
 
1820 
  def recv_getAlerts(self, ):
1821 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1822 
    if mtype == TMessageType.EXCEPTION:
1823 
      x = TApplicationException()
1824 
      x.read(self._iprot)
1825 
      self._iprot.readMessageEnd()
1826 
      raise x
1827 
    result = getAlerts_result()
1828 
    result.read(self._iprot)
1829 
    self._iprot.readMessageEnd()
3431 rajveer 1830 
    if result.success is not None:
3064 chandransh 1831 
      return result.success
1832 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAlerts failed: unknown result");
1833 
 
4444 rajveer 1834 
  def addAlert(self, type, warehouseId, description):
3064 chandransh 1835 
    """
1836 
    Parameters:
1837 
     - type
4444 rajveer 1838 
     - warehouseId
4394 rajveer 1839 
     - description
3064 chandransh 1840 
    """
4444 rajveer 1841 
    self.send_addAlert(type, warehouseId, description)
4394 rajveer 1842 
    self.recv_addAlert()
3064 chandransh 1843 
 
4444 rajveer 1844 
  def send_addAlert(self, type, warehouseId, description):
4394 rajveer 1845 
    self._oprot.writeMessageBegin('addAlert', TMessageType.CALL, self._seqid)
1846 
    args = addAlert_args()
3064 chandransh 1847 
    args.type = type
4444 rajveer 1848 
    args.warehouseId = warehouseId
4394 rajveer 1849 
    args.description = description
3064 chandransh 1850 
    args.write(self._oprot)
1851 
    self._oprot.writeMessageEnd()
1852 
    self._oprot.trans.flush()
1853 
 
4394 rajveer 1854 
  def recv_addAlert(self, ):
3064 chandransh 1855 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1856 
    if mtype == TMessageType.EXCEPTION:
1857 
      x = TApplicationException()
1858 
      x.read(self._iprot)
1859 
      self._iprot.readMessageEnd()
1860 
      raise x
4394 rajveer 1861 
    result = addAlert_result()
3064 chandransh 1862 
    result.read(self._iprot)
1863 
    self._iprot.readMessageEnd()
1864 
    return
1865 
 
4444 rajveer 1866 
  def markAlertsAsSeen(self, warehouseId):
1867 
    """
1868 
    Parameters:
1869 
     - warehouseId
1870 
    """
1871 
    self.send_markAlertsAsSeen(warehouseId)
1872 
    self.recv_markAlertsAsSeen()
1873 
 
1874 
  def send_markAlertsAsSeen(self, warehouseId):
1875 
    self._oprot.writeMessageBegin('markAlertsAsSeen', TMessageType.CALL, self._seqid)
1876 
    args = markAlertsAsSeen_args()
1877 
    args.warehouseId = warehouseId
1878 
    args.write(self._oprot)
1879 
    self._oprot.writeMessageEnd()
1880 
    self._oprot.trans.flush()
1881 
 
1882 
  def recv_markAlertsAsSeen(self, ):
1883 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1884 
    if mtype == TMessageType.EXCEPTION:
1885 
      x = TApplicationException()
1886 
      x.read(self._iprot)
1887 
      self._iprot.readMessageEnd()
1888 
      raise x
1889 
    result = markAlertsAsSeen_result()
1890 
    result.read(self._iprot)
1891 
    self._iprot.readMessageEnd()
1892 
    return
1893 
 
3064 chandransh 1894 
  def getValidOrderCount(self, ):
1895 
    """
1896 
    Return the number of valid orders. (OrderStatus >= OrderStatus.SUBMITTED_FOR_PROCESSING)
1897 
    """
1898 
    self.send_getValidOrderCount()
1899 
    return self.recv_getValidOrderCount()
1900 
 
1901 
  def send_getValidOrderCount(self, ):
1902 
    self._oprot.writeMessageBegin('getValidOrderCount', TMessageType.CALL, self._seqid)
1903 
    args = getValidOrderCount_args()
1904 
    args.write(self._oprot)
1905 
    self._oprot.writeMessageEnd()
1906 
    self._oprot.trans.flush()
1907 
 
1908 
  def recv_getValidOrderCount(self, ):
1909 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1910 
    if mtype == TMessageType.EXCEPTION:
1911 
      x = TApplicationException()
1912 
      x.read(self._iprot)
1913 
      self._iprot.readMessageEnd()
1914 
      raise x
1915 
    result = getValidOrderCount_result()
1916 
    result.read(self._iprot)
1917 
    self._iprot.readMessageEnd()
3431 rajveer 1918 
    if result.success is not None:
3064 chandransh 1919 
      return result.success
1920 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getValidOrderCount failed: unknown result");
1921 
 
1922 
  def getNoOfCustomersWithSuccessfulTransaction(self, ):
1923 
    """
1924 
    Returns the number of distinct customers who have done successful transactions
1925 
    """
1926 
    self.send_getNoOfCustomersWithSuccessfulTransaction()
1927 
    return self.recv_getNoOfCustomersWithSuccessfulTransaction()
1928 
 
1929 
  def send_getNoOfCustomersWithSuccessfulTransaction(self, ):
1930 
    self._oprot.writeMessageBegin('getNoOfCustomersWithSuccessfulTransaction', TMessageType.CALL, self._seqid)
1931 
    args = getNoOfCustomersWithSuccessfulTransaction_args()
1932 
    args.write(self._oprot)
1933 
    self._oprot.writeMessageEnd()
1934 
    self._oprot.trans.flush()
1935 
 
1936 
  def recv_getNoOfCustomersWithSuccessfulTransaction(self, ):
1937 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1938 
    if mtype == TMessageType.EXCEPTION:
1939 
      x = TApplicationException()
1940 
      x.read(self._iprot)
1941 
      self._iprot.readMessageEnd()
1942 
      raise x
1943 
    result = getNoOfCustomersWithSuccessfulTransaction_result()
1944 
    result.read(self._iprot)
1945 
    self._iprot.readMessageEnd()
3431 rajveer 1946 
    if result.success is not None:
3064 chandransh 1947 
      return result.success
1948 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getNoOfCustomersWithSuccessfulTransaction failed: unknown result");
1949 
 
1950 
  def getValidOrdersAmountRange(self, ):
1951 
    """
1952 
    Returns the minimum and maximum amounts of a valid order. (OrderStatus >= OrderStatus.SUBMITTED_FOR_PROCESSING)
1953 
    List contains two values, first minimum amount and second maximum amount.
1954 
    """
1955 
    self.send_getValidOrdersAmountRange()
1956 
    return self.recv_getValidOrdersAmountRange()
1957 
 
1958 
  def send_getValidOrdersAmountRange(self, ):
1959 
    self._oprot.writeMessageBegin('getValidOrdersAmountRange', TMessageType.CALL, self._seqid)
1960 
    args = getValidOrdersAmountRange_args()
1961 
    args.write(self._oprot)
1962 
    self._oprot.writeMessageEnd()
1963 
    self._oprot.trans.flush()
1964 
 
1965 
  def recv_getValidOrdersAmountRange(self, ):
1966 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1967 
    if mtype == TMessageType.EXCEPTION:
1968 
      x = TApplicationException()
1969 
      x.read(self._iprot)
1970 
      self._iprot.readMessageEnd()
1971 
      raise x
1972 
    result = getValidOrdersAmountRange_result()
1973 
    result.read(self._iprot)
1974 
    self._iprot.readMessageEnd()
3431 rajveer 1975 
    if result.success is not None:
3064 chandransh 1976 
      return result.success
1977 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getValidOrdersAmountRange failed: unknown result");
1978 
 
1979 
  def getValidOrders(self, limit):
1980 
    """
1981 
    Returns list of Orders in descending order by Order creation date. List is restricted to limit Orders.
1982 
    If limit is passed as 0, then all valid Orders are returned.
3431 rajveer 1983 
 
3064 chandransh 1984 
    Parameters:
1985 
     - limit
1986 
    """
1987 
    self.send_getValidOrders(limit)
1988 
    return self.recv_getValidOrders()
1989 
 
1990 
  def send_getValidOrders(self, limit):
1991 
    self._oprot.writeMessageBegin('getValidOrders', TMessageType.CALL, self._seqid)
1992 
    args = getValidOrders_args()
1993 
    args.limit = limit
1994 
    args.write(self._oprot)
1995 
    self._oprot.writeMessageEnd()
1996 
    self._oprot.trans.flush()
1997 
 
1998 
  def recv_getValidOrders(self, ):
1999 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2000 
    if mtype == TMessageType.EXCEPTION:
2001 
      x = TApplicationException()
2002 
      x.read(self._iprot)
2003 
      self._iprot.readMessageEnd()
2004 
      raise x
2005 
    result = getValidOrders_result()
2006 
    result.read(self._iprot)
2007 
    self._iprot.readMessageEnd()
3431 rajveer 2008 
    if result.success is not None:
3064 chandransh 2009 
      return result.success
2010 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getValidOrders failed: unknown result");
2011 
 
1220 chandransh 2012 
  def batchOrders(self, warehouseId):
2013 
    """
2014 
    Create a batch of all the pending orders for the given warehouse.
2015 
    The returned list is orderd by created_timestamp.
2016 
    If there are no pending orders, an empty list is returned.
3431 rajveer 2017 
 
1220 chandransh 2018 
    Parameters:
2019 
     - warehouseId
2020 
    """
2021 
    self.send_batchOrders(warehouseId)
2022 
    return self.recv_batchOrders()
2023 
 
2024 
  def send_batchOrders(self, warehouseId):
2025 
    self._oprot.writeMessageBegin('batchOrders', TMessageType.CALL, self._seqid)
2026 
    args = batchOrders_args()
2027 
    args.warehouseId = warehouseId
2028 
    args.write(self._oprot)
2029 
    self._oprot.writeMessageEnd()
2030 
    self._oprot.trans.flush()
2031 
 
2032 
  def recv_batchOrders(self, ):
2033 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2034 
    if mtype == TMessageType.EXCEPTION:
2035 
      x = TApplicationException()
2036 
      x.read(self._iprot)
2037 
      self._iprot.readMessageEnd()
2038 
      raise x
2039 
    result = batchOrders_result()
2040 
    result.read(self._iprot)
2041 
    self._iprot.readMessageEnd()
3431 rajveer 2042 
    if result.success is not None:
1220 chandransh 2043 
      return result.success
3431 rajveer 2044 
    if result.ex is not None:
1220 chandransh 2045 
      raise result.ex
2046 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "batchOrders failed: unknown result");
2047 
 
1208 chandransh 2048 
  def markOrderAsOutOfStock(self, orderId):
2049 
    """
2050 
    Mark the given order as out of stock. Throws an exception if the order with the given Id couldn't be found.
3431 rajveer 2051 
 
1208 chandransh 2052 
    Parameters:
2053 
     - orderId
2054 
    """
2055 
    self.send_markOrderAsOutOfStock(orderId)
2056 
    return self.recv_markOrderAsOutOfStock()
2057 
 
2058 
  def send_markOrderAsOutOfStock(self, orderId):
2059 
    self._oprot.writeMessageBegin('markOrderAsOutOfStock', TMessageType.CALL, self._seqid)
2060 
    args = markOrderAsOutOfStock_args()
2061 
    args.orderId = orderId
2062 
    args.write(self._oprot)
2063 
    self._oprot.writeMessageEnd()
2064 
    self._oprot.trans.flush()
2065 
 
2066 
  def recv_markOrderAsOutOfStock(self, ):
2067 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2068 
    if mtype == TMessageType.EXCEPTION:
2069 
      x = TApplicationException()
2070 
      x.read(self._iprot)
2071 
      self._iprot.readMessageEnd()
2072 
      raise x
2073 
    result = markOrderAsOutOfStock_result()
2074 
    result.read(self._iprot)
2075 
    self._iprot.readMessageEnd()
3431 rajveer 2076 
    if result.success is not None:
1208 chandransh 2077 
      return result.success
3431 rajveer 2078 
    if result.ex is not None:
1208 chandransh 2079 
      raise result.ex
2080 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "markOrderAsOutOfStock failed: unknown result");
2081 
 
3064 chandransh 2082 
  def verifyOrder(self, orderId):
759 chandransh 2083 
    """
3064 chandransh 2084 
    Marks the given order as SUBMITTED_FOR_PROCESSING and updates the verified
2085 
    timestamp. It is intended to be used for COD orders but can be harmlessly
2086 
    used for all other orders as well.
2087 
    Throws an exception if no such order exists.
3431 rajveer 2088 
 
759 chandransh 2089 
    Parameters:
3064 chandransh 2090 
     - orderId
759 chandransh 2091 
    """
3064 chandransh 2092 
    self.send_verifyOrder(orderId)
2093 
    return self.recv_verifyOrder()
759 chandransh 2094 
 
3064 chandransh 2095 
  def send_verifyOrder(self, orderId):
2096 
    self._oprot.writeMessageBegin('verifyOrder', TMessageType.CALL, self._seqid)
2097 
    args = verifyOrder_args()
2098 
    args.orderId = orderId
759 chandransh 2099 
    args.write(self._oprot)
2100 
    self._oprot.writeMessageEnd()
2101 
    self._oprot.trans.flush()
2102 
 
3064 chandransh 2103 
  def recv_verifyOrder(self, ):
759 chandransh 2104 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2105 
    if mtype == TMessageType.EXCEPTION:
2106 
      x = TApplicationException()
2107 
      x.read(self._iprot)
2108 
      self._iprot.readMessageEnd()
2109 
      raise x
3064 chandransh 2110 
    result = verifyOrder_result()
759 chandransh 2111 
    result.read(self._iprot)
2112 
    self._iprot.readMessageEnd()
3431 rajveer 2113 
    if result.success is not None:
759 chandransh 2114 
      return result.success
3431 rajveer 2115 
    if result.ex is not None:
759 chandransh 2116 
      raise result.ex
3064 chandransh 2117 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "verifyOrder failed: unknown result");
759 chandransh 2118 
 
3064 chandransh 2119 
  def acceptOrder(self, orderId):
1113 chandransh 2120 
    """
3064 chandransh 2121 
    Marks the given order as ACCEPTED and updates the accepted timestamp. If the
2122 
    given order is not a COD order, it also captures the payment if the same has
2123 
    not been captured.
2124 
    Throws an exception if no such order exists.
3431 rajveer 2125 
 
1113 chandransh 2126 
    Parameters:
3064 chandransh 2127 
     - orderId
1113 chandransh 2128 
    """
3064 chandransh 2129 
    self.send_acceptOrder(orderId)
2130 
    return self.recv_acceptOrder()
1113 chandransh 2131 
 
3064 chandransh 2132 
  def send_acceptOrder(self, orderId):
2133 
    self._oprot.writeMessageBegin('acceptOrder', TMessageType.CALL, self._seqid)
2134 
    args = acceptOrder_args()
2135 
    args.orderId = orderId
1113 chandransh 2136 
    args.write(self._oprot)
2137 
    self._oprot.writeMessageEnd()
2138 
    self._oprot.trans.flush()
2139 
 
3064 chandransh 2140 
  def recv_acceptOrder(self, ):
1113 chandransh 2141 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2142 
    if mtype == TMessageType.EXCEPTION:
2143 
      x = TApplicationException()
2144 
      x.read(self._iprot)
2145 
      self._iprot.readMessageEnd()
2146 
      raise x
3064 chandransh 2147 
    result = acceptOrder_result()
1113 chandransh 2148 
    result.read(self._iprot)
2149 
    self._iprot.readMessageEnd()
3431 rajveer 2150 
    if result.success is not None:
1113 chandransh 2151 
      return result.success
3431 rajveer 2152 
    if result.ex is not None:
1113 chandransh 2153 
      raise result.ex
3064 chandransh 2154 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "acceptOrder failed: unknown result");
1113 chandransh 2155 
 
4763 rajveer 2156 
  def addBillingDetails(self, orderId, invoice_number, serialNumber, itemNumber, billed_by, jacketNumber, billingType, vendorId, authorize):
1132 chandransh 2157 
    """
3064 chandransh 2158 
    Add billing details such as the bill number and the biller to the Order.
4658 mandeep.dh 2159 
    Adds jacket number, item number and Serial no. to the order. Doesn't update
4283 anupam.sin 2160 
    the IMEI no. if a -1 is supplied.
2161 
    Also, it generates an invoice number for the order, marks the order as
2162 
    BILLED and sets the billing timestamp.
2163 
    Returns false if it doesn't find the order with the given ID.
3431 rajveer 2164 
 
1135 chandransh 2165 
    Parameters:
3064 chandransh 2166 
     - orderId
2167 
     - invoice_number
4658 mandeep.dh 2168 
     - serialNumber
4283 anupam.sin 2169 
     - itemNumber
3064 chandransh 2170 
     - billed_by
4264 rajveer 2171 
     - jacketNumber
4283 anupam.sin 2172 
     - billingType
2173 
     - vendorId
4763 rajveer 2174 
     - authorize
1135 chandransh 2175 
    """
4763 rajveer 2176 
    self.send_addBillingDetails(orderId, invoice_number, serialNumber, itemNumber, billed_by, jacketNumber, billingType, vendorId, authorize)
3064 chandransh 2177 
    return self.recv_addBillingDetails()
1135 chandransh 2178 
 
4763 rajveer 2179 
  def send_addBillingDetails(self, orderId, invoice_number, serialNumber, itemNumber, billed_by, jacketNumber, billingType, vendorId, authorize):
3064 chandransh 2180 
    self._oprot.writeMessageBegin('addBillingDetails', TMessageType.CALL, self._seqid)
2181 
    args = addBillingDetails_args()
2182 
    args.orderId = orderId
2183 
    args.invoice_number = invoice_number
4658 mandeep.dh 2184 
    args.serialNumber = serialNumber
4283 anupam.sin 2185 
    args.itemNumber = itemNumber
3064 chandransh 2186 
    args.billed_by = billed_by
4264 rajveer 2187 
    args.jacketNumber = jacketNumber
4283 anupam.sin 2188 
    args.billingType = billingType
2189 
    args.vendorId = vendorId
4763 rajveer 2190 
    args.authorize = authorize
1135 chandransh 2191 
    args.write(self._oprot)
2192 
    self._oprot.writeMessageEnd()
2193 
    self._oprot.trans.flush()
2194 
 
3064 chandransh 2195 
  def recv_addBillingDetails(self, ):
1135 chandransh 2196 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2197 
    if mtype == TMessageType.EXCEPTION:
2198 
      x = TApplicationException()
2199 
      x.read(self._iprot)
2200 
      self._iprot.readMessageEnd()
2201 
      raise x
3064 chandransh 2202 
    result = addBillingDetails_result()
1135 chandransh 2203 
    result.read(self._iprot)
2204 
    self._iprot.readMessageEnd()
3431 rajveer 2205 
    if result.success is not None:
3064 chandransh 2206 
      return result.success
3431 rajveer 2207 
    if result.ex is not None:
1135 chandransh 2208 
      raise result.ex
3064 chandransh 2209 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "addBillingDetails failed: unknown result");
1135 chandransh 2210 
 
4763 rajveer 2211 
  def addInvoiceNumber(self, orderId, invoiceNumber, color):
4579 rajveer 2212 
    """
2213 
    Add the invoice number to the order.
2214 
 
2215 
    Parameters:
2216 
     - orderId
2217 
     - invoiceNumber
4763 rajveer 2218 
     - color
4579 rajveer 2219 
    """
4763 rajveer 2220 
    self.send_addInvoiceNumber(orderId, invoiceNumber, color)
4579 rajveer 2221 
    self.recv_addInvoiceNumber()
2222 
 
4763 rajveer 2223 
  def send_addInvoiceNumber(self, orderId, invoiceNumber, color):
4579 rajveer 2224 
    self._oprot.writeMessageBegin('addInvoiceNumber', TMessageType.CALL, self._seqid)
2225 
    args = addInvoiceNumber_args()
2226 
    args.orderId = orderId
2227 
    args.invoiceNumber = invoiceNumber
4763 rajveer 2228 
    args.color = color
4579 rajveer 2229 
    args.write(self._oprot)
2230 
    self._oprot.writeMessageEnd()
2231 
    self._oprot.trans.flush()
2232 
 
2233 
  def recv_addInvoiceNumber(self, ):
2234 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2235 
    if mtype == TMessageType.EXCEPTION:
2236 
      x = TApplicationException()
2237 
      x.read(self._iprot)
2238 
      self._iprot.readMessageEnd()
2239 
      raise x
2240 
    result = addInvoiceNumber_result()
2241 
    result.read(self._iprot)
2242 
    self._iprot.readMessageEnd()
2243 
    if result.ex is not None:
2244 
      raise result.ex
2245 
    return
2246 
 
3064 chandransh 2247 
  def markOrdersAsManifested(self, warehouseId, providerId, cod):
1408 ankur.sing 2248 
    """
3064 chandransh 2249 
    Depending on the third parameter, marks either all prepaid or all cod orders BILLED by the
4410 rajveer 2250 
    given warehouse and were picked up by the given provider as MANIFESTED.
3431 rajveer 2251 
 
1408 ankur.sing 2252 
    Parameters:
3064 chandransh 2253 
     - warehouseId
1408 ankur.sing 2254 
     - providerId
3064 chandransh 2255 
     - cod
1408 ankur.sing 2256 
    """
3064 chandransh 2257 
    self.send_markOrdersAsManifested(warehouseId, providerId, cod)
2258 
    return self.recv_markOrdersAsManifested()
1408 ankur.sing 2259 
 
3064 chandransh 2260 
  def send_markOrdersAsManifested(self, warehouseId, providerId, cod):
2261 
    self._oprot.writeMessageBegin('markOrdersAsManifested', TMessageType.CALL, self._seqid)
2262 
    args = markOrdersAsManifested_args()
2263 
    args.warehouseId = warehouseId
1408 ankur.sing 2264 
    args.providerId = providerId
3064 chandransh 2265 
    args.cod = cod
1408 ankur.sing 2266 
    args.write(self._oprot)
2267 
    self._oprot.writeMessageEnd()
2268 
    self._oprot.trans.flush()
2269 
 
3064 chandransh 2270 
  def recv_markOrdersAsManifested(self, ):
1408 ankur.sing 2271 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2272 
    if mtype == TMessageType.EXCEPTION:
2273 
      x = TApplicationException()
2274 
      x.read(self._iprot)
2275 
      self._iprot.readMessageEnd()
2276 
      raise x
3064 chandransh 2277 
    result = markOrdersAsManifested_result()
1408 ankur.sing 2278 
    result.read(self._iprot)
2279 
    self._iprot.readMessageEnd()
3431 rajveer 2280 
    if result.success is not None:
1408 ankur.sing 2281 
      return result.success
3431 rajveer 2282 
    if result.ex is not None:
3064 chandransh 2283 
      raise result.ex
2284 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "markOrdersAsManifested failed: unknown result");
1408 ankur.sing 2285 
 
4789 rajveer 2286 
  def markOrdersAsShippedFromWarehouse(self, warehouseId, providerId, cod, orderIds):
4410 rajveer 2287 
    """
2288 
    Depending on the third parameter, marks either all prepaid or all cod orders BILLED and marked as MANIFESTED by the
2289 
    given warehouse and were picked up by the given provider as SHIPPED_FROM_WH.
2290 
 
2291 
    Parameters:
2292 
     - warehouseId
2293 
     - providerId
2294 
     - cod
4789 rajveer 2295 
     - orderIds
4410 rajveer 2296 
    """
4789 rajveer 2297 
    self.send_markOrdersAsShippedFromWarehouse(warehouseId, providerId, cod, orderIds)
4410 rajveer 2298 
    return self.recv_markOrdersAsShippedFromWarehouse()
2299 
 
4789 rajveer 2300 
  def send_markOrdersAsShippedFromWarehouse(self, warehouseId, providerId, cod, orderIds):
4410 rajveer 2301 
    self._oprot.writeMessageBegin('markOrdersAsShippedFromWarehouse', TMessageType.CALL, self._seqid)
2302 
    args = markOrdersAsShippedFromWarehouse_args()
2303 
    args.warehouseId = warehouseId
2304 
    args.providerId = providerId
2305 
    args.cod = cod
4789 rajveer 2306 
    args.orderIds = orderIds
4410 rajveer 2307 
    args.write(self._oprot)
2308 
    self._oprot.writeMessageEnd()
2309 
    self._oprot.trans.flush()
2310 
 
2311 
  def recv_markOrdersAsShippedFromWarehouse(self, ):
2312 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2313 
    if mtype == TMessageType.EXCEPTION:
2314 
      x = TApplicationException()
2315 
      x.read(self._iprot)
2316 
      self._iprot.readMessageEnd()
2317 
      raise x
2318 
    result = markOrdersAsShippedFromWarehouse_result()
2319 
    result.read(self._iprot)
2320 
    self._iprot.readMessageEnd()
2321 
    if result.success is not None:
2322 
      return result.success
2323 
    if result.ex is not None:
2324 
      raise result.ex
2325 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "markOrdersAsShippedFromWarehouse failed: unknown result");
2326 
 
3064 chandransh 2327 
  def markOrdersAsPickedUp(self, providerId, pickupDetails):
94 ashish 2328 
    """
3064 chandransh 2329 
    Marks all SHIPPED_FROM_WH orders of the previous day for a provider as SHIPPED_TO_LOGISTICS.
2330 
    Returns a list of orders that were shipped from warehouse but did not appear in the pick-up report.
2331 
    Raises an exception if we encounter report for an AWB number that we did not ship.
3431 rajveer 2332 
 
94 ashish 2333 
    Parameters:
3064 chandransh 2334 
     - providerId
2335 
     - pickupDetails
304 ashish 2336 
    """
3064 chandransh 2337 
    self.send_markOrdersAsPickedUp(providerId, pickupDetails)
2338 
    return self.recv_markOrdersAsPickedUp()
94 ashish 2339 
 
3064 chandransh 2340 
  def send_markOrdersAsPickedUp(self, providerId, pickupDetails):
2341 
    self._oprot.writeMessageBegin('markOrdersAsPickedUp', TMessageType.CALL, self._seqid)
2342 
    args = markOrdersAsPickedUp_args()
2343 
    args.providerId = providerId
2344 
    args.pickupDetails = pickupDetails
304 ashish 2345 
    args.write(self._oprot)
2346 
    self._oprot.writeMessageEnd()
2347 
    self._oprot.trans.flush()
2348 
 
3064 chandransh 2349 
  def recv_markOrdersAsPickedUp(self, ):
304 ashish 2350 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2351 
    if mtype == TMessageType.EXCEPTION:
2352 
      x = TApplicationException()
2353 
      x.read(self._iprot)
2354 
      self._iprot.readMessageEnd()
2355 
      raise x
3064 chandransh 2356 
    result = markOrdersAsPickedUp_result()
304 ashish 2357 
    result.read(self._iprot)
2358 
    self._iprot.readMessageEnd()
3431 rajveer 2359 
    if result.success is not None:
304 ashish 2360 
      return result.success
3431 rajveer 2361 
    if result.ex is not None:
3064 chandransh 2362 
      raise result.ex
2363 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "markOrdersAsPickedUp failed: unknown result");
304 ashish 2364 
 
3064 chandransh 2365 
  def markOrdersAsDelivered(self, providerId, deliveredOrders):
304 ashish 2366 
    """
3064 chandransh 2367 
    Marks all orders with AWBs in the given map as delivered. Also sets the delivery timestamp and
2368 
    the name of the receiver.
2369 
    Raises an exception if we encounter report for an AWB number that we did not ship.
3431 rajveer 2370 
 
304 ashish 2371 
    Parameters:
3064 chandransh 2372 
     - providerId
2373 
     - deliveredOrders
304 ashish 2374 
    """
3064 chandransh 2375 
    self.send_markOrdersAsDelivered(providerId, deliveredOrders)
2376 
    self.recv_markOrdersAsDelivered()
304 ashish 2377 
 
3064 chandransh 2378 
  def send_markOrdersAsDelivered(self, providerId, deliveredOrders):
2379 
    self._oprot.writeMessageBegin('markOrdersAsDelivered', TMessageType.CALL, self._seqid)
2380 
    args = markOrdersAsDelivered_args()
2381 
    args.providerId = providerId
2382 
    args.deliveredOrders = deliveredOrders
304 ashish 2383 
    args.write(self._oprot)
2384 
    self._oprot.writeMessageEnd()
2385 
    self._oprot.trans.flush()
2386 
 
3064 chandransh 2387 
  def recv_markOrdersAsDelivered(self, ):
304 ashish 2388 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2389 
    if mtype == TMessageType.EXCEPTION:
2390 
      x = TApplicationException()
2391 
      x.read(self._iprot)
2392 
      self._iprot.readMessageEnd()
2393 
      raise x
3064 chandransh 2394 
    result = markOrdersAsDelivered_result()
304 ashish 2395 
    result.read(self._iprot)
2396 
    self._iprot.readMessageEnd()
3431 rajveer 2397 
    if result.ex is not None:
3064 chandransh 2398 
      raise result.ex
304 ashish 2399 
    return
2400 
 
3064 chandransh 2401 
  def markOrdersAsFailed(self, providerId, returnedOrders):
1596 ankur.sing 2402 
    """
3064 chandransh 2403 
    Mark all orders with AWBs in the given map as failed. Also sets the delivery timestamp.
2404 
    Raises an exception if we encounter report for an AWB number that we did not ship.
3431 rajveer 2405 
 
3064 chandransh 2406 
    Parameters:
2407 
     - providerId
2408 
     - returnedOrders
1596 ankur.sing 2409 
    """
3064 chandransh 2410 
    self.send_markOrdersAsFailed(providerId, returnedOrders)
2411 
    self.recv_markOrdersAsFailed()
304 ashish 2412 
 
3064 chandransh 2413 
  def send_markOrdersAsFailed(self, providerId, returnedOrders):
2414 
    self._oprot.writeMessageBegin('markOrdersAsFailed', TMessageType.CALL, self._seqid)
2415 
    args = markOrdersAsFailed_args()
2416 
    args.providerId = providerId
2417 
    args.returnedOrders = returnedOrders
1596 ankur.sing 2418 
    args.write(self._oprot)
2419 
    self._oprot.writeMessageEnd()
2420 
    self._oprot.trans.flush()
2421 
 
3064 chandransh 2422 
  def recv_markOrdersAsFailed(self, ):
1596 ankur.sing 2423 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2424 
    if mtype == TMessageType.EXCEPTION:
2425 
      x = TApplicationException()
2426 
      x.read(self._iprot)
2427 
      self._iprot.readMessageEnd()
2428 
      raise x
3064 chandransh 2429 
    result = markOrdersAsFailed_result()
1596 ankur.sing 2430 
    result.read(self._iprot)
2431 
    self._iprot.readMessageEnd()
3431 rajveer 2432 
    if result.ex is not None:
3064 chandransh 2433 
      raise result.ex
2434 
    return
1596 ankur.sing 2435 
 
3064 chandransh 2436 
  def updateNonDeliveryReason(self, providerId, undeliveredOrders):
1627 ankur.sing 2437 
    """
3064 chandransh 2438 
    Update the status description of orders whose AWB numbers are keys of the Map.
4581 phani.kuma 2439 
    Returns a list of orders that were picked up or shipped four days ago but did not get delivered.
3431 rajveer 2440 
 
3064 chandransh 2441 
    Parameters:
2442 
     - providerId
2443 
     - undeliveredOrders
1627 ankur.sing 2444 
    """
3064 chandransh 2445 
    self.send_updateNonDeliveryReason(providerId, undeliveredOrders)
4581 phani.kuma 2446 
    return self.recv_updateNonDeliveryReason()
1596 ankur.sing 2447 
 
3064 chandransh 2448 
  def send_updateNonDeliveryReason(self, providerId, undeliveredOrders):
2449 
    self._oprot.writeMessageBegin('updateNonDeliveryReason', TMessageType.CALL, self._seqid)
2450 
    args = updateNonDeliveryReason_args()
2451 
    args.providerId = providerId
2452 
    args.undeliveredOrders = undeliveredOrders
1627 ankur.sing 2453 
    args.write(self._oprot)
2454 
    self._oprot.writeMessageEnd()
2455 
    self._oprot.trans.flush()
2456 
 
3064 chandransh 2457 
  def recv_updateNonDeliveryReason(self, ):
1627 ankur.sing 2458 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2459 
    if mtype == TMessageType.EXCEPTION:
2460 
      x = TApplicationException()
2461 
      x.read(self._iprot)
2462 
      self._iprot.readMessageEnd()
2463 
      raise x
3064 chandransh 2464 
    result = updateNonDeliveryReason_result()
1627 ankur.sing 2465 
    result.read(self._iprot)
2466 
    self._iprot.readMessageEnd()
4581 phani.kuma 2467 
    if result.success is not None:
2468 
      return result.success
3431 rajveer 2469 
    if result.ex is not None:
3064 chandransh 2470 
      raise result.ex
4581 phani.kuma 2471 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "updateNonDeliveryReason failed: unknown result");
1627 ankur.sing 2472 
 
3064 chandransh 2473 
  def getUndeliveredOrders(self, providerId, warehouseId):
1627 ankur.sing 2474 
    """
3064 chandransh 2475 
    Returns the list of orders whose delivery time has passed but have not been
2476 
    delivered yet for the given provider and warehouse. To get a complete list of
2477 
    undelivered orders, pass them as -1.
2478 
    Returns an empty list if no such orders exist.
3431 rajveer 2479 
 
1886 ankur.sing 2480 
    Parameters:
3064 chandransh 2481 
     - providerId
2482 
     - warehouseId
1886 ankur.sing 2483 
    """
3064 chandransh 2484 
    self.send_getUndeliveredOrders(providerId, warehouseId)
2485 
    return self.recv_getUndeliveredOrders()
1627 ankur.sing 2486 
 
3064 chandransh 2487 
  def send_getUndeliveredOrders(self, providerId, warehouseId):
2488 
    self._oprot.writeMessageBegin('getUndeliveredOrders', TMessageType.CALL, self._seqid)
2489 
    args = getUndeliveredOrders_args()
2490 
    args.providerId = providerId
2491 
    args.warehouseId = warehouseId
1886 ankur.sing 2492 
    args.write(self._oprot)
2493 
    self._oprot.writeMessageEnd()
2494 
    self._oprot.trans.flush()
2495 
 
3064 chandransh 2496 
  def recv_getUndeliveredOrders(self, ):
1886 ankur.sing 2497 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2498 
    if mtype == TMessageType.EXCEPTION:
2499 
      x = TApplicationException()
2500 
      x.read(self._iprot)
2501 
      self._iprot.readMessageEnd()
2502 
      raise x
3064 chandransh 2503 
    result = getUndeliveredOrders_result()
1886 ankur.sing 2504 
    result.read(self._iprot)
2505 
    self._iprot.readMessageEnd()
3431 rajveer 2506 
    if result.success is not None:
1886 ankur.sing 2507 
      return result.success
3064 chandransh 2508 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getUndeliveredOrders failed: unknown result");
1886 ankur.sing 2509 
 
4783 phani.kuma 2510 
  def getUndeliveredOrdersExpectedDeliveryDateNotMet(self, ):
2511 
    """
2512 
    Returns the list of orders whose expected delivery date has passed but have not been
2513 
    delivered yet.
2514 
    Returns an empty list if no such orders exist.
2515 
    """
2516 
    self.send_getUndeliveredOrdersExpectedDeliveryDateNotMet()
2517 
    return self.recv_getUndeliveredOrdersExpectedDeliveryDateNotMet()
2518 
 
2519 
  def send_getUndeliveredOrdersExpectedDeliveryDateNotMet(self, ):
2520 
    self._oprot.writeMessageBegin('getUndeliveredOrdersExpectedDeliveryDateNotMet', TMessageType.CALL, self._seqid)
2521 
    args = getUndeliveredOrdersExpectedDeliveryDateNotMet_args()
2522 
    args.write(self._oprot)
2523 
    self._oprot.writeMessageEnd()
2524 
    self._oprot.trans.flush()
2525 
 
2526 
  def recv_getUndeliveredOrdersExpectedDeliveryDateNotMet(self, ):
2527 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2528 
    if mtype == TMessageType.EXCEPTION:
2529 
      x = TApplicationException()
2530 
      x.read(self._iprot)
2531 
      self._iprot.readMessageEnd()
2532 
      raise x
2533 
    result = getUndeliveredOrdersExpectedDeliveryDateNotMet_result()
2534 
    result.read(self._iprot)
2535 
    self._iprot.readMessageEnd()
2536 
    if result.success is not None:
2537 
      return result.success
2538 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getUndeliveredOrdersExpectedDeliveryDateNotMet failed: unknown result");
2539 
 
2536 chandransh 2540 
  def toggleDOAFlag(self, orderId):
2541 
    """
2542 
    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.
2543 
    Returns the final flag status.
2544 
    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 2545 
 
2536 chandransh 2546 
    Parameters:
2547 
     - orderId
2548 
    """
2549 
    self.send_toggleDOAFlag(orderId)
2550 
    return self.recv_toggleDOAFlag()
1886 ankur.sing 2551 
 
2536 chandransh 2552 
  def send_toggleDOAFlag(self, orderId):
2553 
    self._oprot.writeMessageBegin('toggleDOAFlag', TMessageType.CALL, self._seqid)
2554 
    args = toggleDOAFlag_args()
2555 
    args.orderId = orderId
2556 
    args.write(self._oprot)
2557 
    self._oprot.writeMessageEnd()
2558 
    self._oprot.trans.flush()
2559 
 
2560 
  def recv_toggleDOAFlag(self, ):
2561 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2562 
    if mtype == TMessageType.EXCEPTION:
2563 
      x = TApplicationException()
2564 
      x.read(self._iprot)
2565 
      self._iprot.readMessageEnd()
2566 
      raise x
2567 
    result = toggleDOAFlag_result()
2568 
    result.read(self._iprot)
2569 
    self._iprot.readMessageEnd()
3431 rajveer 2570 
    if result.success is not None:
2536 chandransh 2571 
      return result.success
3431 rajveer 2572 
    if result.ex is not None:
2536 chandransh 2573 
      raise result.ex
2574 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "toggleDOAFlag failed: unknown result");
2575 
 
4712 rajveer 2576 
  def markOrderAsDelivered(self, orderId, deliveryTimestamp, receiver):
2577 
    """
2578 
    Parameters:
2579 
     - orderId
2580 
     - deliveryTimestamp
2581 
     - receiver
2582 
    """
2583 
    self.send_markOrderAsDelivered(orderId, deliveryTimestamp, receiver)
2584 
    self.recv_markOrderAsDelivered()
2585 
 
2586 
  def send_markOrderAsDelivered(self, orderId, deliveryTimestamp, receiver):
2587 
    self._oprot.writeMessageBegin('markOrderAsDelivered', TMessageType.CALL, self._seqid)
2588 
    args = markOrderAsDelivered_args()
2589 
    args.orderId = orderId
2590 
    args.deliveryTimestamp = deliveryTimestamp
2591 
    args.receiver = receiver
2592 
    args.write(self._oprot)
2593 
    self._oprot.writeMessageEnd()
2594 
    self._oprot.trans.flush()
2595 
 
2596 
  def recv_markOrderAsDelivered(self, ):
2597 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2598 
    if mtype == TMessageType.EXCEPTION:
2599 
      x = TApplicationException()
2600 
      x.read(self._iprot)
2601 
      self._iprot.readMessageEnd()
2602 
      raise x
2603 
    result = markOrderAsDelivered_result()
2604 
    result.read(self._iprot)
2605 
    self._iprot.readMessageEnd()
2606 
    if result.ex is not None:
2607 
      raise result.ex
2608 
    return
2609 
 
4454 rajveer 2610 
  def markOrderDoaRequestReceived(self, orderId):
2611 
    """
2612 
    Once user raise the request for a DOA, order status will be changed from DELVIERY_SUCCESS to DOA_REQUEST_RECEIVED
2613 
 
2614 
    Parameters:
2615 
     - orderId
2616 
    """
2617 
    self.send_markOrderDoaRequestReceived(orderId)
2618 
    return self.recv_markOrderDoaRequestReceived()
2619 
 
2620 
  def send_markOrderDoaRequestReceived(self, orderId):
2621 
    self._oprot.writeMessageBegin('markOrderDoaRequestReceived', TMessageType.CALL, self._seqid)
2622 
    args = markOrderDoaRequestReceived_args()
2623 
    args.orderId = orderId
2624 
    args.write(self._oprot)
2625 
    self._oprot.writeMessageEnd()
2626 
    self._oprot.trans.flush()
2627 
 
2628 
  def recv_markOrderDoaRequestReceived(self, ):
2629 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2630 
    if mtype == TMessageType.EXCEPTION:
2631 
      x = TApplicationException()
2632 
      x.read(self._iprot)
2633 
      self._iprot.readMessageEnd()
2634 
      raise x
2635 
    result = markOrderDoaRequestReceived_result()
2636 
    result.read(self._iprot)
2637 
    self._iprot.readMessageEnd()
2638 
    if result.success is not None:
2639 
      return result.success
2640 
    if result.ex is not None:
2641 
      raise result.ex
2642 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "markOrderDoaRequestReceived failed: unknown result");
2643 
 
2644 
  def markOrderDoaRequestAuthorized(self, orderId, isAuthorized):
2645 
    """
2646 
    CRM person can authorize or deny the request reised by customer. If he authorizes order will change from DOA_REQUEST_RECEIVED
2647 
    to DOA_REQUEST_AUTHORIZED. If he denies, status will be changed back to DELVIERY_SUCCESS.
2648 
 
2649 
    Parameters:
2650 
     - orderId
2651 
     - isAuthorized
2652 
    """
2653 
    self.send_markOrderDoaRequestAuthorized(orderId, isAuthorized)
2654 
    return self.recv_markOrderDoaRequestAuthorized()
2655 
 
2656 
  def send_markOrderDoaRequestAuthorized(self, orderId, isAuthorized):
2657 
    self._oprot.writeMessageBegin('markOrderDoaRequestAuthorized', TMessageType.CALL, self._seqid)
2658 
    args = markOrderDoaRequestAuthorized_args()
2659 
    args.orderId = orderId
2660 
    args.isAuthorized = isAuthorized
2661 
    args.write(self._oprot)
2662 
    self._oprot.writeMessageEnd()
2663 
    self._oprot.trans.flush()
2664 
 
2665 
  def recv_markOrderDoaRequestAuthorized(self, ):
2666 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2667 
    if mtype == TMessageType.EXCEPTION:
2668 
      x = TApplicationException()
2669 
      x.read(self._iprot)
2670 
      self._iprot.readMessageEnd()
2671 
      raise x
2672 
    result = markOrderDoaRequestAuthorized_result()
2673 
    result.read(self._iprot)
2674 
    self._iprot.readMessageEnd()
2675 
    if result.success is not None:
2676 
      return result.success
2677 
    if result.ex is not None:
2678 
      raise result.ex
2679 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "markOrderDoaRequestAuthorized failed: unknown result");
2680 
 
4488 rajveer 2681 
  def markOrderReturnRequestReceived(self, orderId):
2682 
    """
2683 
    Once user raise the request for a RET, order status will be changed from DELVIERY_SUCCESS to RET_REQUEST_RECEIVED
2684 
 
2685 
    Parameters:
2686 
     - orderId
2687 
    """
2688 
    self.send_markOrderReturnRequestReceived(orderId)
2689 
    return self.recv_markOrderReturnRequestReceived()
2690 
 
2691 
  def send_markOrderReturnRequestReceived(self, orderId):
2692 
    self._oprot.writeMessageBegin('markOrderReturnRequestReceived', TMessageType.CALL, self._seqid)
2693 
    args = markOrderReturnRequestReceived_args()
2694 
    args.orderId = orderId
2695 
    args.write(self._oprot)
2696 
    self._oprot.writeMessageEnd()
2697 
    self._oprot.trans.flush()
2698 
 
2699 
  def recv_markOrderReturnRequestReceived(self, ):
2700 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2701 
    if mtype == TMessageType.EXCEPTION:
2702 
      x = TApplicationException()
2703 
      x.read(self._iprot)
2704 
      self._iprot.readMessageEnd()
2705 
      raise x
2706 
    result = markOrderReturnRequestReceived_result()
2707 
    result.read(self._iprot)
2708 
    self._iprot.readMessageEnd()
2709 
    if result.success is not None:
2710 
      return result.success
2711 
    if result.ex is not None:
2712 
      raise result.ex
2713 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "markOrderReturnRequestReceived failed: unknown result");
2714 
 
2715 
  def markOrderReturnRequestAuthorized(self, orderId, isAuthorized):
2716 
    """
2717 
    CRM person can authorize or deny the request reised by customer. If he authorizes order will change from RET_REQUEST_RECEIVED
2718 
    to RET_REQUEST_AUTHORIZED. If he denies, status will be changed back to DELVIERY_SUCCESS.
2719 
 
2720 
    Parameters:
2721 
     - orderId
2722 
     - isAuthorized
2723 
    """
2724 
    self.send_markOrderReturnRequestAuthorized(orderId, isAuthorized)
2725 
    return self.recv_markOrderReturnRequestAuthorized()
2726 
 
2727 
  def send_markOrderReturnRequestAuthorized(self, orderId, isAuthorized):
2728 
    self._oprot.writeMessageBegin('markOrderReturnRequestAuthorized', TMessageType.CALL, self._seqid)
2729 
    args = markOrderReturnRequestAuthorized_args()
2730 
    args.orderId = orderId
2731 
    args.isAuthorized = isAuthorized
2732 
    args.write(self._oprot)
2733 
    self._oprot.writeMessageEnd()
2734 
    self._oprot.trans.flush()
2735 
 
2736 
  def recv_markOrderReturnRequestAuthorized(self, ):
2737 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2738 
    if mtype == TMessageType.EXCEPTION:
2739 
      x = TApplicationException()
2740 
      x.read(self._iprot)
2741 
      self._iprot.readMessageEnd()
2742 
      raise x
2743 
    result = markOrderReturnRequestAuthorized_result()
2744 
    result.read(self._iprot)
2745 
    self._iprot.readMessageEnd()
2746 
    if result.success is not None:
2747 
      return result.success
2748 
    if result.ex is not None:
2749 
      raise result.ex
2750 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "markOrderReturnRequestAuthorized failed: unknown result");
2751 
 
4579 rajveer 2752 
  def requestPickupNumber(self, orderId, providerId):
2536 chandransh 2753 
    """
2754 
    Sends out an email to the account manager of the original courier provider used to ship the order.
4452 rajveer 2755 
    If the order status was DELIVERY_SUCCESS, it is changed to be DOA_PICKUP_REQUEST_RAISED.
2756 
    If the order status was DOA_PICKUP_REQUEST_RAISED, it is left unchanged.
2536 chandransh 2757 
    For any other status, it returns false.
2758 
    Throws an exception if the order with the given id couldn't be found.
3431 rajveer 2759 
 
2536 chandransh 2760 
    Parameters:
2761 
     - orderId
4579 rajveer 2762 
     - providerId
2536 chandransh 2763 
    """
4579 rajveer 2764 
    self.send_requestPickupNumber(orderId, providerId)
2536 chandransh 2765 
    return self.recv_requestPickupNumber()
2766 
 
4579 rajveer 2767 
  def send_requestPickupNumber(self, orderId, providerId):
2536 chandransh 2768 
    self._oprot.writeMessageBegin('requestPickupNumber', TMessageType.CALL, self._seqid)
2769 
    args = requestPickupNumber_args()
2770 
    args.orderId = orderId
4579 rajveer 2771 
    args.providerId = providerId
2536 chandransh 2772 
    args.write(self._oprot)
2773 
    self._oprot.writeMessageEnd()
2774 
    self._oprot.trans.flush()
2775 
 
2776 
  def recv_requestPickupNumber(self, ):
2777 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2778 
    if mtype == TMessageType.EXCEPTION:
2779 
      x = TApplicationException()
2780 
      x.read(self._iprot)
2781 
      self._iprot.readMessageEnd()
2782 
      raise x
2783 
    result = requestPickupNumber_result()
2784 
    result.read(self._iprot)
2785 
    self._iprot.readMessageEnd()
3431 rajveer 2786 
    if result.success is not None:
2536 chandransh 2787 
      return result.success
3431 rajveer 2788 
    if result.ex is not None:
2536 chandransh 2789 
      raise result.ex
2790 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "requestPickupNumber failed: unknown result");
2791 
 
4602 rajveer 2792 
  def authorizePickup(self, orderId, pickupNumber, providerId):
2536 chandransh 2793 
    """
4452 rajveer 2794 
    If the order status is DOA_PICKUP_REQUEST_RAISED, it does the following
2536 chandransh 2795 
    	1. Sends out an email to the customer with the dispatch advice that he has to print as an attachment.
2796 
    	2. Changes order status to be DOA_PICKUP_AUTHORIZED.
2797 
    	3. Returns true
2591 chandransh 2798 
    If the order is in any other status, it returns false.
2536 chandransh 2799 
    Throws an exception if the order with the given id couldn't be found.
3431 rajveer 2800 
 
2536 chandransh 2801 
    Parameters:
2802 
     - orderId
2803 
     - pickupNumber
4602 rajveer 2804 
     - providerId
2536 chandransh 2805 
    """
4602 rajveer 2806 
    self.send_authorizePickup(orderId, pickupNumber, providerId)
2536 chandransh 2807 
    return self.recv_authorizePickup()
2808 
 
4602 rajveer 2809 
  def send_authorizePickup(self, orderId, pickupNumber, providerId):
2536 chandransh 2810 
    self._oprot.writeMessageBegin('authorizePickup', TMessageType.CALL, self._seqid)
2811 
    args = authorizePickup_args()
2812 
    args.orderId = orderId
2813 
    args.pickupNumber = pickupNumber
4602 rajveer 2814 
    args.providerId = providerId
2536 chandransh 2815 
    args.write(self._oprot)
2816 
    self._oprot.writeMessageEnd()
2817 
    self._oprot.trans.flush()
2818 
 
2819 
  def recv_authorizePickup(self, ):
2820 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2821 
    if mtype == TMessageType.EXCEPTION:
2822 
      x = TApplicationException()
2823 
      x.read(self._iprot)
2824 
      self._iprot.readMessageEnd()
2825 
      raise x
2826 
    result = authorizePickup_result()
2827 
    result.read(self._iprot)
2828 
    self._iprot.readMessageEnd()
3431 rajveer 2829 
    if result.success is not None:
2536 chandransh 2830 
      return result.success
3431 rajveer 2831 
    if result.ex is not None:
2536 chandransh 2832 
      raise result.ex
2833 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "authorizePickup failed: unknown result");
2834 
 
2764 chandransh 2835 
  def markDoasAsPickedUp(self, providerId, pickupDetails):
2836 
    """
2837 
    Marks all DOA_PICKUP_AUTHORIZED orders of the previous day for a provider as DOA_RETURN_IN_TRANSIT.
2838 
    Returns a list of orders that were authorized for pickup but did not appear in the pick-up report.
3431 rajveer 2839 
 
2764 chandransh 2840 
    Parameters:
2841 
     - providerId
2842 
     - pickupDetails
2843 
    """
2844 
    self.send_markDoasAsPickedUp(providerId, pickupDetails)
2845 
    return self.recv_markDoasAsPickedUp()
2846 
 
2847 
  def send_markDoasAsPickedUp(self, providerId, pickupDetails):
2848 
    self._oprot.writeMessageBegin('markDoasAsPickedUp', TMessageType.CALL, self._seqid)
2849 
    args = markDoasAsPickedUp_args()
2850 
    args.providerId = providerId
2851 
    args.pickupDetails = pickupDetails
2852 
    args.write(self._oprot)
2853 
    self._oprot.writeMessageEnd()
2854 
    self._oprot.trans.flush()
2855 
 
2856 
  def recv_markDoasAsPickedUp(self, ):
2857 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2858 
    if mtype == TMessageType.EXCEPTION:
2859 
      x = TApplicationException()
2860 
      x.read(self._iprot)
2861 
      self._iprot.readMessageEnd()
2862 
      raise x
2863 
    result = markDoasAsPickedUp_result()
2864 
    result.read(self._iprot)
2865 
    self._iprot.readMessageEnd()
3431 rajveer 2866 
    if result.success is not None:
2764 chandransh 2867 
      return result.success
2868 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "markDoasAsPickedUp failed: unknown result");
2869 
 
4741 phani.kuma 2870 
  def markReturnOrdersAsPickedUp(self, providerId, pickupDetails):
2871 
    """
2872 
    Marks all RET_PICKUP_CONFIRMED orders of the previous day for a provider as RET_RETURN_IN_TRANSIT.
2873 
    Returns a list of orders that were authorized for pickup but did not appear in the pick-up report.
2874 
 
2875 
    Parameters:
2876 
     - providerId
2877 
     - pickupDetails
2878 
    """
2879 
    self.send_markReturnOrdersAsPickedUp(providerId, pickupDetails)
2880 
    return self.recv_markReturnOrdersAsPickedUp()
2881 
 
2882 
  def send_markReturnOrdersAsPickedUp(self, providerId, pickupDetails):
2883 
    self._oprot.writeMessageBegin('markReturnOrdersAsPickedUp', TMessageType.CALL, self._seqid)
2884 
    args = markReturnOrdersAsPickedUp_args()
2885 
    args.providerId = providerId
2886 
    args.pickupDetails = pickupDetails
2887 
    args.write(self._oprot)
2888 
    self._oprot.writeMessageEnd()
2889 
    self._oprot.trans.flush()
2890 
 
2891 
  def recv_markReturnOrdersAsPickedUp(self, ):
2892 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2893 
    if mtype == TMessageType.EXCEPTION:
2894 
      x = TApplicationException()
2895 
      x.read(self._iprot)
2896 
      self._iprot.readMessageEnd()
2897 
      raise x
2898 
    result = markReturnOrdersAsPickedUp_result()
2899 
    result.read(self._iprot)
2900 
    self._iprot.readMessageEnd()
2901 
    if result.success is not None:
2902 
      return result.success
2903 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "markReturnOrdersAsPickedUp failed: unknown result");
2904 
 
4479 rajveer 2905 
  def receiveReturn(self, orderId, receiveCondition):
2591 chandransh 2906 
    """
4452 rajveer 2907 
    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 2908 
    If the order status is RTO_IN_TRANSIT, marks the order status as RTO_RECEIVED_PRESTINE and returns true.
2591 chandransh 2909 
    If the order is in any other state, it returns false.
2910 
    Throws an exception if the order with the given id couldn't be found.
3431 rajveer 2911 
 
2591 chandransh 2912 
    Parameters:
2913 
     - orderId
4479 rajveer 2914 
     - receiveCondition
2591 chandransh 2915 
    """
4479 rajveer 2916 
    self.send_receiveReturn(orderId, receiveCondition)
2616 chandransh 2917 
    return self.recv_receiveReturn()
2536 chandransh 2918 
 
4479 rajveer 2919 
  def send_receiveReturn(self, orderId, receiveCondition):
2616 chandransh 2920 
    self._oprot.writeMessageBegin('receiveReturn', TMessageType.CALL, self._seqid)
2921 
    args = receiveReturn_args()
2591 chandransh 2922 
    args.orderId = orderId
4479 rajveer 2923 
    args.receiveCondition = receiveCondition
2591 chandransh 2924 
    args.write(self._oprot)
2925 
    self._oprot.writeMessageEnd()
2926 
    self._oprot.trans.flush()
2927 
 
2616 chandransh 2928 
  def recv_receiveReturn(self, ):
2591 chandransh 2929 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2930 
    if mtype == TMessageType.EXCEPTION:
2931 
      x = TApplicationException()
2932 
      x.read(self._iprot)
2933 
      self._iprot.readMessageEnd()
2934 
      raise x
2616 chandransh 2935 
    result = receiveReturn_result()
2591 chandransh 2936 
    result.read(self._iprot)
2937 
    self._iprot.readMessageEnd()
3431 rajveer 2938 
    if result.success is not None:
2591 chandransh 2939 
      return result.success
3431 rajveer 2940 
    if result.ex is not None:
2591 chandransh 2941 
      raise result.ex
2616 chandransh 2942 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "receiveReturn failed: unknown result");
2591 chandransh 2943 
 
2944 
  def validateDoa(self, orderId, isValid):
2945 
    """
4452 rajveer 2946 
    Used to validate the DOA certificate for an order in the DOA_RECEIVED_PRESTINE state. If the certificate is valid,
2616 chandransh 2947 
    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 2948 
    If the order is in any other state, it returns false.
2949 
    Throws an exception if the order with the given id couldn't be found.
3431 rajveer 2950 
 
2591 chandransh 2951 
    Parameters:
2952 
     - orderId
2953 
     - isValid
2954 
    """
2955 
    self.send_validateDoa(orderId, isValid)
2956 
    return self.recv_validateDoa()
2957 
 
2958 
  def send_validateDoa(self, orderId, isValid):
2959 
    self._oprot.writeMessageBegin('validateDoa', TMessageType.CALL, self._seqid)
2960 
    args = validateDoa_args()
2961 
    args.orderId = orderId
2962 
    args.isValid = isValid
2963 
    args.write(self._oprot)
2964 
    self._oprot.writeMessageEnd()
2965 
    self._oprot.trans.flush()
2966 
 
2967 
  def recv_validateDoa(self, ):
2968 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2969 
    if mtype == TMessageType.EXCEPTION:
2970 
      x = TApplicationException()
2971 
      x.read(self._iprot)
2972 
      self._iprot.readMessageEnd()
2973 
      raise x
2974 
    result = validateDoa_result()
2975 
    result.read(self._iprot)
2976 
    self._iprot.readMessageEnd()
3431 rajveer 2977 
    if result.success is not None:
2591 chandransh 2978 
      return result.success
3431 rajveer 2979 
    if result.ex is not None:
2591 chandransh 2980 
      raise result.ex
2981 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "validateDoa failed: unknown result");
2982 
 
4495 rajveer 2983 
  def validateReturnProduct(self, orderId, isUsable):
2984 
    """
2985 
    Parameters:
2986 
     - orderId
2987 
     - isUsable
2988 
    """
2989 
    self.send_validateReturnProduct(orderId, isUsable)
2990 
    return self.recv_validateReturnProduct()
2991 
 
2992 
  def send_validateReturnProduct(self, orderId, isUsable):
2993 
    self._oprot.writeMessageBegin('validateReturnProduct', TMessageType.CALL, self._seqid)
2994 
    args = validateReturnProduct_args()
2995 
    args.orderId = orderId
2996 
    args.isUsable = isUsable
2997 
    args.write(self._oprot)
2998 
    self._oprot.writeMessageEnd()
2999 
    self._oprot.trans.flush()
3000 
 
3001 
  def recv_validateReturnProduct(self, ):
3002 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3003 
    if mtype == TMessageType.EXCEPTION:
3004 
      x = TApplicationException()
3005 
      x.read(self._iprot)
3006 
      self._iprot.readMessageEnd()
3007 
      raise x
3008 
    result = validateReturnProduct_result()
3009 
    result.read(self._iprot)
3010 
    self._iprot.readMessageEnd()
3011 
    if result.success is not None:
3012 
      return result.success
3013 
    if result.ex is not None:
3014 
      raise result.ex
3015 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "validateReturnProduct failed: unknown result");
3016 
 
2616 chandransh 3017 
  def reshipOrder(self, orderId):
3018 
    """
4484 rajveer 3019 
    If the order is in RTO_RECEIVED_PRESTINE or DOA_CERT_INVALID state, it does the following:
2616 chandransh 3020 
    	1. Creates a new order for processing in the BILLED state. All billing information is saved.
4484 rajveer 3021 
    	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 3022 
 
3023 
    If the order is in DOA_CERT_VALID state, it does the following:
3024 
    	1. Creates a new order for processing in the SUBMITTED_FOR_PROCESSING state.
3025 
    	2. Creates a return order for the warehouse executive to return the DOA material.
4452 rajveer 3026 
    	3. Marks the current order as the final DOA_VALID_RESHIPPED state.
3431 rajveer 3027 
 
2616 chandransh 3028 
    Returns the id of the newly created order.
3431 rajveer 3029 
 
2616 chandransh 3030 
    Throws an exception if the order with the given id couldn't be found.
3431 rajveer 3031 
 
2616 chandransh 3032 
    Parameters:
3033 
     - orderId
3034 
    """
3035 
    self.send_reshipOrder(orderId)
3036 
    return self.recv_reshipOrder()
2591 chandransh 3037 
 
2616 chandransh 3038 
  def send_reshipOrder(self, orderId):
3039 
    self._oprot.writeMessageBegin('reshipOrder', TMessageType.CALL, self._seqid)
3040 
    args = reshipOrder_args()
3041 
    args.orderId = orderId
3042 
    args.write(self._oprot)
3043 
    self._oprot.writeMessageEnd()
3044 
    self._oprot.trans.flush()
3045 
 
3046 
  def recv_reshipOrder(self, ):
3047 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3048 
    if mtype == TMessageType.EXCEPTION:
3049 
      x = TApplicationException()
3050 
      x.read(self._iprot)
3051 
      self._iprot.readMessageEnd()
3052 
      raise x
3053 
    result = reshipOrder_result()
3054 
    result.read(self._iprot)
3055 
    self._iprot.readMessageEnd()
3431 rajveer 3056 
    if result.success is not None:
2616 chandransh 3057 
      return result.success
3431 rajveer 3058 
    if result.ex is not None:
2616 chandransh 3059 
      raise result.ex
3060 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "reshipOrder failed: unknown result");
3061 
 
3226 chandransh 3062 
  def refundOrder(self, orderId, refundedBy, reason):
2616 chandransh 3063 
    """
4484 rajveer 3064 
    If the order is in RTO_RECEIVED_PRESTINE, DOA_CERT_VALID or DOA_CERT_INVALID state, it does the following:
2616 chandransh 3065 
    	1. Creates a refund request for batch processing.
3066 
    	2. Creates a return order for the warehouse executive to return the shipped material.
4484 rajveer 3067 
    	3. Marks the current order as RTO_REFUNDED, DOA_VALID_REFUNDED or DOA_INVALID_REFUNDED final states.
3431 rajveer 3068 
 
2616 chandransh 3069 
    If the order is in SUBMITTED_FOR_PROCESSING or INVENTORY_LOW state, it does the following:
3070 
    	1. Creates a refund request for batch processing.
3226 chandransh 3071 
    	2. Cancels the reservation of the item in the warehouse.
3072 
    	3. Marks the current order as the REFUNDED final state.
3431 rajveer 3073 
 
3226 chandransh 3074 
    For all COD orders, if the order is in INIT, SUBMITTED_FOR_PROCESSING or INVENTORY_LOW state, it does the following:
3075 
    	1. Cancels the reservation of the item in the warehouse.
3076 
    	2. Marks the current order as CANCELED.
3077 
 
3078 
    In all cases, it updates the reason for cancellation or refund and the person who performed the action.
3079 
 
2616 chandransh 3080 
    Returns True if it is successful, False otherwise.
3431 rajveer 3081 
 
2616 chandransh 3082 
    Throws an exception if the order with the given id couldn't be found.
3431 rajveer 3083 
 
2616 chandransh 3084 
    Parameters:
3085 
     - orderId
3226 chandransh 3086 
     - refundedBy
3087 
     - reason
2616 chandransh 3088 
    """
3226 chandransh 3089 
    self.send_refundOrder(orderId, refundedBy, reason)
2616 chandransh 3090 
    return self.recv_refundOrder()
3091 
 
3226 chandransh 3092 
  def send_refundOrder(self, orderId, refundedBy, reason):
2616 chandransh 3093 
    self._oprot.writeMessageBegin('refundOrder', TMessageType.CALL, self._seqid)
3094 
    args = refundOrder_args()
3095 
    args.orderId = orderId
3226 chandransh 3096 
    args.refundedBy = refundedBy
3097 
    args.reason = reason
2616 chandransh 3098 
    args.write(self._oprot)
3099 
    self._oprot.writeMessageEnd()
3100 
    self._oprot.trans.flush()
3101 
 
3102 
  def recv_refundOrder(self, ):
3103 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3104 
    if mtype == TMessageType.EXCEPTION:
3105 
      x = TApplicationException()
3106 
      x.read(self._iprot)
3107 
      self._iprot.readMessageEnd()
3108 
      raise x
3109 
    result = refundOrder_result()
3110 
    result.read(self._iprot)
3111 
    self._iprot.readMessageEnd()
3431 rajveer 3112 
    if result.success is not None:
2616 chandransh 3113 
      return result.success
3431 rajveer 3114 
    if result.ex is not None:
2616 chandransh 3115 
      raise result.ex
3116 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "refundOrder failed: unknown result");
3117 
 
2690 chandransh 3118 
  def getReturnOrders(self, warehouseId, fromDate, toDate):
3119 
    """
3120 
    Get all return orders created between the from and to dates for the given warehouse.
3121 
    Ignores the warehouse if it is passed as -1.
3431 rajveer 3122 
 
2690 chandransh 3123 
    Parameters:
3124 
     - warehouseId
3125 
     - fromDate
3126 
     - toDate
3127 
    """
3128 
    self.send_getReturnOrders(warehouseId, fromDate, toDate)
3129 
    return self.recv_getReturnOrders()
2616 chandransh 3130 
 
2690 chandransh 3131 
  def send_getReturnOrders(self, warehouseId, fromDate, toDate):
3132 
    self._oprot.writeMessageBegin('getReturnOrders', TMessageType.CALL, self._seqid)
3133 
    args = getReturnOrders_args()
3134 
    args.warehouseId = warehouseId
3135 
    args.fromDate = fromDate
3136 
    args.toDate = toDate
3137 
    args.write(self._oprot)
3138 
    self._oprot.writeMessageEnd()
3139 
    self._oprot.trans.flush()
3140 
 
3141 
  def recv_getReturnOrders(self, ):
3142 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3143 
    if mtype == TMessageType.EXCEPTION:
3144 
      x = TApplicationException()
3145 
      x.read(self._iprot)
3146 
      self._iprot.readMessageEnd()
3147 
      raise x
3148 
    result = getReturnOrders_result()
3149 
    result.read(self._iprot)
3150 
    self._iprot.readMessageEnd()
3431 rajveer 3151 
    if result.success is not None:
2690 chandransh 3152 
      return result.success
3153 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getReturnOrders failed: unknown result");
3154 
 
2700 chandransh 3155 
  def getReturnOrder(self, id):
3156 
    """
3157 
    Returns the ReturnOrder corresponding to the given id.
3158 
    Throws an exception if the return order with the given id couldn't be found.
3431 rajveer 3159 
 
2700 chandransh 3160 
    Parameters:
3161 
     - id
3162 
    """
3163 
    self.send_getReturnOrder(id)
3164 
    return self.recv_getReturnOrder()
3165 
 
3166 
  def send_getReturnOrder(self, id):
3167 
    self._oprot.writeMessageBegin('getReturnOrder', TMessageType.CALL, self._seqid)
3168 
    args = getReturnOrder_args()
3169 
    args.id = id
3170 
    args.write(self._oprot)
3171 
    self._oprot.writeMessageEnd()
3172 
    self._oprot.trans.flush()
3173 
 
3174 
  def recv_getReturnOrder(self, ):
3175 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3176 
    if mtype == TMessageType.EXCEPTION:
3177 
      x = TApplicationException()
3178 
      x.read(self._iprot)
3179 
      self._iprot.readMessageEnd()
3180 
      raise x
3181 
    result = getReturnOrder_result()
3182 
    result.read(self._iprot)
3183 
    self._iprot.readMessageEnd()
3431 rajveer 3184 
    if result.success is not None:
2700 chandransh 3185 
      return result.success
3431 rajveer 3186 
    if result.ex is not None:
2700 chandransh 3187 
      raise result.ex
3188 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getReturnOrder failed: unknown result");
3189 
 
2690 chandransh 3190 
  def processReturn(self, returnOrderId):
3191 
    """
3192 
    Marks the return order with the given id as processed. Raises an exception if no such return order exists.
3431 rajveer 3193 
 
2690 chandransh 3194 
    Parameters:
3195 
     - returnOrderId
3196 
    """
3197 
    self.send_processReturn(returnOrderId)
3198 
    self.recv_processReturn()
3199 
 
3200 
  def send_processReturn(self, returnOrderId):
3201 
    self._oprot.writeMessageBegin('processReturn', TMessageType.CALL, self._seqid)
3202 
    args = processReturn_args()
3203 
    args.returnOrderId = returnOrderId
3204 
    args.write(self._oprot)
3205 
    self._oprot.writeMessageEnd()
3206 
    self._oprot.trans.flush()
3207 
 
3208 
  def recv_processReturn(self, ):
3209 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3210 
    if mtype == TMessageType.EXCEPTION:
3211 
      x = TApplicationException()
3212 
      x.read(self._iprot)
3213 
      self._iprot.readMessageEnd()
3214 
      raise x
3215 
    result = processReturn_result()
3216 
    result.read(self._iprot)
3217 
    self._iprot.readMessageEnd()
3431 rajveer 3218 
    if result.ex is not None:
2690 chandransh 3219 
      raise result.ex
3220 
    return
3221 
 
3451 chandransh 3222 
  def updateWeight(self, orderId, weight):
3223 
    """
3224 
    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 3225 
 
3451 chandransh 3226 
    Parameters:
3227 
     - orderId
3228 
     - weight
3229 
    """
3230 
    self.send_updateWeight(orderId, weight)
3231 
    return self.recv_updateWeight()
3232 
 
3233 
  def send_updateWeight(self, orderId, weight):
3234 
    self._oprot.writeMessageBegin('updateWeight', TMessageType.CALL, self._seqid)
3235 
    args = updateWeight_args()
3236 
    args.orderId = orderId
3237 
    args.weight = weight
3238 
    args.write(self._oprot)
3239 
    self._oprot.writeMessageEnd()
3240 
    self._oprot.trans.flush()
3241 
 
3242 
  def recv_updateWeight(self, ):
3243 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3244 
    if mtype == TMessageType.EXCEPTION:
3245 
      x = TApplicationException()
3246 
      x.read(self._iprot)
3247 
      self._iprot.readMessageEnd()
3248 
      raise x
3249 
    result = updateWeight_result()
3250 
    result.read(self._iprot)
3251 
    self._iprot.readMessageEnd()
3252 
    if result.success is not None:
3253 
      return result.success
3254 
    if result.ex is not None:
3255 
      raise result.ex
3256 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "updateWeight failed: unknown result");
3257 
 
3469 chandransh 3258 
  def changeItem(self, orderId, itemId):
3259 
    """
3260 
    Change the item to be shipped for this order. Also adjusts the reservation in the inventory accordingly.
3261 
    Currently, it also ensures that only a different color of the given item is shipped.
3451 chandransh 3262 
 
3469 chandransh 3263 
    Parameters:
3264 
     - orderId
3265 
     - itemId
3266 
    """
3267 
    self.send_changeItem(orderId, itemId)
3268 
    return self.recv_changeItem()
3269 
 
3270 
  def send_changeItem(self, orderId, itemId):
3271 
    self._oprot.writeMessageBegin('changeItem', TMessageType.CALL, self._seqid)
3272 
    args = changeItem_args()
3273 
    args.orderId = orderId
3274 
    args.itemId = itemId
3275 
    args.write(self._oprot)
3276 
    self._oprot.writeMessageEnd()
3277 
    self._oprot.trans.flush()
3278 
 
3279 
  def recv_changeItem(self, ):
3280 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3281 
    if mtype == TMessageType.EXCEPTION:
3282 
      x = TApplicationException()
3283 
      x.read(self._iprot)
3284 
      self._iprot.readMessageEnd()
3285 
      raise x
3286 
    result = changeItem_result()
3287 
    result.read(self._iprot)
3288 
    self._iprot.readMessageEnd()
3289 
    if result.success is not None:
3290 
      return result.success
3291 
    if result.ex is not None:
3292 
      raise result.ex
3293 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "changeItem failed: unknown result");
3294 
 
3295 
  def shiftToWarehouse(self, orderId, warehouseId):
3296 
    """
3297 
    Moves the given order to the given warehouse. Also adjusts the inventory reservations accordingly.
3298 
 
3299 
    Parameters:
3300 
     - orderId
3301 
     - warehouseId
3302 
    """
3303 
    self.send_shiftToWarehouse(orderId, warehouseId)
3304 
    return self.recv_shiftToWarehouse()
3305 
 
3306 
  def send_shiftToWarehouse(self, orderId, warehouseId):
3307 
    self._oprot.writeMessageBegin('shiftToWarehouse', TMessageType.CALL, self._seqid)
3308 
    args = shiftToWarehouse_args()
3309 
    args.orderId = orderId
3310 
    args.warehouseId = warehouseId
3311 
    args.write(self._oprot)
3312 
    self._oprot.writeMessageEnd()
3313 
    self._oprot.trans.flush()
3314 
 
3315 
  def recv_shiftToWarehouse(self, ):
3316 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3317 
    if mtype == TMessageType.EXCEPTION:
3318 
      x = TApplicationException()
3319 
      x.read(self._iprot)
3320 
      self._iprot.readMessageEnd()
3321 
      raise x
3322 
    result = shiftToWarehouse_result()
3323 
    result.read(self._iprot)
3324 
    self._iprot.readMessageEnd()
3325 
    if result.success is not None:
3326 
      return result.success
3327 
    if result.ex is not None:
3328 
      raise result.ex
3329 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "shiftToWarehouse failed: unknown result");
3330 
 
4647 rajveer 3331 
  def addDelayReason(self, orderId, delayReason, furtherDelay, delayReasonText):
3553 chandransh 3332 
    """
3333 
    Adds the given delay reason to the given order.
3986 chandransh 3334 
    Increases the expected delivery time of the given order by the given no. of days.
3553 chandransh 3335 
    Raises an exception if no order with the given id can be found.
3469 chandransh 3336 
 
3553 chandransh 3337 
    Parameters:
3338 
     - orderId
3339 
     - delayReason
3986 chandransh 3340 
     - furtherDelay
4647 rajveer 3341 
     - delayReasonText
3553 chandransh 3342 
    """
4647 rajveer 3343 
    self.send_addDelayReason(orderId, delayReason, furtherDelay, delayReasonText)
3553 chandransh 3344 
    return self.recv_addDelayReason()
3345 
 
4647 rajveer 3346 
  def send_addDelayReason(self, orderId, delayReason, furtherDelay, delayReasonText):
3553 chandransh 3347 
    self._oprot.writeMessageBegin('addDelayReason', TMessageType.CALL, self._seqid)
3348 
    args = addDelayReason_args()
3349 
    args.orderId = orderId
3350 
    args.delayReason = delayReason
3986 chandransh 3351 
    args.furtherDelay = furtherDelay
4647 rajveer 3352 
    args.delayReasonText = delayReasonText
3553 chandransh 3353 
    args.write(self._oprot)
3354 
    self._oprot.writeMessageEnd()
3355 
    self._oprot.trans.flush()
3356 
 
3357 
  def recv_addDelayReason(self, ):
3358 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3359 
    if mtype == TMessageType.EXCEPTION:
3360 
      x = TApplicationException()
3361 
      x.read(self._iprot)
3362 
      self._iprot.readMessageEnd()
3363 
      raise x
3364 
    result = addDelayReason_result()
3365 
    result.read(self._iprot)
3366 
    self._iprot.readMessageEnd()
3367 
    if result.success is not None:
3368 
      return result.success
3369 
    if result.ex is not None:
3370 
      raise result.ex
3371 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "addDelayReason failed: unknown result");
3372 
 
3956 chandransh 3373 
  def reconcileCodCollection(self, collectedAmountMap, xferBy, xferTxnId, xferDate):
3374 
    """
3375 
    Marks the COD orders with given AWB nos. as having been processed.
3376 
    Updates the captured amount for the corresponding payment.
3553 chandransh 3377 
 
3956 chandransh 3378 
    Returns a map of AWBs which were not processed and the associated reason. An AWB is not processed if:
3379 
    1. There is no order corresponding to an AWB number.
3380 
    2. The captured amount for a payment exceeds the total payment.
3381 
    3. The order corresponding to an AWB no. is in a state prior to DELIVERY_SUCCESS.
3382 
 
3383 
    Parameters:
3384 
     - collectedAmountMap
3385 
     - xferBy
3386 
     - xferTxnId
3387 
     - xferDate
3388 
    """
3389 
    self.send_reconcileCodCollection(collectedAmountMap, xferBy, xferTxnId, xferDate)
3390 
    return self.recv_reconcileCodCollection()
3391 
 
3392 
  def send_reconcileCodCollection(self, collectedAmountMap, xferBy, xferTxnId, xferDate):
3393 
    self._oprot.writeMessageBegin('reconcileCodCollection', TMessageType.CALL, self._seqid)
3394 
    args = reconcileCodCollection_args()
3395 
    args.collectedAmountMap = collectedAmountMap
3396 
    args.xferBy = xferBy
3397 
    args.xferTxnId = xferTxnId
3398 
    args.xferDate = xferDate
3399 
    args.write(self._oprot)
3400 
    self._oprot.writeMessageEnd()
3401 
    self._oprot.trans.flush()
3402 
 
3403 
  def recv_reconcileCodCollection(self, ):
3404 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3405 
    if mtype == TMessageType.EXCEPTION:
3406 
      x = TApplicationException()
3407 
      x.read(self._iprot)
3408 
      self._iprot.readMessageEnd()
3409 
      raise x
3410 
    result = reconcileCodCollection_result()
3411 
    result.read(self._iprot)
3412 
    self._iprot.readMessageEnd()
3413 
    if result.success is not None:
3414 
      return result.success
3415 
    if result.ex is not None:
3416 
      raise result.ex
3417 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "reconcileCodCollection failed: unknown result");
3418 
 
4008 mandeep.dh 3419 
  def getTransactionsRequiringExtraProcessing(self, category):
3420 
    """
4065 mandeep.dh 3421 
    Returns the list of transaction ids that require some extra processing and
4008 mandeep.dh 3422 
    which belong to a particular category. This is currently used by CRM
4065 mandeep.dh 3423 
    application. If no such transaction ids are present, it returns an empty list.
3956 chandransh 3424 
 
4008 mandeep.dh 3425 
    Parameters:
3426 
     - category
3427 
    """
3428 
    self.send_getTransactionsRequiringExtraProcessing(category)
3429 
    return self.recv_getTransactionsRequiringExtraProcessing()
3430 
 
3431 
  def send_getTransactionsRequiringExtraProcessing(self, category):
3432 
    self._oprot.writeMessageBegin('getTransactionsRequiringExtraProcessing', TMessageType.CALL, self._seqid)
3433 
    args = getTransactionsRequiringExtraProcessing_args()
3434 
    args.category = category
3435 
    args.write(self._oprot)
3436 
    self._oprot.writeMessageEnd()
3437 
    self._oprot.trans.flush()
3438 
 
3439 
  def recv_getTransactionsRequiringExtraProcessing(self, ):
3440 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3441 
    if mtype == TMessageType.EXCEPTION:
3442 
      x = TApplicationException()
3443 
      x.read(self._iprot)
3444 
      self._iprot.readMessageEnd()
3445 
      raise x
3446 
    result = getTransactionsRequiringExtraProcessing_result()
3447 
    result.read(self._iprot)
3448 
    self._iprot.readMessageEnd()
3449 
    if result.success is not None:
3450 
      return result.success
3451 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getTransactionsRequiringExtraProcessing failed: unknown result");
3452 
 
3453 
  def markTransactionAsProcessed(self, transactionId, category):
3454 
    """
3455 
    Marks a particular transaction as processed for a particular cateogory.
4065 mandeep.dh 3456 
    It essentially deletes the transaction id record for a particular
3457 
    processing type category (if present) from DB.
3458 
    This is currently used by CRM application.
4008 mandeep.dh 3459 
 
3460 
    Parameters:
3461 
     - transactionId
3462 
     - category
3463 
    """
3464 
    self.send_markTransactionAsProcessed(transactionId, category)
3465 
    self.recv_markTransactionAsProcessed()
3466 
 
3467 
  def send_markTransactionAsProcessed(self, transactionId, category):
3468 
    self._oprot.writeMessageBegin('markTransactionAsProcessed', TMessageType.CALL, self._seqid)
3469 
    args = markTransactionAsProcessed_args()
3470 
    args.transactionId = transactionId
3471 
    args.category = category
3472 
    args.write(self._oprot)
3473 
    self._oprot.writeMessageEnd()
3474 
    self._oprot.trans.flush()
3475 
 
3476 
  def recv_markTransactionAsProcessed(self, ):
3477 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3478 
    if mtype == TMessageType.EXCEPTION:
3479 
      x = TApplicationException()
3480 
      x.read(self._iprot)
3481 
      self._iprot.readMessageEnd()
3482 
      raise x
3483 
    result = markTransactionAsProcessed_result()
3484 
    result.read(self._iprot)
3485 
    self._iprot.readMessageEnd()
3486 
    return
3487 
 
4018 chandransh 3488 
  def getItemWiseRiskyOrdersCount(self, ):
3489 
    """
3490 
    Returns a map containing the number of risky orders keyed by item id. A risky order
3491 
    is defined as one whose shipping date is about to expire.
3492 
    """
3493 
    self.send_getItemWiseRiskyOrdersCount()
3494 
    return self.recv_getItemWiseRiskyOrdersCount()
4008 mandeep.dh 3495 
 
4018 chandransh 3496 
  def send_getItemWiseRiskyOrdersCount(self, ):
3497 
    self._oprot.writeMessageBegin('getItemWiseRiskyOrdersCount', TMessageType.CALL, self._seqid)
3498 
    args = getItemWiseRiskyOrdersCount_args()
3499 
    args.write(self._oprot)
3500 
    self._oprot.writeMessageEnd()
3501 
    self._oprot.trans.flush()
3502 
 
3503 
  def recv_getItemWiseRiskyOrdersCount(self, ):
3504 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3505 
    if mtype == TMessageType.EXCEPTION:
3506 
      x = TApplicationException()
3507 
      x.read(self._iprot)
3508 
      self._iprot.readMessageEnd()
3509 
      raise x
3510 
    result = getItemWiseRiskyOrdersCount_result()
3511 
    result.read(self._iprot)
3512 
    self._iprot.readMessageEnd()
3513 
    if result.success is not None:
3514 
      return result.success
3515 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getItemWiseRiskyOrdersCount failed: unknown result");
3516 
 
4295 varun.gupt 3517 
  def getOrdersForItemIds(self, itemIds):
3518 
    """
3519 
    Returns a list of all orders which have items with given id
3520 
 
3521 
    Parameters:
3522 
     - itemIds
3523 
    """
3524 
    self.send_getOrdersForItemIds(itemIds)
3525 
    return self.recv_getOrdersForItemIds()
3526 
 
3527 
  def send_getOrdersForItemIds(self, itemIds):
3528 
    self._oprot.writeMessageBegin('getOrdersForItemIds', TMessageType.CALL, self._seqid)
3529 
    args = getOrdersForItemIds_args()
3530 
    args.itemIds = itemIds
3531 
    args.write(self._oprot)
3532 
    self._oprot.writeMessageEnd()
3533 
    self._oprot.trans.flush()
3534 
 
3535 
  def recv_getOrdersForItemIds(self, ):
3536 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3537 
    if mtype == TMessageType.EXCEPTION:
3538 
      x = TApplicationException()
3539 
      x.read(self._iprot)
3540 
      self._iprot.readMessageEnd()
3541 
      raise x
3542 
    result = getOrdersForItemIds_result()
3543 
    result.read(self._iprot)
3544 
    self._iprot.readMessageEnd()
3545 
    if result.success is not None:
3546 
      return result.success
3547 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getOrdersForItemIds failed: unknown result");
3548 
 
4247 rajveer 3549 
  def markOrderCancellationRequestReceived(self, orderId):
3550 
    """
3551 
    Mark order as cancellation request received. If customer sends request of cancellation of
3552 
    a particular order, this method will be called. It will just change status of the order
3553 
    depending on its current status. It also records the previous status, so that we can move
3554 
    back to that status if cancellation request is denied.
4018 chandransh 3555 
 
4247 rajveer 3556 
    Parameters:
3557 
     - orderId
3558 
    """
3559 
    self.send_markOrderCancellationRequestReceived(orderId)
3560 
    self.recv_markOrderCancellationRequestReceived()
3561 
 
3562 
  def send_markOrderCancellationRequestReceived(self, orderId):
3563 
    self._oprot.writeMessageBegin('markOrderCancellationRequestReceived', TMessageType.CALL, self._seqid)
3564 
    args = markOrderCancellationRequestReceived_args()
3565 
    args.orderId = orderId
3566 
    args.write(self._oprot)
3567 
    self._oprot.writeMessageEnd()
3568 
    self._oprot.trans.flush()
3569 
 
3570 
  def recv_markOrderCancellationRequestReceived(self, ):
3571 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3572 
    if mtype == TMessageType.EXCEPTION:
3573 
      x = TApplicationException()
3574 
      x.read(self._iprot)
3575 
      self._iprot.readMessageEnd()
3576 
      raise x
3577 
    result = markOrderCancellationRequestReceived_result()
3578 
    result.read(self._iprot)
3579 
    self._iprot.readMessageEnd()
3580 
    if result.ex is not None:
3581 
      raise result.ex
3582 
    return
3583 
 
3584 
  def markOrderCancellationRequestConfirmed(self, orderId):
3585 
    """
3586 
    If we decide to to cancel order, CRM will call this method to move the status of order to
3587 
    cancellation request confirmed. After this OM will be able to cancel the order.
3588 
 
3589 
    Parameters:
3590 
     - orderId
3591 
    """
3592 
    self.send_markOrderCancellationRequestConfirmed(orderId)
3593 
    self.recv_markOrderCancellationRequestConfirmed()
3594 
 
3595 
  def send_markOrderCancellationRequestConfirmed(self, orderId):
3596 
    self._oprot.writeMessageBegin('markOrderCancellationRequestConfirmed', TMessageType.CALL, self._seqid)
3597 
    args = markOrderCancellationRequestConfirmed_args()
3598 
    args.orderId = orderId
3599 
    args.write(self._oprot)
3600 
    self._oprot.writeMessageEnd()
3601 
    self._oprot.trans.flush()
3602 
 
3603 
  def recv_markOrderCancellationRequestConfirmed(self, ):
3604 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3605 
    if mtype == TMessageType.EXCEPTION:
3606 
      x = TApplicationException()
3607 
      x.read(self._iprot)
3608 
      self._iprot.readMessageEnd()
3609 
      raise x
3610 
    result = markOrderCancellationRequestConfirmed_result()
3611 
    result.read(self._iprot)
3612 
    self._iprot.readMessageEnd()
3613 
    if result.ex is not None:
3614 
      raise result.ex
3615 
    return
3616 
 
3617 
  def markOrderCancellationRequestDenied(self, orderId):
3618 
    """
3619 
    If we decide to not to cancel order, we will move the order ro previous status.
3620 
 
3621 
    Parameters:
3622 
     - orderId
3623 
    """
3624 
    self.send_markOrderCancellationRequestDenied(orderId)
3625 
    self.recv_markOrderCancellationRequestDenied()
3626 
 
3627 
  def send_markOrderCancellationRequestDenied(self, orderId):
3628 
    self._oprot.writeMessageBegin('markOrderCancellationRequestDenied', TMessageType.CALL, self._seqid)
3629 
    args = markOrderCancellationRequestDenied_args()
3630 
    args.orderId = orderId
3631 
    args.write(self._oprot)
3632 
    self._oprot.writeMessageEnd()
3633 
    self._oprot.trans.flush()
3634 
 
3635 
  def recv_markOrderCancellationRequestDenied(self, ):
3636 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3637 
    if mtype == TMessageType.EXCEPTION:
3638 
      x = TApplicationException()
3639 
      x.read(self._iprot)
3640 
      self._iprot.readMessageEnd()
3641 
      raise x
3642 
    result = markOrderCancellationRequestDenied_result()
3643 
    result.read(self._iprot)
3644 
    self._iprot.readMessageEnd()
3645 
    if result.ex is not None:
3646 
      raise result.ex
3647 
    return
3648 
 
4258 rajveer 3649 
  def markTransactionAsPaymentFlagRemoved(self, transactionId):
4247 rajveer 3650 
    """
4258 rajveer 3651 
    If we and/or payment gateway has decided to accept the payment, this method needs to be called.
3652 
    Changed transaction and all orders status to payment accepted.
4247 rajveer 3653 
 
3654 
    Parameters:
4258 rajveer 3655 
     - transactionId
4247 rajveer 3656 
    """
4258 rajveer 3657 
    self.send_markTransactionAsPaymentFlagRemoved(transactionId)
3658 
    self.recv_markTransactionAsPaymentFlagRemoved()
4247 rajveer 3659 
 
4258 rajveer 3660 
  def send_markTransactionAsPaymentFlagRemoved(self, transactionId):
3661 
    self._oprot.writeMessageBegin('markTransactionAsPaymentFlagRemoved', TMessageType.CALL, self._seqid)
3662 
    args = markTransactionAsPaymentFlagRemoved_args()
3663 
    args.transactionId = transactionId
4247 rajveer 3664 
    args.write(self._oprot)
3665 
    self._oprot.writeMessageEnd()
3666 
    self._oprot.trans.flush()
3667 
 
4258 rajveer 3668 
  def recv_markTransactionAsPaymentFlagRemoved(self, ):
4247 rajveer 3669 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3670 
    if mtype == TMessageType.EXCEPTION:
3671 
      x = TApplicationException()
3672 
      x.read(self._iprot)
3673 
      self._iprot.readMessageEnd()
3674 
      raise x
4258 rajveer 3675 
    result = markTransactionAsPaymentFlagRemoved_result()
4247 rajveer 3676 
    result.read(self._iprot)
3677 
    self._iprot.readMessageEnd()
3678 
    if result.ex is not None:
3679 
      raise result.ex
3680 
    return
3681 
 
4259 anupam.sin 3682 
  def refundTransaction(self, transactionId, refundedBy, reason):
3683 
    """
3684 
    This method is called when a flagged payment is deemed unserviceable and the corresponding orders
3685 
    need to be cancelled
4247 rajveer 3686 
 
4259 anupam.sin 3687 
    Parameters:
3688 
     - transactionId
3689 
     - refundedBy
3690 
     - reason
3691 
    """
3692 
    self.send_refundTransaction(transactionId, refundedBy, reason)
3693 
    self.recv_refundTransaction()
3694 
 
3695 
  def send_refundTransaction(self, transactionId, refundedBy, reason):
3696 
    self._oprot.writeMessageBegin('refundTransaction', TMessageType.CALL, self._seqid)
3697 
    args = refundTransaction_args()
3698 
    args.transactionId = transactionId
3699 
    args.refundedBy = refundedBy
3700 
    args.reason = reason
3701 
    args.write(self._oprot)
3702 
    self._oprot.writeMessageEnd()
3703 
    self._oprot.trans.flush()
3704 
 
3705 
  def recv_refundTransaction(self, ):
3706 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3707 
    if mtype == TMessageType.EXCEPTION:
3708 
      x = TApplicationException()
3709 
      x.read(self._iprot)
3710 
      self._iprot.readMessageEnd()
3711 
      raise x
3712 
    result = refundTransaction_result()
3713 
    result.read(self._iprot)
3714 
    self._iprot.readMessageEnd()
3715 
    if result.ex is not None:
3716 
      raise result.ex
3717 
    return
3718 
 
4324 mandeep.dh 3719 
  def updateShipmentAddress(self, orderId, addressId):
3720 
    """
3721 
    Updates shipment address of an order. Delivery and shipping date estimates
3722 
    etc. are also updated here.
3723 
 
3724 
    Throws TransactionServiceException in case address change is not
3725 
    possible due to certain reasons such as new pincode in address is
3726 
    not serviceable etc.
3727 
 
3728 
    Parameters:
3729 
     - orderId
3730 
     - addressId
3731 
    """
3732 
    self.send_updateShipmentAddress(orderId, addressId)
3733 
    self.recv_updateShipmentAddress()
3734 
 
3735 
  def send_updateShipmentAddress(self, orderId, addressId):
3736 
    self._oprot.writeMessageBegin('updateShipmentAddress', TMessageType.CALL, self._seqid)
3737 
    args = updateShipmentAddress_args()
3738 
    args.orderId = orderId
3739 
    args.addressId = addressId
3740 
    args.write(self._oprot)
3741 
    self._oprot.writeMessageEnd()
3742 
    self._oprot.trans.flush()
3743 
 
3744 
  def recv_updateShipmentAddress(self, ):
3745 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3746 
    if mtype == TMessageType.EXCEPTION:
3747 
      x = TApplicationException()
3748 
      x.read(self._iprot)
3749 
      self._iprot.readMessageEnd()
3750 
      raise x
3751 
    result = updateShipmentAddress_result()
3752 
    result.read(self._iprot)
3753 
    self._iprot.readMessageEnd()
3754 
    if result.ex is not None:
3755 
      raise result.ex
3756 
    return
3757 
 
4285 rajveer 3758 
  def acceptOrdersForItemId(self, itemId, inventory):
3759 
    """
3760 
    Marks the orders as ACCEPTED for the given itemId and inventory. It also updates the accepted timestamp. If the
3761 
    given order is not a COD order, it also captures the payment if the same has not been captured.
4259 anupam.sin 3762 
 
4285 rajveer 3763 
    Parameters:
3764 
     - itemId
3765 
     - inventory
3766 
    """
3767 
    self.send_acceptOrdersForItemId(itemId, inventory)
3768 
    return self.recv_acceptOrdersForItemId()
3769 
 
3770 
  def send_acceptOrdersForItemId(self, itemId, inventory):
3771 
    self._oprot.writeMessageBegin('acceptOrdersForItemId', TMessageType.CALL, self._seqid)
3772 
    args = acceptOrdersForItemId_args()
3773 
    args.itemId = itemId
3774 
    args.inventory = inventory
3775 
    args.write(self._oprot)
3776 
    self._oprot.writeMessageEnd()
3777 
    self._oprot.trans.flush()
3778 
 
3779 
  def recv_acceptOrdersForItemId(self, ):
3780 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3781 
    if mtype == TMessageType.EXCEPTION:
3782 
      x = TApplicationException()
3783 
      x.read(self._iprot)
3784 
      self._iprot.readMessageEnd()
3785 
      raise x
3786 
    result = acceptOrdersForItemId_result()
3787 
    result.read(self._iprot)
3788 
    self._iprot.readMessageEnd()
3789 
    if result.success is not None:
3790 
      return result.success
3791 
    if result.ex is not None:
3792 
      raise result.ex
3793 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "acceptOrdersForItemId failed: unknown result");
3794 
 
4369 rajveer 3795 
  def markOrdersAsPORaised(self, vendorId, itemId, quantity, estimate, isReminder):
4303 rajveer 3796 
    """
3797 
    Parameters:
3798 
     - vendorId
3799 
     - itemId
3800 
     - quantity
3801 
     - estimate
4369 rajveer 3802 
     - isReminder
4303 rajveer 3803 
    """
4369 rajveer 3804 
    self.send_markOrdersAsPORaised(vendorId, itemId, quantity, estimate, isReminder)
4303 rajveer 3805 
    self.recv_markOrdersAsPORaised()
4285 rajveer 3806 
 
4369 rajveer 3807 
  def send_markOrdersAsPORaised(self, vendorId, itemId, quantity, estimate, isReminder):
4303 rajveer 3808 
    self._oprot.writeMessageBegin('markOrdersAsPORaised', TMessageType.CALL, self._seqid)
3809 
    args = markOrdersAsPORaised_args()
3810 
    args.vendorId = vendorId
3811 
    args.itemId = itemId
3812 
    args.quantity = quantity
3813 
    args.estimate = estimate
4369 rajveer 3814 
    args.isReminder = isReminder
4303 rajveer 3815 
    args.write(self._oprot)
3816 
    self._oprot.writeMessageEnd()
3817 
    self._oprot.trans.flush()
3818 
 
3819 
  def recv_markOrdersAsPORaised(self, ):
3820 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3821 
    if mtype == TMessageType.EXCEPTION:
3822 
      x = TApplicationException()
3823 
      x.read(self._iprot)
3824 
      self._iprot.readMessageEnd()
3825 
      raise x
3826 
    result = markOrdersAsPORaised_result()
3827 
    result.read(self._iprot)
3828 
    self._iprot.readMessageEnd()
3829 
    if result.ex is not None:
3830 
      raise result.ex
3831 
    return
3832 
 
4369 rajveer 3833 
  def markOrdersAsReversalInitiated(self, vendorId, itemId, quantity, estimate, isReminder):
4303 rajveer 3834 
    """
3835 
    Parameters:
3836 
     - vendorId
3837 
     - itemId
3838 
     - quantity
3839 
     - estimate
4369 rajveer 3840 
     - isReminder
4303 rajveer 3841 
    """
4369 rajveer 3842 
    self.send_markOrdersAsReversalInitiated(vendorId, itemId, quantity, estimate, isReminder)
4303 rajveer 3843 
    self.recv_markOrdersAsReversalInitiated()
3844 
 
4369 rajveer 3845 
  def send_markOrdersAsReversalInitiated(self, vendorId, itemId, quantity, estimate, isReminder):
4303 rajveer 3846 
    self._oprot.writeMessageBegin('markOrdersAsReversalInitiated', TMessageType.CALL, self._seqid)
3847 
    args = markOrdersAsReversalInitiated_args()
3848 
    args.vendorId = vendorId
3849 
    args.itemId = itemId
3850 
    args.quantity = quantity
3851 
    args.estimate = estimate
4369 rajveer 3852 
    args.isReminder = isReminder
4303 rajveer 3853 
    args.write(self._oprot)
3854 
    self._oprot.writeMessageEnd()
3855 
    self._oprot.trans.flush()
3856 
 
3857 
  def recv_markOrdersAsReversalInitiated(self, ):
3858 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3859 
    if mtype == TMessageType.EXCEPTION:
3860 
      x = TApplicationException()
3861 
      x.read(self._iprot)
3862 
      self._iprot.readMessageEnd()
3863 
      raise x
3864 
    result = markOrdersAsReversalInitiated_result()
3865 
    result.read(self._iprot)
3866 
    self._iprot.readMessageEnd()
3867 
    if result.ex is not None:
3868 
      raise result.ex
3869 
    return
3870 
 
4369 rajveer 3871 
  def markOrdersAsNotAvailabke(self, vendorId, itemId, quantity, estimate, isReminder):
4303 rajveer 3872 
    """
3873 
    Parameters:
3874 
     - vendorId
3875 
     - itemId
3876 
     - quantity
3877 
     - estimate
4369 rajveer 3878 
     - isReminder
4303 rajveer 3879 
    """
4369 rajveer 3880 
    self.send_markOrdersAsNotAvailabke(vendorId, itemId, quantity, estimate, isReminder)
4303 rajveer 3881 
    self.recv_markOrdersAsNotAvailabke()
3882 
 
4369 rajveer 3883 
  def send_markOrdersAsNotAvailabke(self, vendorId, itemId, quantity, estimate, isReminder):
4303 rajveer 3884 
    self._oprot.writeMessageBegin('markOrdersAsNotAvailabke', TMessageType.CALL, self._seqid)
3885 
    args = markOrdersAsNotAvailabke_args()
3886 
    args.vendorId = vendorId
3887 
    args.itemId = itemId
3888 
    args.quantity = quantity
3889 
    args.estimate = estimate
4369 rajveer 3890 
    args.isReminder = isReminder
4303 rajveer 3891 
    args.write(self._oprot)
3892 
    self._oprot.writeMessageEnd()
3893 
    self._oprot.trans.flush()
3894 
 
3895 
  def recv_markOrdersAsNotAvailabke(self, ):
3896 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3897 
    if mtype == TMessageType.EXCEPTION:
3898 
      x = TApplicationException()
3899 
      x.read(self._iprot)
3900 
      self._iprot.readMessageEnd()
3901 
      raise x
3902 
    result = markOrdersAsNotAvailabke_result()
3903 
    result.read(self._iprot)
3904 
    self._iprot.readMessageEnd()
3905 
    if result.ex is not None:
3906 
      raise result.ex
3907 
    return
3908 
 
4369 rajveer 3909 
  def markOrdersAsTimeout(self, vendorId):
3910 
    """
3911 
    Parameters:
3912 
     - vendorId
3913 
    """
3914 
    self.send_markOrdersAsTimeout(vendorId)
3915 
    return self.recv_markOrdersAsTimeout()
4303 rajveer 3916 
 
4369 rajveer 3917 
  def send_markOrdersAsTimeout(self, vendorId):
3918 
    self._oprot.writeMessageBegin('markOrdersAsTimeout', TMessageType.CALL, self._seqid)
3919 
    args = markOrdersAsTimeout_args()
3920 
    args.vendorId = vendorId
3921 
    args.write(self._oprot)
3922 
    self._oprot.writeMessageEnd()
3923 
    self._oprot.trans.flush()
3924 
 
3925 
  def recv_markOrdersAsTimeout(self, ):
3926 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3927 
    if mtype == TMessageType.EXCEPTION:
3928 
      x = TApplicationException()
3929 
      x.read(self._iprot)
3930 
      self._iprot.readMessageEnd()
3931 
      raise x
3932 
    result = markOrdersAsTimeout_result()
3933 
    result.read(self._iprot)
3934 
    self._iprot.readMessageEnd()
3935 
    if result.success is not None:
3936 
      return result.success
3937 
    if result.ex is not None:
3938 
      raise result.ex
3939 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "markOrdersAsTimeout failed: unknown result");
3940 
 
4662 rajveer 3941 
  def markOrderAsLostInTransit(self, orderId):
3942 
    """
3943 
    Mark order as LOST_IN_TRANSIT
3944 
 
3945 
    Parameters:
3946 
     - orderId
3947 
    """
3948 
    self.send_markOrderAsLostInTransit(orderId)
3949 
    return self.recv_markOrderAsLostInTransit()
3950 
 
3951 
  def send_markOrderAsLostInTransit(self, orderId):
3952 
    self._oprot.writeMessageBegin('markOrderAsLostInTransit', TMessageType.CALL, self._seqid)
3953 
    args = markOrderAsLostInTransit_args()
3954 
    args.orderId = orderId
3955 
    args.write(self._oprot)
3956 
    self._oprot.writeMessageEnd()
3957 
    self._oprot.trans.flush()
3958 
 
3959 
  def recv_markOrderAsLostInTransit(self, ):
3960 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3961 
    if mtype == TMessageType.EXCEPTION:
3962 
      x = TApplicationException()
3963 
      x.read(self._iprot)
3964 
      self._iprot.readMessageEnd()
3965 
      raise x
3966 
    result = markOrderAsLostInTransit_result()
3967 
    result.read(self._iprot)
3968 
    self._iprot.readMessageEnd()
3969 
    if result.success is not None:
3970 
      return result.success
3971 
    if result.ex is not None:
3972 
      raise result.ex
3973 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "markOrderAsLostInTransit failed: unknown result");
3974 
 
4386 anupam.sin 3975 
  def getOrderForAwb(self, awb):
3976 
    """
3977 
    Returns the order corresponding to an AWB number
4369 rajveer 3978 
 
4386 anupam.sin 3979 
    Parameters:
3980 
     - awb
3981 
    """
3982 
    self.send_getOrderForAwb(awb)
3983 
    return self.recv_getOrderForAwb()
3984 
 
3985 
  def send_getOrderForAwb(self, awb):
3986 
    self._oprot.writeMessageBegin('getOrderForAwb', TMessageType.CALL, self._seqid)
3987 
    args = getOrderForAwb_args()
3988 
    args.awb = awb
3989 
    args.write(self._oprot)
3990 
    self._oprot.writeMessageEnd()
3991 
    self._oprot.trans.flush()
3992 
 
3993 
  def recv_getOrderForAwb(self, ):
3994 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3995 
    if mtype == TMessageType.EXCEPTION:
3996 
      x = TApplicationException()
3997 
      x.read(self._iprot)
3998 
      self._iprot.readMessageEnd()
3999 
      raise x
4000 
    result = getOrderForAwb_result()
4001 
    result.read(self._iprot)
4002 
    self._iprot.readMessageEnd()
4003 
    if result.success is not None:
4004 
      return result.success
4005 
    if result.ex is not None:
4006 
      raise result.ex
4007 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getOrderForAwb failed: unknown result");
4008 
 
4506 phani.kuma 4009 
  def getOrdersForProviderForStatus(self, logistics_provider_id, order_status):
4010 
    """
4011 
    Returns the order corresponding to a logistics provider id for a given order status
4386 anupam.sin 4012 
 
4506 phani.kuma 4013 
    Parameters:
4014 
     - logistics_provider_id
4015 
     - order_status
4016 
    """
4017 
    self.send_getOrdersForProviderForStatus(logistics_provider_id, order_status)
4018 
    return self.recv_getOrdersForProviderForStatus()
4019 
 
4020 
  def send_getOrdersForProviderForStatus(self, logistics_provider_id, order_status):
4021 
    self._oprot.writeMessageBegin('getOrdersForProviderForStatus', TMessageType.CALL, self._seqid)
4022 
    args = getOrdersForProviderForStatus_args()
4023 
    args.logistics_provider_id = logistics_provider_id
4024 
    args.order_status = order_status
4025 
    args.write(self._oprot)
4026 
    self._oprot.writeMessageEnd()
4027 
    self._oprot.trans.flush()
4028 
 
4029 
  def recv_getOrdersForProviderForStatus(self, ):
4030 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4031 
    if mtype == TMessageType.EXCEPTION:
4032 
      x = TApplicationException()
4033 
      x.read(self._iprot)
4034 
      self._iprot.readMessageEnd()
4035 
      raise x
4036 
    result = getOrdersForProviderForStatus_result()
4037 
    result.read(self._iprot)
4038 
    self._iprot.readMessageEnd()
4039 
    if result.success is not None:
4040 
      return result.success
4041 
    if result.ex is not None:
4042 
      raise result.ex
4043 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getOrdersForProviderForStatus failed: unknown result");
4044 
 
4600 varun.gupt 4045 
  def getBilledOrdersForVendor(self, vendorId, billingDateFrom, billingDateTo):
4046 
    """
4047 
    Returns list of orders fullfiled from a certain vendor and billed in a given date range
4506 phani.kuma 4048 
 
4600 varun.gupt 4049 
    Parameters:
4050 
     - vendorId
4051 
     - billingDateFrom
4052 
     - billingDateTo
4053 
    """
4054 
    self.send_getBilledOrdersForVendor(vendorId, billingDateFrom, billingDateTo)
4055 
    return self.recv_getBilledOrdersForVendor()
4056 
 
4057 
  def send_getBilledOrdersForVendor(self, vendorId, billingDateFrom, billingDateTo):
4058 
    self._oprot.writeMessageBegin('getBilledOrdersForVendor', TMessageType.CALL, self._seqid)
4059 
    args = getBilledOrdersForVendor_args()
4060 
    args.vendorId = vendorId
4061 
    args.billingDateFrom = billingDateFrom
4062 
    args.billingDateTo = billingDateTo
4063 
    args.write(self._oprot)
4064 
    self._oprot.writeMessageEnd()
4065 
    self._oprot.trans.flush()
4066 
 
4067 
  def recv_getBilledOrdersForVendor(self, ):
4068 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4069 
    if mtype == TMessageType.EXCEPTION:
4070 
      x = TApplicationException()
4071 
      x.read(self._iprot)
4072 
      self._iprot.readMessageEnd()
4073 
      raise x
4074 
    result = getBilledOrdersForVendor_result()
4075 
    result.read(self._iprot)
4076 
    self._iprot.readMessageEnd()
4077 
    if result.success is not None:
4078 
      return result.success
4079 
    if result.ex is not None:
4080 
      raise result.ex
4081 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getBilledOrdersForVendor failed: unknown result");
4082 
 
4607 rajveer 4083 
  def getSlippedSippingDateOrders(self, ):
4084 
    self.send_getSlippedSippingDateOrders()
4085 
    return self.recv_getSlippedSippingDateOrders()
4086 
 
4087 
  def send_getSlippedSippingDateOrders(self, ):
4088 
    self._oprot.writeMessageBegin('getSlippedSippingDateOrders', TMessageType.CALL, self._seqid)
4089 
    args = getSlippedSippingDateOrders_args()
4090 
    args.write(self._oprot)
4091 
    self._oprot.writeMessageEnd()
4092 
    self._oprot.trans.flush()
4093 
 
4094 
  def recv_getSlippedSippingDateOrders(self, ):
4095 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4096 
    if mtype == TMessageType.EXCEPTION:
4097 
      x = TApplicationException()
4098 
      x.read(self._iprot)
4099 
      self._iprot.readMessageEnd()
4100 
      raise x
4101 
    result = getSlippedSippingDateOrders_result()
4102 
    result.read(self._iprot)
4103 
    self._iprot.readMessageEnd()
4104 
    if result.success is not None:
4105 
      return result.success
4106 
    if result.ex is not None:
4107 
      raise result.ex
4108 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getSlippedSippingDateOrders failed: unknown result");
4109 
 
4709 rajveer 4110 
  def getCancelledOrders(self, cancelDateFrom, cancelDateTo):
4111 
    """
4112 
    Parameters:
4113 
     - cancelDateFrom
4114 
     - cancelDateTo
4115 
    """
4116 
    self.send_getCancelledOrders(cancelDateFrom, cancelDateTo)
4117 
    return self.recv_getCancelledOrders()
4118 
 
4119 
  def send_getCancelledOrders(self, cancelDateFrom, cancelDateTo):
4120 
    self._oprot.writeMessageBegin('getCancelledOrders', TMessageType.CALL, self._seqid)
4121 
    args = getCancelledOrders_args()
4122 
    args.cancelDateFrom = cancelDateFrom
4123 
    args.cancelDateTo = cancelDateTo
4124 
    args.write(self._oprot)
4125 
    self._oprot.writeMessageEnd()
4126 
    self._oprot.trans.flush()
4127 
 
4128 
  def recv_getCancelledOrders(self, ):
4129 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4130 
    if mtype == TMessageType.EXCEPTION:
4131 
      x = TApplicationException()
4132 
      x.read(self._iprot)
4133 
      self._iprot.readMessageEnd()
4134 
      raise x
4135 
    result = getCancelledOrders_result()
4136 
    result.read(self._iprot)
4137 
    self._iprot.readMessageEnd()
4138 
    if result.success is not None:
4139 
      return result.success
4140 
    if result.ex is not None:
4141 
      raise result.ex
4142 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getCancelledOrders failed: unknown result");
4143 
 
4600 varun.gupt 4144 
  def saveBluedartSettlements(self, mapAWBAndAmount):
4145 
    """
4146 
    Parameters:
4147 
     - mapAWBAndAmount
4148 
    """
4149 
    self.send_saveBluedartSettlements(mapAWBAndAmount)
4150 
    self.recv_saveBluedartSettlements()
4151 
 
4152 
  def send_saveBluedartSettlements(self, mapAWBAndAmount):
4153 
    self._oprot.writeMessageBegin('saveBluedartSettlements', TMessageType.CALL, self._seqid)
4154 
    args = saveBluedartSettlements_args()
4155 
    args.mapAWBAndAmount = mapAWBAndAmount
4156 
    args.write(self._oprot)
4157 
    self._oprot.writeMessageEnd()
4158 
    self._oprot.trans.flush()
4159 
 
4160 
  def recv_saveBluedartSettlements(self, ):
4161 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4162 
    if mtype == TMessageType.EXCEPTION:
4163 
      x = TApplicationException()
4164 
      x.read(self._iprot)
4165 
      self._iprot.readMessageEnd()
4166 
      raise x
4167 
    result = saveBluedartSettlements_result()
4168 
    result.read(self._iprot)
4169 
    self._iprot.readMessageEnd()
4170 
    if result.ex is not None:
4171 
      raise result.ex
4172 
    return
4173 
 
4174 
  def savePaymentSettlements(self, settlementDate, paymentGatewayId, paymentId, serviceTax, otherCharges, netCollection):
4175 
    """
4176 
    Parameters:
4177 
     - settlementDate
4178 
     - paymentGatewayId
4179 
     - paymentId
4180 
     - serviceTax
4181 
     - otherCharges
4182 
     - netCollection
4183 
    """
4184 
    self.send_savePaymentSettlements(settlementDate, paymentGatewayId, paymentId, serviceTax, otherCharges, netCollection)
4185 
    self.recv_savePaymentSettlements()
4186 
 
4187 
  def send_savePaymentSettlements(self, settlementDate, paymentGatewayId, paymentId, serviceTax, otherCharges, netCollection):
4188 
    self._oprot.writeMessageBegin('savePaymentSettlements', TMessageType.CALL, self._seqid)
4189 
    args = savePaymentSettlements_args()
4190 
    args.settlementDate = settlementDate
4191 
    args.paymentGatewayId = paymentGatewayId
4192 
    args.paymentId = paymentId
4193 
    args.serviceTax = serviceTax
4194 
    args.otherCharges = otherCharges
4195 
    args.netCollection = netCollection
4196 
    args.write(self._oprot)
4197 
    self._oprot.writeMessageEnd()
4198 
    self._oprot.trans.flush()
4199 
 
4200 
  def recv_savePaymentSettlements(self, ):
4201 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4202 
    if mtype == TMessageType.EXCEPTION:
4203 
      x = TApplicationException()
4204 
      x.read(self._iprot)
4205 
      self._iprot.readMessageEnd()
4206 
      raise x
4207 
    result = savePaymentSettlements_result()
4208 
    result.read(self._iprot)
4209 
    self._iprot.readMessageEnd()
4210 
    if result.ex is not None:
4211 
      raise result.ex
4212 
    return
4213 
 
4875 varun.gupt 4214 
  def saveCODPaymentSettlement(self, orderId, settlementDate, collection):
4215 
    """
4216 
    Parameters:
4217 
     - orderId
4218 
     - settlementDate
4219 
     - collection
4220 
    """
4221 
    self.send_saveCODPaymentSettlement(orderId, settlementDate, collection)
4222 
    self.recv_saveCODPaymentSettlement()
4223 
 
4224 
  def send_saveCODPaymentSettlement(self, orderId, settlementDate, collection):
4225 
    self._oprot.writeMessageBegin('saveCODPaymentSettlement', TMessageType.CALL, self._seqid)
4226 
    args = saveCODPaymentSettlement_args()
4227 
    args.orderId = orderId
4228 
    args.settlementDate = settlementDate
4229 
    args.collection = collection
4230 
    args.write(self._oprot)
4231 
    self._oprot.writeMessageEnd()
4232 
    self._oprot.trans.flush()
4233 
 
4234 
  def recv_saveCODPaymentSettlement(self, ):
4235 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4236 
    if mtype == TMessageType.EXCEPTION:
4237 
      x = TApplicationException()
4238 
      x.read(self._iprot)
4239 
      self._iprot.readMessageEnd()
4240 
      raise x
4241 
    result = saveCODPaymentSettlement_result()
4242 
    result.read(self._iprot)
4243 
    self._iprot.readMessageEnd()
4244 
    if result.ex is not None:
4245 
      raise result.ex
4246 
    return
4247 
 
4600 varun.gupt 4248 
  def saveEBSSettlementSummary(self, settlementId, settlementDate, transactionDateFrom, transactionDateTo, amount):
4249 
    """
4250 
    Parameters:
4251 
     - settlementId
4252 
     - settlementDate
4253 
     - transactionDateFrom
4254 
     - transactionDateTo
4255 
     - amount
4256 
    """
4257 
    self.send_saveEBSSettlementSummary(settlementId, settlementDate, transactionDateFrom, transactionDateTo, amount)
4258 
    self.recv_saveEBSSettlementSummary()
4259 
 
4260 
  def send_saveEBSSettlementSummary(self, settlementId, settlementDate, transactionDateFrom, transactionDateTo, amount):
4261 
    self._oprot.writeMessageBegin('saveEBSSettlementSummary', TMessageType.CALL, self._seqid)
4262 
    args = saveEBSSettlementSummary_args()
4263 
    args.settlementId = settlementId
4264 
    args.settlementDate = settlementDate
4265 
    args.transactionDateFrom = transactionDateFrom
4266 
    args.transactionDateTo = transactionDateTo
4267 
    args.amount = amount
4268 
    args.write(self._oprot)
4269 
    self._oprot.writeMessageEnd()
4270 
    self._oprot.trans.flush()
4271 
 
4272 
  def recv_saveEBSSettlementSummary(self, ):
4273 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4274 
    if mtype == TMessageType.EXCEPTION:
4275 
      x = TApplicationException()
4276 
      x.read(self._iprot)
4277 
      self._iprot.readMessageEnd()
4278 
      raise x
4279 
    result = saveEBSSettlementSummary_result()
4280 
    result.read(self._iprot)
4281 
    self._iprot.readMessageEnd()
4282 
    if result.ex is not None:
4283 
      raise result.ex
4284 
    return
4285 
 
4286 
  def getSettlementForPaymentId(self, paymentId):
4287 
    """
4288 
    Parameters:
4289 
     - paymentId
4290 
    """
4291 
    self.send_getSettlementForPaymentId(paymentId)
4292 
    return self.recv_getSettlementForPaymentId()
4293 
 
4294 
  def send_getSettlementForPaymentId(self, paymentId):
4295 
    self._oprot.writeMessageBegin('getSettlementForPaymentId', TMessageType.CALL, self._seqid)
4296 
    args = getSettlementForPaymentId_args()
4297 
    args.paymentId = paymentId
4298 
    args.write(self._oprot)
4299 
    self._oprot.writeMessageEnd()
4300 
    self._oprot.trans.flush()
4301 
 
4302 
  def recv_getSettlementForPaymentId(self, ):
4303 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4304 
    if mtype == TMessageType.EXCEPTION:
4305 
      x = TApplicationException()
4306 
      x.read(self._iprot)
4307 
      self._iprot.readMessageEnd()
4308 
      raise x
4309 
    result = getSettlementForPaymentId_result()
4310 
    result.read(self._iprot)
4311 
    self._iprot.readMessageEnd()
4312 
    if result.success is not None:
4313 
      return result.success
4314 
    if result.ex is not None:
4315 
      raise result.ex
4316 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getSettlementForPaymentId failed: unknown result");
4317 
 
4318 
  def getEBSSettlementSummaries(self, ):
4319 
    self.send_getEBSSettlementSummaries()
4320 
    return self.recv_getEBSSettlementSummaries()
4321 
 
4322 
  def send_getEBSSettlementSummaries(self, ):
4323 
    self._oprot.writeMessageBegin('getEBSSettlementSummaries', TMessageType.CALL, self._seqid)
4324 
    args = getEBSSettlementSummaries_args()
4325 
    args.write(self._oprot)
4326 
    self._oprot.writeMessageEnd()
4327 
    self._oprot.trans.flush()
4328 
 
4329 
  def recv_getEBSSettlementSummaries(self, ):
4330 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4331 
    if mtype == TMessageType.EXCEPTION:
4332 
      x = TApplicationException()
4333 
      x.read(self._iprot)
4334 
      self._iprot.readMessageEnd()
4335 
      raise x
4336 
    result = getEBSSettlementSummaries_result()
4337 
    result.read(self._iprot)
4338 
    self._iprot.readMessageEnd()
4339 
    if result.success is not None:
4340 
      return result.success
4341 
    if result.ex is not None:
4342 
      raise result.ex
4343 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getEBSSettlementSummaries failed: unknown result");
4344 
 
4345 
  def markEBSSettlementUploaded(self, settlementId):
4346 
    """
4347 
    Parameters:
4348 
     - settlementId
4349 
    """
4350 
    self.send_markEBSSettlementUploaded(settlementId)
4351 
    self.recv_markEBSSettlementUploaded()
4352 
 
4353 
  def send_markEBSSettlementUploaded(self, settlementId):
4354 
    self._oprot.writeMessageBegin('markEBSSettlementUploaded', TMessageType.CALL, self._seqid)
4355 
    args = markEBSSettlementUploaded_args()
4356 
    args.settlementId = settlementId
4357 
    args.write(self._oprot)
4358 
    self._oprot.writeMessageEnd()
4359 
    self._oprot.trans.flush()
4360 
 
4361 
  def recv_markEBSSettlementUploaded(self, ):
4362 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4363 
    if mtype == TMessageType.EXCEPTION:
4364 
      x = TApplicationException()
4365 
      x.read(self._iprot)
4366 
      self._iprot.readMessageEnd()
4367 
      raise x
4368 
    result = markEBSSettlementUploaded_result()
4369 
    result.read(self._iprot)
4370 
    self._iprot.readMessageEnd()
4371 
    if result.ex is not None:
4372 
      raise result.ex
4373 
    return
4374 
 
4375 
  def getEBSSettlementDate(self, settlementId):
4376 
    """
4377 
    Parameters:
4378 
     - settlementId
4379 
    """
4380 
    self.send_getEBSSettlementDate(settlementId)
4381 
    return self.recv_getEBSSettlementDate()
4382 
 
4383 
  def send_getEBSSettlementDate(self, settlementId):
4384 
    self._oprot.writeMessageBegin('getEBSSettlementDate', TMessageType.CALL, self._seqid)
4385 
    args = getEBSSettlementDate_args()
4386 
    args.settlementId = settlementId
4387 
    args.write(self._oprot)
4388 
    self._oprot.writeMessageEnd()
4389 
    self._oprot.trans.flush()
4390 
 
4391 
  def recv_getEBSSettlementDate(self, ):
4392 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4393 
    if mtype == TMessageType.EXCEPTION:
4394 
      x = TApplicationException()
4395 
      x.read(self._iprot)
4396 
      self._iprot.readMessageEnd()
4397 
      raise x
4398 
    result = getEBSSettlementDate_result()
4399 
    result.read(self._iprot)
4400 
    self._iprot.readMessageEnd()
4401 
    if result.success is not None:
4402 
      return result.success
4403 
    if result.ex is not None:
4404 
      raise result.ex
4405 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getEBSSettlementDate failed: unknown result");
4406 
 
4715 varun.gupt 4407 
  def getSettlementsByDate(self, settlementDateFrom, settlementDateTo, isRefund):
4408 
    """
4409 
    Parameters:
4410 
     - settlementDateFrom
4411 
     - settlementDateTo
4412 
     - isRefund
4413 
    """
4414 
    self.send_getSettlementsByDate(settlementDateFrom, settlementDateTo, isRefund)
4415 
    return self.recv_getSettlementsByDate()
4600 varun.gupt 4416 
 
4715 varun.gupt 4417 
  def send_getSettlementsByDate(self, settlementDateFrom, settlementDateTo, isRefund):
4418 
    self._oprot.writeMessageBegin('getSettlementsByDate', TMessageType.CALL, self._seqid)
4419 
    args = getSettlementsByDate_args()
4420 
    args.settlementDateFrom = settlementDateFrom
4421 
    args.settlementDateTo = settlementDateTo
4422 
    args.isRefund = isRefund
4423 
    args.write(self._oprot)
4424 
    self._oprot.writeMessageEnd()
4425 
    self._oprot.trans.flush()
4426 
 
4427 
  def recv_getSettlementsByDate(self, ):
4428 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4429 
    if mtype == TMessageType.EXCEPTION:
4430 
      x = TApplicationException()
4431 
      x.read(self._iprot)
4432 
      self._iprot.readMessageEnd()
4433 
      raise x
4434 
    result = getSettlementsByDate_result()
4435 
    result.read(self._iprot)
4436 
    self._iprot.readMessageEnd()
4437 
    if result.success is not None:
4438 
      return result.success
4439 
    if result.ex is not None:
4440 
      raise result.ex
4441 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getSettlementsByDate failed: unknown result");
4442 
 
4443 
  def getReshippedOrderIds(self, orderIds):
4444 
    """
4445 
    Returns list of Order Ids, which belong to reshiped orders, shortlisted from a given list of Order Ids
4446 
 
4447 
    Parameters:
4448 
     - orderIds
4449 
    """
4450 
    self.send_getReshippedOrderIds(orderIds)
4451 
    return self.recv_getReshippedOrderIds()
4452 
 
4453 
  def send_getReshippedOrderIds(self, orderIds):
4454 
    self._oprot.writeMessageBegin('getReshippedOrderIds', TMessageType.CALL, self._seqid)
4455 
    args = getReshippedOrderIds_args()
4456 
    args.orderIds = orderIds
4457 
    args.write(self._oprot)
4458 
    self._oprot.writeMessageEnd()
4459 
    self._oprot.trans.flush()
4460 
 
4461 
  def recv_getReshippedOrderIds(self, ):
4462 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4463 
    if mtype == TMessageType.EXCEPTION:
4464 
      x = TApplicationException()
4465 
      x.read(self._iprot)
4466 
      self._iprot.readMessageEnd()
4467 
      raise x
4468 
    result = getReshippedOrderIds_result()
4469 
    result.read(self._iprot)
4470 
    self._iprot.readMessageEnd()
4471 
    if result.success is not None:
4472 
      return result.success
4473 
    if result.ex is not None:
4474 
      raise result.ex
4475 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getReshippedOrderIds failed: unknown result");
4476 
 
4757 mandeep.dh 4477 
  def updateOrdersAsPORaised(self, itemIdQuantityMap, purchaseOrderId, warehouseId):
4478 
    """
4479 
    Updates orders as PO raised. Also updates purchase order id in orders. Pass a map of items mapped to
4480 
    the quantities for which the PO is raised.
4715 varun.gupt 4481 
 
4757 mandeep.dh 4482 
    Parameters:
4483 
     - itemIdQuantityMap
4484 
     - purchaseOrderId
4485 
     - warehouseId
4486 
    """
4487 
    self.send_updateOrdersAsPORaised(itemIdQuantityMap, purchaseOrderId, warehouseId)
4488 
    self.recv_updateOrdersAsPORaised()
4489 
 
4490 
  def send_updateOrdersAsPORaised(self, itemIdQuantityMap, purchaseOrderId, warehouseId):
4491 
    self._oprot.writeMessageBegin('updateOrdersAsPORaised', TMessageType.CALL, self._seqid)
4492 
    args = updateOrdersAsPORaised_args()
4493 
    args.itemIdQuantityMap = itemIdQuantityMap
4494 
    args.purchaseOrderId = purchaseOrderId
4495 
    args.warehouseId = warehouseId
4496 
    args.write(self._oprot)
4497 
    self._oprot.writeMessageEnd()
4498 
    self._oprot.trans.flush()
4499 
 
4500 
  def recv_updateOrdersAsPORaised(self, ):
4501 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4502 
    if mtype == TMessageType.EXCEPTION:
4503 
      x = TApplicationException()
4504 
      x.read(self._iprot)
4505 
      self._iprot.readMessageEnd()
4506 
      raise x
4507 
    result = updateOrdersAsPORaised_result()
4508 
    result.read(self._iprot)
4509 
    self._iprot.readMessageEnd()
4510 
    if result.ex is not None:
4511 
      raise result.ex
4512 
    return
4513 
 
4875 varun.gupt 4514 
  def getOrdersWhereVendorNotPaid(self, vendorId):
4515 
    """
4516 
    Parameters:
4517 
     - vendorId
4518 
    """
4519 
    self.send_getOrdersWhereVendorNotPaid(vendorId)
4520 
    return self.recv_getOrdersWhereVendorNotPaid()
4757 mandeep.dh 4521 
 
4875 varun.gupt 4522 
  def send_getOrdersWhereVendorNotPaid(self, vendorId):
4523 
    self._oprot.writeMessageBegin('getOrdersWhereVendorNotPaid', TMessageType.CALL, self._seqid)
4524 
    args = getOrdersWhereVendorNotPaid_args()
4525 
    args.vendorId = vendorId
4526 
    args.write(self._oprot)
4527 
    self._oprot.writeMessageEnd()
4528 
    self._oprot.trans.flush()
4529 
 
4530 
  def recv_getOrdersWhereVendorNotPaid(self, ):
4531 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4532 
    if mtype == TMessageType.EXCEPTION:
4533 
      x = TApplicationException()
4534 
      x.read(self._iprot)
4535 
      self._iprot.readMessageEnd()
4536 
      raise x
4537 
    result = getOrdersWhereVendorNotPaid_result()
4538 
    result.read(self._iprot)
4539 
    self._iprot.readMessageEnd()
4540 
    if result.success is not None:
4541 
      return result.success
4542 
    if result.ex is not None:
4543 
      raise result.ex
4544 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getOrdersWhereVendorNotPaid failed: unknown result");
4545 
 
4546 
 
3376 rajveer 4547 
class Processor(shop2020.thriftpy.generic.GenericService.Processor, Iface, TProcessor):
94 ashish 4548 
  def __init__(self, handler):
3376 rajveer 4549 
    shop2020.thriftpy.generic.GenericService.Processor.__init__(self, handler)
94 ashish 4550 
    self._processMap["createTransaction"] = Processor.process_createTransaction
4551 
    self._processMap["getTransaction"] = Processor.process_getTransaction
4552 
    self._processMap["getTransactionsForCustomer"] = Processor.process_getTransactionsForCustomer
132 ashish 4553 
    self._processMap["getTransactionsForShoppingCartId"] = Processor.process_getTransactionsForShoppingCartId
94 ashish 4554 
    self._processMap["getTransactionStatus"] = Processor.process_getTransactionStatus
4555 
    self._processMap["changeTransactionStatus"] = Processor.process_changeTransactionStatus
1398 varun.gupt 4556 
    self._processMap["enqueueTransactionInfoEmail"] = Processor.process_enqueueTransactionInfoEmail
483 rajveer 4557 
    self._processMap["getAllOrders"] = Processor.process_getAllOrders
4133 chandransh 4558 
    self._processMap["getOrdersInBatch"] = Processor.process_getOrdersInBatch
4559 
    self._processMap["getOrderCount"] = Processor.process_getOrderCount
999 varun.gupt 4560 
    self._processMap["getOrdersByBillingDate"] = Processor.process_getOrdersByBillingDate
3427 chandransh 4561 
    self._processMap["getOrdersByShippingDate"] = Processor.process_getOrdersByShippingDate
1382 varun.gupt 4562 
    self._processMap["getReturnableOrdersForCustomer"] = Processor.process_getReturnableOrdersForCustomer
4563 
    self._processMap["getCancellableOrdersForCustomer"] = Processor.process_getCancellableOrdersForCustomer
483 rajveer 4564 
    self._processMap["changeOrderStatus"] = Processor.process_changeOrderStatus
4565 
    self._processMap["getOrdersForTransaction"] = Processor.process_getOrdersForTransaction
4566 
    self._processMap["getOrdersForCustomer"] = Processor.process_getOrdersForCustomer
4567 
    self._processMap["createOrder"] = Processor.process_createOrder
4568 
    self._processMap["getOrder"] = Processor.process_getOrder
4569 
    self._processMap["getLineItemsForOrder"] = Processor.process_getLineItemsForOrder
1528 ankur.sing 4570 
    self._processMap["getOrderForCustomer"] = Processor.process_getOrderForCustomer
3064 chandransh 4571 
    self._processMap["getAlerts"] = Processor.process_getAlerts
4394 rajveer 4572 
    self._processMap["addAlert"] = Processor.process_addAlert
4444 rajveer 4573 
    self._processMap["markAlertsAsSeen"] = Processor.process_markAlertsAsSeen
3064 chandransh 4574 
    self._processMap["getValidOrderCount"] = Processor.process_getValidOrderCount
4575 
    self._processMap["getNoOfCustomersWithSuccessfulTransaction"] = Processor.process_getNoOfCustomersWithSuccessfulTransaction
4576 
    self._processMap["getValidOrdersAmountRange"] = Processor.process_getValidOrdersAmountRange
4577 
    self._processMap["getValidOrders"] = Processor.process_getValidOrders
1220 chandransh 4578 
    self._processMap["batchOrders"] = Processor.process_batchOrders
1208 chandransh 4579 
    self._processMap["markOrderAsOutOfStock"] = Processor.process_markOrderAsOutOfStock
3064 chandransh 4580 
    self._processMap["verifyOrder"] = Processor.process_verifyOrder
4581 
    self._processMap["acceptOrder"] = Processor.process_acceptOrder
4582 
    self._processMap["addBillingDetails"] = Processor.process_addBillingDetails
4579 rajveer 4583 
    self._processMap["addInvoiceNumber"] = Processor.process_addInvoiceNumber
759 chandransh 4584 
    self._processMap["markOrdersAsManifested"] = Processor.process_markOrdersAsManifested
4410 rajveer 4585 
    self._processMap["markOrdersAsShippedFromWarehouse"] = Processor.process_markOrdersAsShippedFromWarehouse
1113 chandransh 4586 
    self._processMap["markOrdersAsPickedUp"] = Processor.process_markOrdersAsPickedUp
1132 chandransh 4587 
    self._processMap["markOrdersAsDelivered"] = Processor.process_markOrdersAsDelivered
1135 chandransh 4588 
    self._processMap["markOrdersAsFailed"] = Processor.process_markOrdersAsFailed
1246 chandransh 4589 
    self._processMap["updateNonDeliveryReason"] = Processor.process_updateNonDeliveryReason
1408 ankur.sing 4590 
    self._processMap["getUndeliveredOrders"] = Processor.process_getUndeliveredOrders
4783 phani.kuma 4591 
    self._processMap["getUndeliveredOrdersExpectedDeliveryDateNotMet"] = Processor.process_getUndeliveredOrdersExpectedDeliveryDateNotMet
2536 chandransh 4592 
    self._processMap["toggleDOAFlag"] = Processor.process_toggleDOAFlag
4712 rajveer 4593 
    self._processMap["markOrderAsDelivered"] = Processor.process_markOrderAsDelivered
4454 rajveer 4594 
    self._processMap["markOrderDoaRequestReceived"] = Processor.process_markOrderDoaRequestReceived
4595 
    self._processMap["markOrderDoaRequestAuthorized"] = Processor.process_markOrderDoaRequestAuthorized
4488 rajveer 4596 
    self._processMap["markOrderReturnRequestReceived"] = Processor.process_markOrderReturnRequestReceived
4597 
    self._processMap["markOrderReturnRequestAuthorized"] = Processor.process_markOrderReturnRequestAuthorized
2536 chandransh 4598 
    self._processMap["requestPickupNumber"] = Processor.process_requestPickupNumber
4599 
    self._processMap["authorizePickup"] = Processor.process_authorizePickup
2764 chandransh 4600 
    self._processMap["markDoasAsPickedUp"] = Processor.process_markDoasAsPickedUp
4741 phani.kuma 4601 
    self._processMap["markReturnOrdersAsPickedUp"] = Processor.process_markReturnOrdersAsPickedUp
2616 chandransh 4602 
    self._processMap["receiveReturn"] = Processor.process_receiveReturn
2591 chandransh 4603 
    self._processMap["validateDoa"] = Processor.process_validateDoa
4495 rajveer 4604 
    self._processMap["validateReturnProduct"] = Processor.process_validateReturnProduct
2616 chandransh 4605 
    self._processMap["reshipOrder"] = Processor.process_reshipOrder
4606 
    self._processMap["refundOrder"] = Processor.process_refundOrder
2690 chandransh 4607 
    self._processMap["getReturnOrders"] = Processor.process_getReturnOrders
2700 chandransh 4608 
    self._processMap["getReturnOrder"] = Processor.process_getReturnOrder
2690 chandransh 4609 
    self._processMap["processReturn"] = Processor.process_processReturn
3451 chandransh 4610 
    self._processMap["updateWeight"] = Processor.process_updateWeight
3469 chandransh 4611 
    self._processMap["changeItem"] = Processor.process_changeItem
4612 
    self._processMap["shiftToWarehouse"] = Processor.process_shiftToWarehouse
3553 chandransh 4613 
    self._processMap["addDelayReason"] = Processor.process_addDelayReason
3956 chandransh 4614 
    self._processMap["reconcileCodCollection"] = Processor.process_reconcileCodCollection
4008 mandeep.dh 4615 
    self._processMap["getTransactionsRequiringExtraProcessing"] = Processor.process_getTransactionsRequiringExtraProcessing
4616 
    self._processMap["markTransactionAsProcessed"] = Processor.process_markTransactionAsProcessed
4018 chandransh 4617 
    self._processMap["getItemWiseRiskyOrdersCount"] = Processor.process_getItemWiseRiskyOrdersCount
4295 varun.gupt 4618 
    self._processMap["getOrdersForItemIds"] = Processor.process_getOrdersForItemIds
4247 rajveer 4619 
    self._processMap["markOrderCancellationRequestReceived"] = Processor.process_markOrderCancellationRequestReceived
4620 
    self._processMap["markOrderCancellationRequestConfirmed"] = Processor.process_markOrderCancellationRequestConfirmed
4621 
    self._processMap["markOrderCancellationRequestDenied"] = Processor.process_markOrderCancellationRequestDenied
4258 rajveer 4622 
    self._processMap["markTransactionAsPaymentFlagRemoved"] = Processor.process_markTransactionAsPaymentFlagRemoved
4259 anupam.sin 4623 
    self._processMap["refundTransaction"] = Processor.process_refundTransaction
4324 mandeep.dh 4624 
    self._processMap["updateShipmentAddress"] = Processor.process_updateShipmentAddress
4285 rajveer 4625 
    self._processMap["acceptOrdersForItemId"] = Processor.process_acceptOrdersForItemId
4303 rajveer 4626 
    self._processMap["markOrdersAsPORaised"] = Processor.process_markOrdersAsPORaised
4627 
    self._processMap["markOrdersAsReversalInitiated"] = Processor.process_markOrdersAsReversalInitiated
4628 
    self._processMap["markOrdersAsNotAvailabke"] = Processor.process_markOrdersAsNotAvailabke
4369 rajveer 4629 
    self._processMap["markOrdersAsTimeout"] = Processor.process_markOrdersAsTimeout
4662 rajveer 4630 
    self._processMap["markOrderAsLostInTransit"] = Processor.process_markOrderAsLostInTransit
4386 anupam.sin 4631 
    self._processMap["getOrderForAwb"] = Processor.process_getOrderForAwb
4506 phani.kuma 4632 
    self._processMap["getOrdersForProviderForStatus"] = Processor.process_getOrdersForProviderForStatus
4600 varun.gupt 4633 
    self._processMap["getBilledOrdersForVendor"] = Processor.process_getBilledOrdersForVendor
4607 rajveer 4634 
    self._processMap["getSlippedSippingDateOrders"] = Processor.process_getSlippedSippingDateOrders
4709 rajveer 4635 
    self._processMap["getCancelledOrders"] = Processor.process_getCancelledOrders
4600 varun.gupt 4636 
    self._processMap["saveBluedartSettlements"] = Processor.process_saveBluedartSettlements
4637 
    self._processMap["savePaymentSettlements"] = Processor.process_savePaymentSettlements
4875 varun.gupt 4638 
    self._processMap["saveCODPaymentSettlement"] = Processor.process_saveCODPaymentSettlement
4600 varun.gupt 4639 
    self._processMap["saveEBSSettlementSummary"] = Processor.process_saveEBSSettlementSummary
4640 
    self._processMap["getSettlementForPaymentId"] = Processor.process_getSettlementForPaymentId
4641 
    self._processMap["getEBSSettlementSummaries"] = Processor.process_getEBSSettlementSummaries
4642 
    self._processMap["markEBSSettlementUploaded"] = Processor.process_markEBSSettlementUploaded
4643 
    self._processMap["getEBSSettlementDate"] = Processor.process_getEBSSettlementDate
4715 varun.gupt 4644 
    self._processMap["getSettlementsByDate"] = Processor.process_getSettlementsByDate
4645 
    self._processMap["getReshippedOrderIds"] = Processor.process_getReshippedOrderIds
4757 mandeep.dh 4646 
    self._processMap["updateOrdersAsPORaised"] = Processor.process_updateOrdersAsPORaised
4875 varun.gupt 4647 
    self._processMap["getOrdersWhereVendorNotPaid"] = Processor.process_getOrdersWhereVendorNotPaid
94 ashish 4648 
 
4649 
  def process(self, iprot, oprot):
4650 
    (name, type, seqid) = iprot.readMessageBegin()
4651 
    if name not in self._processMap:
4652 
      iprot.skip(TType.STRUCT)
4653 
      iprot.readMessageEnd()
4654 
      x = TApplicationException(TApplicationException.UNKNOWN_METHOD, 'Unknown function %s' % (name))
4655 
      oprot.writeMessageBegin(name, TMessageType.EXCEPTION, seqid)
4656 
      x.write(oprot)
4657 
      oprot.writeMessageEnd()
4658 
      oprot.trans.flush()
4659 
      return
4660 
    else:
4661 
      self._processMap[name](self, seqid, iprot, oprot)
4662 
    return True
4663 
 
4664 
  def process_createTransaction(self, seqid, iprot, oprot):
4665 
    args = createTransaction_args()
4666 
    args.read(iprot)
4667 
    iprot.readMessageEnd()
4668 
    result = createTransaction_result()
4669 
    try:
132 ashish 4670 
      result.success = self._handler.createTransaction(args.transaction)
94 ashish 4671 
    except TransactionServiceException, ex:
4672 
      result.ex = ex
4673 
    oprot.writeMessageBegin("createTransaction", TMessageType.REPLY, seqid)
4674 
    result.write(oprot)
4675 
    oprot.writeMessageEnd()
4676 
    oprot.trans.flush()
4677 
 
4678 
  def process_getTransaction(self, seqid, iprot, oprot):
4679 
    args = getTransaction_args()
4680 
    args.read(iprot)
4681 
    iprot.readMessageEnd()
4682 
    result = getTransaction_result()
4683 
    try:
4684 
      result.success = self._handler.getTransaction(args.id)
4685 
    except TransactionServiceException, ex:
4686 
      result.ex = ex
4687 
    oprot.writeMessageBegin("getTransaction", TMessageType.REPLY, seqid)
4688 
    result.write(oprot)
4689 
    oprot.writeMessageEnd()
4690 
    oprot.trans.flush()
4691 
 
4692 
  def process_getTransactionsForCustomer(self, seqid, iprot, oprot):
4693 
    args = getTransactionsForCustomer_args()
4694 
    args.read(iprot)
4695 
    iprot.readMessageEnd()
4696 
    result = getTransactionsForCustomer_result()
4697 
    try:
4698 
      result.success = self._handler.getTransactionsForCustomer(args.customerId, args.from_date, args.to_date, args.status)
4699 
    except TransactionServiceException, ex:
4700 
      result.ex = ex
4701 
    oprot.writeMessageBegin("getTransactionsForCustomer", TMessageType.REPLY, seqid)
4702 
    result.write(oprot)
4703 
    oprot.writeMessageEnd()
4704 
    oprot.trans.flush()
4705 
 
132 ashish 4706 
  def process_getTransactionsForShoppingCartId(self, seqid, iprot, oprot):
4707 
    args = getTransactionsForShoppingCartId_args()
4708 
    args.read(iprot)
4709 
    iprot.readMessageEnd()
4710 
    result = getTransactionsForShoppingCartId_result()
4711 
    try:
4712 
      result.success = self._handler.getTransactionsForShoppingCartId(args.shoppingCartId)
4713 
    except TransactionServiceException, ex:
4714 
      result.ex = ex
4715 
    oprot.writeMessageBegin("getTransactionsForShoppingCartId", TMessageType.REPLY, seqid)
4716 
    result.write(oprot)
4717 
    oprot.writeMessageEnd()
4718 
    oprot.trans.flush()
4719 
 
94 ashish 4720 
  def process_getTransactionStatus(self, seqid, iprot, oprot):
4721 
    args = getTransactionStatus_args()
4722 
    args.read(iprot)
4723 
    iprot.readMessageEnd()
4724 
    result = getTransactionStatus_result()
4725 
    try:
4726 
      result.success = self._handler.getTransactionStatus(args.transactionId)
4727 
    except TransactionServiceException, ex:
4728 
      result.ex = ex
4729 
    oprot.writeMessageBegin("getTransactionStatus", TMessageType.REPLY, seqid)
4730 
    result.write(oprot)
4731 
    oprot.writeMessageEnd()
4732 
    oprot.trans.flush()
4733 
 
4734 
  def process_changeTransactionStatus(self, seqid, iprot, oprot):
4735 
    args = changeTransactionStatus_args()
4736 
    args.read(iprot)
4737 
    iprot.readMessageEnd()
4738 
    result = changeTransactionStatus_result()
4739 
    try:
4740 
      result.success = self._handler.changeTransactionStatus(args.transactionId, args.status, args.description)
4741 
    except TransactionServiceException, ex:
4742 
      result.ex = ex
4743 
    oprot.writeMessageBegin("changeTransactionStatus", TMessageType.REPLY, seqid)
4744 
    result.write(oprot)
4745 
    oprot.writeMessageEnd()
4746 
    oprot.trans.flush()
4747 
 
1398 varun.gupt 4748 
  def process_enqueueTransactionInfoEmail(self, seqid, iprot, oprot):
4749 
    args = enqueueTransactionInfoEmail_args()
1382 varun.gupt 4750 
    args.read(iprot)
4751 
    iprot.readMessageEnd()
1398 varun.gupt 4752 
    result = enqueueTransactionInfoEmail_result()
1382 varun.gupt 4753 
    try:
1398 varun.gupt 4754 
      result.success = self._handler.enqueueTransactionInfoEmail(args.transactionId)
1382 varun.gupt 4755 
    except TransactionServiceException, ex:
4756 
      result.ex = ex
1398 varun.gupt 4757 
    oprot.writeMessageBegin("enqueueTransactionInfoEmail", TMessageType.REPLY, seqid)
1382 varun.gupt 4758 
    result.write(oprot)
4759 
    oprot.writeMessageEnd()
4760 
    oprot.trans.flush()
4761 
 
483 rajveer 4762 
  def process_getAllOrders(self, seqid, iprot, oprot):
4763 
    args = getAllOrders_args()
94 ashish 4764 
    args.read(iprot)
4765 
    iprot.readMessageEnd()
483 rajveer 4766 
    result = getAllOrders_result()
94 ashish 4767 
    try:
4801 anupam.sin 4768 
      result.success = self._handler.getAllOrders(args.statuses, args.from_date, args.to_date, args.warehouse_id)
94 ashish 4769 
    except TransactionServiceException, ex:
4770 
      result.ex = ex
483 rajveer 4771 
    oprot.writeMessageBegin("getAllOrders", TMessageType.REPLY, seqid)
94 ashish 4772 
    result.write(oprot)
4773 
    oprot.writeMessageEnd()
4774 
    oprot.trans.flush()
4775 
 
4133 chandransh 4776 
  def process_getOrdersInBatch(self, seqid, iprot, oprot):
4777 
    args = getOrdersInBatch_args()
4778 
    args.read(iprot)
4779 
    iprot.readMessageEnd()
4780 
    result = getOrdersInBatch_result()
4781 
    try:
4782 
      result.success = self._handler.getOrdersInBatch(args.statuses, args.offset, args.limit, args.warehouse_id)
4783 
    except TransactionServiceException, ex:
4784 
      result.ex = ex
4785 
    oprot.writeMessageBegin("getOrdersInBatch", TMessageType.REPLY, seqid)
4786 
    result.write(oprot)
4787 
    oprot.writeMessageEnd()
4788 
    oprot.trans.flush()
4789 
 
4790 
  def process_getOrderCount(self, seqid, iprot, oprot):
4791 
    args = getOrderCount_args()
4792 
    args.read(iprot)
4793 
    iprot.readMessageEnd()
4794 
    result = getOrderCount_result()
4795 
    try:
4796 
      result.success = self._handler.getOrderCount(args.statuses, args.warehouseId)
4797 
    except TransactionServiceException, ex:
4798 
      result.ex = ex
4799 
    oprot.writeMessageBegin("getOrderCount", TMessageType.REPLY, seqid)
4800 
    result.write(oprot)
4801 
    oprot.writeMessageEnd()
4802 
    oprot.trans.flush()
4803 
 
999 varun.gupt 4804 
  def process_getOrdersByBillingDate(self, seqid, iprot, oprot):
4805 
    args = getOrdersByBillingDate_args()
4806 
    args.read(iprot)
4807 
    iprot.readMessageEnd()
4808 
    result = getOrdersByBillingDate_result()
4809 
    try:
4810 
      result.success = self._handler.getOrdersByBillingDate(args.status, args.start_billing_date, args.end_billing_date, args.warehouse_id)
4811 
    except TransactionServiceException, ex:
4812 
      result.ex = ex
4813 
    oprot.writeMessageBegin("getOrdersByBillingDate", TMessageType.REPLY, seqid)
4814 
    result.write(oprot)
4815 
    oprot.writeMessageEnd()
4816 
    oprot.trans.flush()
4817 
 
3427 chandransh 4818 
  def process_getOrdersByShippingDate(self, seqid, iprot, oprot):
4819 
    args = getOrdersByShippingDate_args()
4820 
    args.read(iprot)
4821 
    iprot.readMessageEnd()
4822 
    result = getOrdersByShippingDate_result()
4823 
    try:
3451 chandransh 4824 
      result.success = self._handler.getOrdersByShippingDate(args.fromShippingDate, args.toShippingDate, args.providerId, args.warehouseId, args.cod)
3427 chandransh 4825 
    except TransactionServiceException, ex:
4826 
      result.ex = ex
4827 
    oprot.writeMessageBegin("getOrdersByShippingDate", TMessageType.REPLY, seqid)
4828 
    result.write(oprot)
4829 
    oprot.writeMessageEnd()
4830 
    oprot.trans.flush()
4831 
 
1382 varun.gupt 4832 
  def process_getReturnableOrdersForCustomer(self, seqid, iprot, oprot):
4833 
    args = getReturnableOrdersForCustomer_args()
4834 
    args.read(iprot)
4835 
    iprot.readMessageEnd()
4836 
    result = getReturnableOrdersForCustomer_result()
4837 
    try:
4838 
      result.success = self._handler.getReturnableOrdersForCustomer(args.customer_id, args.limit)
4839 
    except TransactionServiceException, ex:
4840 
      result.ex = ex
4841 
    oprot.writeMessageBegin("getReturnableOrdersForCustomer", TMessageType.REPLY, seqid)
4842 
    result.write(oprot)
4843 
    oprot.writeMessageEnd()
4844 
    oprot.trans.flush()
4845 
 
4846 
  def process_getCancellableOrdersForCustomer(self, seqid, iprot, oprot):
4847 
    args = getCancellableOrdersForCustomer_args()
4848 
    args.read(iprot)
4849 
    iprot.readMessageEnd()
4850 
    result = getCancellableOrdersForCustomer_result()
4851 
    try:
4852 
      result.success = self._handler.getCancellableOrdersForCustomer(args.customer_id, args.limit)
4853 
    except TransactionServiceException, ex:
4854 
      result.ex = ex
4855 
    oprot.writeMessageBegin("getCancellableOrdersForCustomer", TMessageType.REPLY, seqid)
4856 
    result.write(oprot)
4857 
    oprot.writeMessageEnd()
4858 
    oprot.trans.flush()
4859 
 
483 rajveer 4860 
  def process_changeOrderStatus(self, seqid, iprot, oprot):
4861 
    args = changeOrderStatus_args()
94 ashish 4862 
    args.read(iprot)
4863 
    iprot.readMessageEnd()
483 rajveer 4864 
    result = changeOrderStatus_result()
94 ashish 4865 
    try:
483 rajveer 4866 
      result.success = self._handler.changeOrderStatus(args.orderId, args.status, args.description)
94 ashish 4867 
    except TransactionServiceException, ex:
4868 
      result.ex = ex
483 rajveer 4869 
    oprot.writeMessageBegin("changeOrderStatus", TMessageType.REPLY, seqid)
94 ashish 4870 
    result.write(oprot)
4871 
    oprot.writeMessageEnd()
4872 
    oprot.trans.flush()
4873 
 
483 rajveer 4874 
  def process_getOrdersForTransaction(self, seqid, iprot, oprot):
4875 
    args = getOrdersForTransaction_args()
94 ashish 4876 
    args.read(iprot)
4877 
    iprot.readMessageEnd()
483 rajveer 4878 
    result = getOrdersForTransaction_result()
94 ashish 4879 
    try:
1528 ankur.sing 4880 
      result.success = self._handler.getOrdersForTransaction(args.transactionId, args.customerId)
94 ashish 4881 
    except TransactionServiceException, ex:
4882 
      result.ex = ex
483 rajveer 4883 
    oprot.writeMessageBegin("getOrdersForTransaction", TMessageType.REPLY, seqid)
94 ashish 4884 
    result.write(oprot)
4885 
    oprot.writeMessageEnd()
4886 
    oprot.trans.flush()
4887 
 
483 rajveer 4888 
  def process_getOrdersForCustomer(self, seqid, iprot, oprot):
4889 
    args = getOrdersForCustomer_args()
94 ashish 4890 
    args.read(iprot)
4891 
    iprot.readMessageEnd()
483 rajveer 4892 
    result = getOrdersForCustomer_result()
94 ashish 4893 
    try:
3014 chandransh 4894 
      result.success = self._handler.getOrdersForCustomer(args.customerId, args.from_date, args.to_date, args.statuses)
94 ashish 4895 
    except TransactionServiceException, ex:
4896 
      result.ex = ex
483 rajveer 4897 
    oprot.writeMessageBegin("getOrdersForCustomer", TMessageType.REPLY, seqid)
94 ashish 4898 
    result.write(oprot)
4899 
    oprot.writeMessageEnd()
4900 
    oprot.trans.flush()
4901 
 
483 rajveer 4902 
  def process_createOrder(self, seqid, iprot, oprot):
4903 
    args = createOrder_args()
94 ashish 4904 
    args.read(iprot)
4905 
    iprot.readMessageEnd()
483 rajveer 4906 
    result = createOrder_result()
94 ashish 4907 
    try:
483 rajveer 4908 
      result.success = self._handler.createOrder(args.order)
94 ashish 4909 
    except TransactionServiceException, ex:
4910 
      result.ex = ex
483 rajveer 4911 
    oprot.writeMessageBegin("createOrder", TMessageType.REPLY, seqid)
94 ashish 4912 
    result.write(oprot)
4913 
    oprot.writeMessageEnd()
4914 
    oprot.trans.flush()
4915 
 
483 rajveer 4916 
  def process_getOrder(self, seqid, iprot, oprot):
4917 
    args = getOrder_args()
94 ashish 4918 
    args.read(iprot)
4919 
    iprot.readMessageEnd()
483 rajveer 4920 
    result = getOrder_result()
94 ashish 4921 
    try:
483 rajveer 4922 
      result.success = self._handler.getOrder(args.id)
94 ashish 4923 
    except TransactionServiceException, ex:
4924 
      result.ex = ex
483 rajveer 4925 
    oprot.writeMessageBegin("getOrder", TMessageType.REPLY, seqid)
94 ashish 4926 
    result.write(oprot)
4927 
    oprot.writeMessageEnd()
4928 
    oprot.trans.flush()
4929 
 
483 rajveer 4930 
  def process_getLineItemsForOrder(self, seqid, iprot, oprot):
4931 
    args = getLineItemsForOrder_args()
94 ashish 4932 
    args.read(iprot)
4933 
    iprot.readMessageEnd()
483 rajveer 4934 
    result = getLineItemsForOrder_result()
94 ashish 4935 
    try:
483 rajveer 4936 
      result.success = self._handler.getLineItemsForOrder(args.orderId)
94 ashish 4937 
    except TransactionServiceException, ex:
4938 
      result.ex = ex
483 rajveer 4939 
    oprot.writeMessageBegin("getLineItemsForOrder", TMessageType.REPLY, seqid)
94 ashish 4940 
    result.write(oprot)
4941 
    oprot.writeMessageEnd()
4942 
    oprot.trans.flush()
4943 
 
1528 ankur.sing 4944 
  def process_getOrderForCustomer(self, seqid, iprot, oprot):
4945 
    args = getOrderForCustomer_args()
4946 
    args.read(iprot)
4947 
    iprot.readMessageEnd()
4948 
    result = getOrderForCustomer_result()
4949 
    try:
4950 
      result.success = self._handler.getOrderForCustomer(args.orderId, args.customerId)
4951 
    except TransactionServiceException, ex:
4952 
      result.ex = ex
4953 
    oprot.writeMessageBegin("getOrderForCustomer", TMessageType.REPLY, seqid)
4954 
    result.write(oprot)
4955 
    oprot.writeMessageEnd()
4956 
    oprot.trans.flush()
4957 
 
3064 chandransh 4958 
  def process_getAlerts(self, seqid, iprot, oprot):
4959 
    args = getAlerts_args()
4960 
    args.read(iprot)
4961 
    iprot.readMessageEnd()
4962 
    result = getAlerts_result()
4444 rajveer 4963 
    result.success = self._handler.getAlerts(args.type, args.warehouseId, args.status, args.timestamp)
3064 chandransh 4964 
    oprot.writeMessageBegin("getAlerts", TMessageType.REPLY, seqid)
4965 
    result.write(oprot)
4966 
    oprot.writeMessageEnd()
4967 
    oprot.trans.flush()
4968 
 
4394 rajveer 4969 
  def process_addAlert(self, seqid, iprot, oprot):
4970 
    args = addAlert_args()
3064 chandransh 4971 
    args.read(iprot)
4972 
    iprot.readMessageEnd()
4394 rajveer 4973 
    result = addAlert_result()
4444 rajveer 4974 
    self._handler.addAlert(args.type, args.warehouseId, args.description)
4394 rajveer 4975 
    oprot.writeMessageBegin("addAlert", TMessageType.REPLY, seqid)
3064 chandransh 4976 
    result.write(oprot)
4977 
    oprot.writeMessageEnd()
4978 
    oprot.trans.flush()
4979 
 
4444 rajveer 4980 
  def process_markAlertsAsSeen(self, seqid, iprot, oprot):
4981 
    args = markAlertsAsSeen_args()
4982 
    args.read(iprot)
4983 
    iprot.readMessageEnd()
4984 
    result = markAlertsAsSeen_result()
4985 
    self._handler.markAlertsAsSeen(args.warehouseId)
4986 
    oprot.writeMessageBegin("markAlertsAsSeen", TMessageType.REPLY, seqid)
4987 
    result.write(oprot)
4988 
    oprot.writeMessageEnd()
4989 
    oprot.trans.flush()
4990 
 
3064 chandransh 4991 
  def process_getValidOrderCount(self, seqid, iprot, oprot):
4992 
    args = getValidOrderCount_args()
4993 
    args.read(iprot)
4994 
    iprot.readMessageEnd()
4995 
    result = getValidOrderCount_result()
4996 
    result.success = self._handler.getValidOrderCount()
4997 
    oprot.writeMessageBegin("getValidOrderCount", TMessageType.REPLY, seqid)
4998 
    result.write(oprot)
4999 
    oprot.writeMessageEnd()
5000 
    oprot.trans.flush()
5001 
 
5002 
  def process_getNoOfCustomersWithSuccessfulTransaction(self, seqid, iprot, oprot):
5003 
    args = getNoOfCustomersWithSuccessfulTransaction_args()
5004 
    args.read(iprot)
5005 
    iprot.readMessageEnd()
5006 
    result = getNoOfCustomersWithSuccessfulTransaction_result()
5007 
    result.success = self._handler.getNoOfCustomersWithSuccessfulTransaction()
5008 
    oprot.writeMessageBegin("getNoOfCustomersWithSuccessfulTransaction", TMessageType.REPLY, seqid)
5009 
    result.write(oprot)
5010 
    oprot.writeMessageEnd()
5011 
    oprot.trans.flush()
5012 
 
5013 
  def process_getValidOrdersAmountRange(self, seqid, iprot, oprot):
5014 
    args = getValidOrdersAmountRange_args()
5015 
    args.read(iprot)
5016 
    iprot.readMessageEnd()
5017 
    result = getValidOrdersAmountRange_result()
5018 
    result.success = self._handler.getValidOrdersAmountRange()
5019 
    oprot.writeMessageBegin("getValidOrdersAmountRange", TMessageType.REPLY, seqid)
5020 
    result.write(oprot)
5021 
    oprot.writeMessageEnd()
5022 
    oprot.trans.flush()
5023 
 
5024 
  def process_getValidOrders(self, seqid, iprot, oprot):
5025 
    args = getValidOrders_args()
5026 
    args.read(iprot)
5027 
    iprot.readMessageEnd()
5028 
    result = getValidOrders_result()
5029 
    result.success = self._handler.getValidOrders(args.limit)
5030 
    oprot.writeMessageBegin("getValidOrders", TMessageType.REPLY, seqid)
5031 
    result.write(oprot)
5032 
    oprot.writeMessageEnd()
5033 
    oprot.trans.flush()
5034 
 
1220 chandransh 5035 
  def process_batchOrders(self, seqid, iprot, oprot):
5036 
    args = batchOrders_args()
5037 
    args.read(iprot)
5038 
    iprot.readMessageEnd()
5039 
    result = batchOrders_result()
5040 
    try:
5041 
      result.success = self._handler.batchOrders(args.warehouseId)
5042 
    except TransactionServiceException, ex:
5043 
      result.ex = ex
5044 
    oprot.writeMessageBegin("batchOrders", TMessageType.REPLY, seqid)
5045 
    result.write(oprot)
5046 
    oprot.writeMessageEnd()
5047 
    oprot.trans.flush()
5048 
 
1208 chandransh 5049 
  def process_markOrderAsOutOfStock(self, seqid, iprot, oprot):
5050 
    args = markOrderAsOutOfStock_args()
5051 
    args.read(iprot)
5052 
    iprot.readMessageEnd()
5053 
    result = markOrderAsOutOfStock_result()
5054 
    try:
5055 
      result.success = self._handler.markOrderAsOutOfStock(args.orderId)
5056 
    except TransactionServiceException, ex:
5057 
      result.ex = ex
5058 
    oprot.writeMessageBegin("markOrderAsOutOfStock", TMessageType.REPLY, seqid)
5059 
    result.write(oprot)
5060 
    oprot.writeMessageEnd()
5061 
    oprot.trans.flush()
5062 
 
3064 chandransh 5063 
  def process_verifyOrder(self, seqid, iprot, oprot):
5064 
    args = verifyOrder_args()
759 chandransh 5065 
    args.read(iprot)
5066 
    iprot.readMessageEnd()
3064 chandransh 5067 
    result = verifyOrder_result()
759 chandransh 5068 
    try:
3064 chandransh 5069 
      result.success = self._handler.verifyOrder(args.orderId)
759 chandransh 5070 
    except TransactionServiceException, ex:
5071 
      result.ex = ex
3064 chandransh 5072 
    oprot.writeMessageBegin("verifyOrder", TMessageType.REPLY, seqid)
759 chandransh 5073 
    result.write(oprot)
5074 
    oprot.writeMessageEnd()
5075 
    oprot.trans.flush()
5076 
 
3064 chandransh 5077 
  def process_acceptOrder(self, seqid, iprot, oprot):
5078 
    args = acceptOrder_args()
1113 chandransh 5079 
    args.read(iprot)
5080 
    iprot.readMessageEnd()
3064 chandransh 5081 
    result = acceptOrder_result()
1113 chandransh 5082 
    try:
3064 chandransh 5083 
      result.success = self._handler.acceptOrder(args.orderId)
1113 chandransh 5084 
    except TransactionServiceException, ex:
5085 
      result.ex = ex
3064 chandransh 5086 
    oprot.writeMessageBegin("acceptOrder", TMessageType.REPLY, seqid)
1113 chandransh 5087 
    result.write(oprot)
5088 
    oprot.writeMessageEnd()
5089 
    oprot.trans.flush()
5090 
 
3064 chandransh 5091 
  def process_addBillingDetails(self, seqid, iprot, oprot):
5092 
    args = addBillingDetails_args()
1135 chandransh 5093 
    args.read(iprot)
5094 
    iprot.readMessageEnd()
3064 chandransh 5095 
    result = addBillingDetails_result()
1135 chandransh 5096 
    try:
4763 rajveer 5097 
      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 5098 
    except TransactionServiceException, ex:
5099 
      result.ex = ex
3064 chandransh 5100 
    oprot.writeMessageBegin("addBillingDetails", TMessageType.REPLY, seqid)
1135 chandransh 5101 
    result.write(oprot)
5102 
    oprot.writeMessageEnd()
5103 
    oprot.trans.flush()
5104 
 
4579 rajveer 5105 
  def process_addInvoiceNumber(self, seqid, iprot, oprot):
5106 
    args = addInvoiceNumber_args()
5107 
    args.read(iprot)
5108 
    iprot.readMessageEnd()
5109 
    result = addInvoiceNumber_result()
5110 
    try:
4763 rajveer 5111 
      self._handler.addInvoiceNumber(args.orderId, args.invoiceNumber, args.color)
4579 rajveer 5112 
    except TransactionServiceException, ex:
5113 
      result.ex = ex
5114 
    oprot.writeMessageBegin("addInvoiceNumber", TMessageType.REPLY, seqid)
5115 
    result.write(oprot)
5116 
    oprot.writeMessageEnd()
5117 
    oprot.trans.flush()
5118 
 
3064 chandransh 5119 
  def process_markOrdersAsManifested(self, seqid, iprot, oprot):
5120 
    args = markOrdersAsManifested_args()
1408 ankur.sing 5121 
    args.read(iprot)
5122 
    iprot.readMessageEnd()
3064 chandransh 5123 
    result = markOrdersAsManifested_result()
5124 
    try:
5125 
      result.success = self._handler.markOrdersAsManifested(args.warehouseId, args.providerId, args.cod)
5126 
    except TransactionServiceException, ex:
5127 
      result.ex = ex
5128 
    oprot.writeMessageBegin("markOrdersAsManifested", TMessageType.REPLY, seqid)
1408 ankur.sing 5129 
    result.write(oprot)
5130 
    oprot.writeMessageEnd()
5131 
    oprot.trans.flush()
5132 
 
4410 rajveer 5133 
  def process_markOrdersAsShippedFromWarehouse(self, seqid, iprot, oprot):
5134 
    args = markOrdersAsShippedFromWarehouse_args()
5135 
    args.read(iprot)
5136 
    iprot.readMessageEnd()
5137 
    result = markOrdersAsShippedFromWarehouse_result()
5138 
    try:
4789 rajveer 5139 
      result.success = self._handler.markOrdersAsShippedFromWarehouse(args.warehouseId, args.providerId, args.cod, args.orderIds)
4410 rajveer 5140 
    except TransactionServiceException, ex:
5141 
      result.ex = ex
5142 
    oprot.writeMessageBegin("markOrdersAsShippedFromWarehouse", TMessageType.REPLY, seqid)
5143 
    result.write(oprot)
5144 
    oprot.writeMessageEnd()
5145 
    oprot.trans.flush()
5146 
 
3064 chandransh 5147 
  def process_markOrdersAsPickedUp(self, seqid, iprot, oprot):
5148 
    args = markOrdersAsPickedUp_args()
304 ashish 5149 
    args.read(iprot)
5150 
    iprot.readMessageEnd()
3064 chandransh 5151 
    result = markOrdersAsPickedUp_result()
5152 
    try:
5153 
      result.success = self._handler.markOrdersAsPickedUp(args.providerId, args.pickupDetails)
5154 
    except TransactionServiceException, ex:
5155 
      result.ex = ex
5156 
    oprot.writeMessageBegin("markOrdersAsPickedUp", TMessageType.REPLY, seqid)
304 ashish 5157 
    result.write(oprot)
5158 
    oprot.writeMessageEnd()
5159 
    oprot.trans.flush()
94 ashish 5160 
 
3064 chandransh 5161 
  def process_markOrdersAsDelivered(self, seqid, iprot, oprot):
5162 
    args = markOrdersAsDelivered_args()
304 ashish 5163 
    args.read(iprot)
5164 
    iprot.readMessageEnd()
3064 chandransh 5165 
    result = markOrdersAsDelivered_result()
5166 
    try:
5167 
      self._handler.markOrdersAsDelivered(args.providerId, args.deliveredOrders)
5168 
    except TransactionServiceException, ex:
5169 
      result.ex = ex
5170 
    oprot.writeMessageBegin("markOrdersAsDelivered", TMessageType.REPLY, seqid)
304 ashish 5171 
    result.write(oprot)
5172 
    oprot.writeMessageEnd()
5173 
    oprot.trans.flush()
5174 
 
3064 chandransh 5175 
  def process_markOrdersAsFailed(self, seqid, iprot, oprot):
5176 
    args = markOrdersAsFailed_args()
1596 ankur.sing 5177 
    args.read(iprot)
5178 
    iprot.readMessageEnd()
3064 chandransh 5179 
    result = markOrdersAsFailed_result()
5180 
    try:
5181 
      self._handler.markOrdersAsFailed(args.providerId, args.returnedOrders)
5182 
    except TransactionServiceException, ex:
5183 
      result.ex = ex
5184 
    oprot.writeMessageBegin("markOrdersAsFailed", TMessageType.REPLY, seqid)
1596 ankur.sing 5185 
    result.write(oprot)
5186 
    oprot.writeMessageEnd()
5187 
    oprot.trans.flush()
304 ashish 5188 
 
3064 chandransh 5189 
  def process_updateNonDeliveryReason(self, seqid, iprot, oprot):
5190 
    args = updateNonDeliveryReason_args()
1627 ankur.sing 5191 
    args.read(iprot)
5192 
    iprot.readMessageEnd()
3064 chandransh 5193 
    result = updateNonDeliveryReason_result()
5194 
    try:
4581 phani.kuma 5195 
      result.success = self._handler.updateNonDeliveryReason(args.providerId, args.undeliveredOrders)
3064 chandransh 5196 
    except TransactionServiceException, ex:
5197 
      result.ex = ex
5198 
    oprot.writeMessageBegin("updateNonDeliveryReason", TMessageType.REPLY, seqid)
1627 ankur.sing 5199 
    result.write(oprot)
5200 
    oprot.writeMessageEnd()
5201 
    oprot.trans.flush()
1596 ankur.sing 5202 
 
3064 chandransh 5203 
  def process_getUndeliveredOrders(self, seqid, iprot, oprot):
5204 
    args = getUndeliveredOrders_args()
1627 ankur.sing 5205 
    args.read(iprot)
5206 
    iprot.readMessageEnd()
3064 chandransh 5207 
    result = getUndeliveredOrders_result()
5208 
    result.success = self._handler.getUndeliveredOrders(args.providerId, args.warehouseId)
5209 
    oprot.writeMessageBegin("getUndeliveredOrders", TMessageType.REPLY, seqid)
1627 ankur.sing 5210 
    result.write(oprot)
5211 
    oprot.writeMessageEnd()
5212 
    oprot.trans.flush()
5213 
 
4783 phani.kuma 5214 
  def process_getUndeliveredOrdersExpectedDeliveryDateNotMet(self, seqid, iprot, oprot):
5215 
    args = getUndeliveredOrdersExpectedDeliveryDateNotMet_args()
5216 
    args.read(iprot)
5217 
    iprot.readMessageEnd()
5218 
    result = getUndeliveredOrdersExpectedDeliveryDateNotMet_result()
5219 
    result.success = self._handler.getUndeliveredOrdersExpectedDeliveryDateNotMet()
5220 
    oprot.writeMessageBegin("getUndeliveredOrdersExpectedDeliveryDateNotMet", TMessageType.REPLY, seqid)
5221 
    result.write(oprot)
5222 
    oprot.writeMessageEnd()
5223 
    oprot.trans.flush()
5224 
 
2536 chandransh 5225 
  def process_toggleDOAFlag(self, seqid, iprot, oprot):
5226 
    args = toggleDOAFlag_args()
5227 
    args.read(iprot)
5228 
    iprot.readMessageEnd()
5229 
    result = toggleDOAFlag_result()
5230 
    try:
5231 
      result.success = self._handler.toggleDOAFlag(args.orderId)
5232 
    except TransactionServiceException, ex:
5233 
      result.ex = ex
5234 
    oprot.writeMessageBegin("toggleDOAFlag", TMessageType.REPLY, seqid)
5235 
    result.write(oprot)
5236 
    oprot.writeMessageEnd()
5237 
    oprot.trans.flush()
1886 ankur.sing 5238 
 
4712 rajveer 5239 
  def process_markOrderAsDelivered(self, seqid, iprot, oprot):
5240 
    args = markOrderAsDelivered_args()
5241 
    args.read(iprot)
5242 
    iprot.readMessageEnd()
5243 
    result = markOrderAsDelivered_result()
5244 
    try:
5245 
      self._handler.markOrderAsDelivered(args.orderId, args.deliveryTimestamp, args.receiver)
5246 
    except TransactionServiceException, ex:
5247 
      result.ex = ex
5248 
    oprot.writeMessageBegin("markOrderAsDelivered", TMessageType.REPLY, seqid)
5249 
    result.write(oprot)
5250 
    oprot.writeMessageEnd()
5251 
    oprot.trans.flush()
5252 
 
4454 rajveer 5253 
  def process_markOrderDoaRequestReceived(self, seqid, iprot, oprot):
5254 
    args = markOrderDoaRequestReceived_args()
5255 
    args.read(iprot)
5256 
    iprot.readMessageEnd()
5257 
    result = markOrderDoaRequestReceived_result()
5258 
    try:
5259 
      result.success = self._handler.markOrderDoaRequestReceived(args.orderId)
5260 
    except TransactionServiceException, ex:
5261 
      result.ex = ex
5262 
    oprot.writeMessageBegin("markOrderDoaRequestReceived", TMessageType.REPLY, seqid)
5263 
    result.write(oprot)
5264 
    oprot.writeMessageEnd()
5265 
    oprot.trans.flush()
5266 
 
5267 
  def process_markOrderDoaRequestAuthorized(self, seqid, iprot, oprot):
5268 
    args = markOrderDoaRequestAuthorized_args()
5269 
    args.read(iprot)
5270 
    iprot.readMessageEnd()
5271 
    result = markOrderDoaRequestAuthorized_result()
5272 
    try:
5273 
      result.success = self._handler.markOrderDoaRequestAuthorized(args.orderId, args.isAuthorized)
5274 
    except TransactionServiceException, ex:
5275 
      result.ex = ex
5276 
    oprot.writeMessageBegin("markOrderDoaRequestAuthorized", TMessageType.REPLY, seqid)
5277 
    result.write(oprot)
5278 
    oprot.writeMessageEnd()
5279 
    oprot.trans.flush()
5280 
 
4488 rajveer 5281 
  def process_markOrderReturnRequestReceived(self, seqid, iprot, oprot):
5282 
    args = markOrderReturnRequestReceived_args()
5283 
    args.read(iprot)
5284 
    iprot.readMessageEnd()
5285 
    result = markOrderReturnRequestReceived_result()
5286 
    try:
5287 
      result.success = self._handler.markOrderReturnRequestReceived(args.orderId)
5288 
    except TransactionServiceException, ex:
5289 
      result.ex = ex
5290 
    oprot.writeMessageBegin("markOrderReturnRequestReceived", TMessageType.REPLY, seqid)
5291 
    result.write(oprot)
5292 
    oprot.writeMessageEnd()
5293 
    oprot.trans.flush()
5294 
 
5295 
  def process_markOrderReturnRequestAuthorized(self, seqid, iprot, oprot):
5296 
    args = markOrderReturnRequestAuthorized_args()
5297 
    args.read(iprot)
5298 
    iprot.readMessageEnd()
5299 
    result = markOrderReturnRequestAuthorized_result()
5300 
    try:
5301 
      result.success = self._handler.markOrderReturnRequestAuthorized(args.orderId, args.isAuthorized)
5302 
    except TransactionServiceException, ex:
5303 
      result.ex = ex
5304 
    oprot.writeMessageBegin("markOrderReturnRequestAuthorized", TMessageType.REPLY, seqid)
5305 
    result.write(oprot)
5306 
    oprot.writeMessageEnd()
5307 
    oprot.trans.flush()
5308 
 
2536 chandransh 5309 
  def process_requestPickupNumber(self, seqid, iprot, oprot):
5310 
    args = requestPickupNumber_args()
5311 
    args.read(iprot)
5312 
    iprot.readMessageEnd()
5313 
    result = requestPickupNumber_result()
5314 
    try:
4579 rajveer 5315 
      result.success = self._handler.requestPickupNumber(args.orderId, args.providerId)
2536 chandransh 5316 
    except TransactionServiceException, ex:
5317 
      result.ex = ex
5318 
    oprot.writeMessageBegin("requestPickupNumber", TMessageType.REPLY, seqid)
5319 
    result.write(oprot)
5320 
    oprot.writeMessageEnd()
5321 
    oprot.trans.flush()
5322 
 
5323 
  def process_authorizePickup(self, seqid, iprot, oprot):
5324 
    args = authorizePickup_args()
5325 
    args.read(iprot)
5326 
    iprot.readMessageEnd()
5327 
    result = authorizePickup_result()
5328 
    try:
4602 rajveer 5329 
      result.success = self._handler.authorizePickup(args.orderId, args.pickupNumber, args.providerId)
2536 chandransh 5330 
    except TransactionServiceException, ex:
5331 
      result.ex = ex
5332 
    oprot.writeMessageBegin("authorizePickup", TMessageType.REPLY, seqid)
5333 
    result.write(oprot)
5334 
    oprot.writeMessageEnd()
5335 
    oprot.trans.flush()
5336 
 
2764 chandransh 5337 
  def process_markDoasAsPickedUp(self, seqid, iprot, oprot):
5338 
    args = markDoasAsPickedUp_args()
5339 
    args.read(iprot)
5340 
    iprot.readMessageEnd()
5341 
    result = markDoasAsPickedUp_result()
5342 
    result.success = self._handler.markDoasAsPickedUp(args.providerId, args.pickupDetails)
5343 
    oprot.writeMessageBegin("markDoasAsPickedUp", TMessageType.REPLY, seqid)
5344 
    result.write(oprot)
5345 
    oprot.writeMessageEnd()
5346 
    oprot.trans.flush()
5347 
 
4741 phani.kuma 5348 
  def process_markReturnOrdersAsPickedUp(self, seqid, iprot, oprot):
5349 
    args = markReturnOrdersAsPickedUp_args()
5350 
    args.read(iprot)
5351 
    iprot.readMessageEnd()
5352 
    result = markReturnOrdersAsPickedUp_result()
5353 
    result.success = self._handler.markReturnOrdersAsPickedUp(args.providerId, args.pickupDetails)
5354 
    oprot.writeMessageBegin("markReturnOrdersAsPickedUp", TMessageType.REPLY, seqid)
5355 
    result.write(oprot)
5356 
    oprot.writeMessageEnd()
5357 
    oprot.trans.flush()
5358 
 
2616 chandransh 5359 
  def process_receiveReturn(self, seqid, iprot, oprot):
5360 
    args = receiveReturn_args()
2591 chandransh 5361 
    args.read(iprot)
5362 
    iprot.readMessageEnd()
2616 chandransh 5363 
    result = receiveReturn_result()
2591 chandransh 5364 
    try:
4479 rajveer 5365 
      result.success = self._handler.receiveReturn(args.orderId, args.receiveCondition)
2591 chandransh 5366 
    except TransactionServiceException, ex:
5367 
      result.ex = ex
2616 chandransh 5368 
    oprot.writeMessageBegin("receiveReturn", TMessageType.REPLY, seqid)
2591 chandransh 5369 
    result.write(oprot)
5370 
    oprot.writeMessageEnd()
5371 
    oprot.trans.flush()
2536 chandransh 5372 
 
2591 chandransh 5373 
  def process_validateDoa(self, seqid, iprot, oprot):
5374 
    args = validateDoa_args()
5375 
    args.read(iprot)
5376 
    iprot.readMessageEnd()
5377 
    result = validateDoa_result()
5378 
    try:
5379 
      result.success = self._handler.validateDoa(args.orderId, args.isValid)
5380 
    except TransactionServiceException, ex:
5381 
      result.ex = ex
5382 
    oprot.writeMessageBegin("validateDoa", TMessageType.REPLY, seqid)
5383 
    result.write(oprot)
5384 
    oprot.writeMessageEnd()
5385 
    oprot.trans.flush()
5386 
 
4495 rajveer 5387 
  def process_validateReturnProduct(self, seqid, iprot, oprot):
5388 
    args = validateReturnProduct_args()
5389 
    args.read(iprot)
5390 
    iprot.readMessageEnd()
5391 
    result = validateReturnProduct_result()
5392 
    try:
5393 
      result.success = self._handler.validateReturnProduct(args.orderId, args.isUsable)
5394 
    except TransactionServiceException, ex:
5395 
      result.ex = ex
5396 
    oprot.writeMessageBegin("validateReturnProduct", TMessageType.REPLY, seqid)
5397 
    result.write(oprot)
5398 
    oprot.writeMessageEnd()
5399 
    oprot.trans.flush()
5400 
 
2616 chandransh 5401 
  def process_reshipOrder(self, seqid, iprot, oprot):
5402 
    args = reshipOrder_args()
5403 
    args.read(iprot)
5404 
    iprot.readMessageEnd()
5405 
    result = reshipOrder_result()
5406 
    try:
5407 
      result.success = self._handler.reshipOrder(args.orderId)
5408 
    except TransactionServiceException, ex:
5409 
      result.ex = ex
5410 
    oprot.writeMessageBegin("reshipOrder", TMessageType.REPLY, seqid)
5411 
    result.write(oprot)
5412 
    oprot.writeMessageEnd()
5413 
    oprot.trans.flush()
2591 chandransh 5414 
 
2616 chandransh 5415 
  def process_refundOrder(self, seqid, iprot, oprot):
5416 
    args = refundOrder_args()
5417 
    args.read(iprot)
5418 
    iprot.readMessageEnd()
5419 
    result = refundOrder_result()
5420 
    try:
3226 chandransh 5421 
      result.success = self._handler.refundOrder(args.orderId, args.refundedBy, args.reason)
2616 chandransh 5422 
    except TransactionServiceException, ex:
5423 
      result.ex = ex
5424 
    oprot.writeMessageBegin("refundOrder", TMessageType.REPLY, seqid)
5425 
    result.write(oprot)
5426 
    oprot.writeMessageEnd()
5427 
    oprot.trans.flush()
5428 
 
2690 chandransh 5429 
  def process_getReturnOrders(self, seqid, iprot, oprot):
5430 
    args = getReturnOrders_args()
5431 
    args.read(iprot)
5432 
    iprot.readMessageEnd()
5433 
    result = getReturnOrders_result()
5434 
    result.success = self._handler.getReturnOrders(args.warehouseId, args.fromDate, args.toDate)
5435 
    oprot.writeMessageBegin("getReturnOrders", TMessageType.REPLY, seqid)
5436 
    result.write(oprot)
5437 
    oprot.writeMessageEnd()
5438 
    oprot.trans.flush()
2616 chandransh 5439 
 
2700 chandransh 5440 
  def process_getReturnOrder(self, seqid, iprot, oprot):
5441 
    args = getReturnOrder_args()
5442 
    args.read(iprot)
5443 
    iprot.readMessageEnd()
5444 
    result = getReturnOrder_result()
5445 
    try:
5446 
      result.success = self._handler.getReturnOrder(args.id)
5447 
    except TransactionServiceException, ex:
5448 
      result.ex = ex
5449 
    oprot.writeMessageBegin("getReturnOrder", TMessageType.REPLY, seqid)
5450 
    result.write(oprot)
5451 
    oprot.writeMessageEnd()
5452 
    oprot.trans.flush()
5453 
 
2690 chandransh 5454 
  def process_processReturn(self, seqid, iprot, oprot):
5455 
    args = processReturn_args()
5456 
    args.read(iprot)
5457 
    iprot.readMessageEnd()
5458 
    result = processReturn_result()
5459 
    try:
5460 
      self._handler.processReturn(args.returnOrderId)
5461 
    except TransactionServiceException, ex:
5462 
      result.ex = ex
5463 
    oprot.writeMessageBegin("processReturn", TMessageType.REPLY, seqid)
5464 
    result.write(oprot)
5465 
    oprot.writeMessageEnd()
5466 
    oprot.trans.flush()
5467 
 
3451 chandransh 5468 
  def process_updateWeight(self, seqid, iprot, oprot):
5469 
    args = updateWeight_args()
5470 
    args.read(iprot)
5471 
    iprot.readMessageEnd()
5472 
    result = updateWeight_result()
5473 
    try:
5474 
      result.success = self._handler.updateWeight(args.orderId, args.weight)
5475 
    except TransactionServiceException, ex:
5476 
      result.ex = ex
5477 
    oprot.writeMessageBegin("updateWeight", TMessageType.REPLY, seqid)
5478 
    result.write(oprot)
5479 
    oprot.writeMessageEnd()
5480 
    oprot.trans.flush()
2819 chandransh 5481 
 
3469 chandransh 5482 
  def process_changeItem(self, seqid, iprot, oprot):
5483 
    args = changeItem_args()
5484 
    args.read(iprot)
5485 
    iprot.readMessageEnd()
5486 
    result = changeItem_result()
5487 
    try:
5488 
      result.success = self._handler.changeItem(args.orderId, args.itemId)
5489 
    except TransactionServiceException, ex:
5490 
      result.ex = ex
5491 
    oprot.writeMessageBegin("changeItem", TMessageType.REPLY, seqid)
5492 
    result.write(oprot)
5493 
    oprot.writeMessageEnd()
5494 
    oprot.trans.flush()
3451 chandransh 5495 
 
3469 chandransh 5496 
  def process_shiftToWarehouse(self, seqid, iprot, oprot):
5497 
    args = shiftToWarehouse_args()
5498 
    args.read(iprot)
5499 
    iprot.readMessageEnd()
5500 
    result = shiftToWarehouse_result()
5501 
    try:
5502 
      result.success = self._handler.shiftToWarehouse(args.orderId, args.warehouseId)
5503 
    except TransactionServiceException, ex:
5504 
      result.ex = ex
5505 
    oprot.writeMessageBegin("shiftToWarehouse", TMessageType.REPLY, seqid)
5506 
    result.write(oprot)
5507 
    oprot.writeMessageEnd()
5508 
    oprot.trans.flush()
5509 
 
3553 chandransh 5510 
  def process_addDelayReason(self, seqid, iprot, oprot):
5511 
    args = addDelayReason_args()
5512 
    args.read(iprot)
5513 
    iprot.readMessageEnd()
5514 
    result = addDelayReason_result()
5515 
    try:
4647 rajveer 5516 
      result.success = self._handler.addDelayReason(args.orderId, args.delayReason, args.furtherDelay, args.delayReasonText)
3553 chandransh 5517 
    except TransactionServiceException, ex:
5518 
      result.ex = ex
5519 
    oprot.writeMessageBegin("addDelayReason", TMessageType.REPLY, seqid)
5520 
    result.write(oprot)
5521 
    oprot.writeMessageEnd()
5522 
    oprot.trans.flush()
3469 chandransh 5523 
 
3956 chandransh 5524 
  def process_reconcileCodCollection(self, seqid, iprot, oprot):
5525 
    args = reconcileCodCollection_args()
5526 
    args.read(iprot)
5527 
    iprot.readMessageEnd()
5528 
    result = reconcileCodCollection_result()
5529 
    try:
5530 
      result.success = self._handler.reconcileCodCollection(args.collectedAmountMap, args.xferBy, args.xferTxnId, args.xferDate)
5531 
    except TransactionServiceException, ex:
5532 
      result.ex = ex
5533 
    oprot.writeMessageBegin("reconcileCodCollection", TMessageType.REPLY, seqid)
5534 
    result.write(oprot)
5535 
    oprot.writeMessageEnd()
5536 
    oprot.trans.flush()
3553 chandransh 5537 
 
4008 mandeep.dh 5538 
  def process_getTransactionsRequiringExtraProcessing(self, seqid, iprot, oprot):
5539 
    args = getTransactionsRequiringExtraProcessing_args()
5540 
    args.read(iprot)
5541 
    iprot.readMessageEnd()
5542 
    result = getTransactionsRequiringExtraProcessing_result()
5543 
    result.success = self._handler.getTransactionsRequiringExtraProcessing(args.category)
5544 
    oprot.writeMessageBegin("getTransactionsRequiringExtraProcessing", TMessageType.REPLY, seqid)
5545 
    result.write(oprot)
5546 
    oprot.writeMessageEnd()
5547 
    oprot.trans.flush()
3956 chandransh 5548 
 
4008 mandeep.dh 5549 
  def process_markTransactionAsProcessed(self, seqid, iprot, oprot):
5550 
    args = markTransactionAsProcessed_args()
5551 
    args.read(iprot)
5552 
    iprot.readMessageEnd()
5553 
    result = markTransactionAsProcessed_result()
5554 
    self._handler.markTransactionAsProcessed(args.transactionId, args.category)
5555 
    oprot.writeMessageBegin("markTransactionAsProcessed", TMessageType.REPLY, seqid)
5556 
    result.write(oprot)
5557 
    oprot.writeMessageEnd()
5558 
    oprot.trans.flush()
5559 
 
4018 chandransh 5560 
  def process_getItemWiseRiskyOrdersCount(self, seqid, iprot, oprot):
5561 
    args = getItemWiseRiskyOrdersCount_args()
5562 
    args.read(iprot)
5563 
    iprot.readMessageEnd()
5564 
    result = getItemWiseRiskyOrdersCount_result()
5565 
    result.success = self._handler.getItemWiseRiskyOrdersCount()
5566 
    oprot.writeMessageBegin("getItemWiseRiskyOrdersCount", TMessageType.REPLY, seqid)
5567 
    result.write(oprot)
5568 
    oprot.writeMessageEnd()
5569 
    oprot.trans.flush()
4008 mandeep.dh 5570 
 
4295 varun.gupt 5571 
  def process_getOrdersForItemIds(self, seqid, iprot, oprot):
5572 
    args = getOrdersForItemIds_args()
5573 
    args.read(iprot)
5574 
    iprot.readMessageEnd()
5575 
    result = getOrdersForItemIds_result()
5576 
    result.success = self._handler.getOrdersForItemIds(args.itemIds)
5577 
    oprot.writeMessageBegin("getOrdersForItemIds", TMessageType.REPLY, seqid)
5578 
    result.write(oprot)
5579 
    oprot.writeMessageEnd()
5580 
    oprot.trans.flush()
5581 
 
4247 rajveer 5582 
  def process_markOrderCancellationRequestReceived(self, seqid, iprot, oprot):
5583 
    args = markOrderCancellationRequestReceived_args()
5584 
    args.read(iprot)
5585 
    iprot.readMessageEnd()
5586 
    result = markOrderCancellationRequestReceived_result()
5587 
    try:
5588 
      self._handler.markOrderCancellationRequestReceived(args.orderId)
5589 
    except TransactionServiceException, ex:
5590 
      result.ex = ex
5591 
    oprot.writeMessageBegin("markOrderCancellationRequestReceived", TMessageType.REPLY, seqid)
5592 
    result.write(oprot)
5593 
    oprot.writeMessageEnd()
5594 
    oprot.trans.flush()
4018 chandransh 5595 
 
4247 rajveer 5596 
  def process_markOrderCancellationRequestConfirmed(self, seqid, iprot, oprot):
5597 
    args = markOrderCancellationRequestConfirmed_args()
5598 
    args.read(iprot)
5599 
    iprot.readMessageEnd()
5600 
    result = markOrderCancellationRequestConfirmed_result()
5601 
    try:
5602 
      self._handler.markOrderCancellationRequestConfirmed(args.orderId)
5603 
    except TransactionServiceException, ex:
5604 
      result.ex = ex
5605 
    oprot.writeMessageBegin("markOrderCancellationRequestConfirmed", TMessageType.REPLY, seqid)
5606 
    result.write(oprot)
5607 
    oprot.writeMessageEnd()
5608 
    oprot.trans.flush()
5609 
 
5610 
  def process_markOrderCancellationRequestDenied(self, seqid, iprot, oprot):
5611 
    args = markOrderCancellationRequestDenied_args()
5612 
    args.read(iprot)
5613 
    iprot.readMessageEnd()
5614 
    result = markOrderCancellationRequestDenied_result()
5615 
    try:
5616 
      self._handler.markOrderCancellationRequestDenied(args.orderId)
5617 
    except TransactionServiceException, ex:
5618 
      result.ex = ex
5619 
    oprot.writeMessageBegin("markOrderCancellationRequestDenied", TMessageType.REPLY, seqid)
5620 
    result.write(oprot)
5621 
    oprot.writeMessageEnd()
5622 
    oprot.trans.flush()
5623 
 
4258 rajveer 5624 
  def process_markTransactionAsPaymentFlagRemoved(self, seqid, iprot, oprot):
5625 
    args = markTransactionAsPaymentFlagRemoved_args()
4247 rajveer 5626 
    args.read(iprot)
5627 
    iprot.readMessageEnd()
4258 rajveer 5628 
    result = markTransactionAsPaymentFlagRemoved_result()
4247 rajveer 5629 
    try:
4258 rajveer 5630 
      self._handler.markTransactionAsPaymentFlagRemoved(args.transactionId)
4247 rajveer 5631 
    except TransactionServiceException, ex:
5632 
      result.ex = ex
4258 rajveer 5633 
    oprot.writeMessageBegin("markTransactionAsPaymentFlagRemoved", TMessageType.REPLY, seqid)
4247 rajveer 5634 
    result.write(oprot)
5635 
    oprot.writeMessageEnd()
5636 
    oprot.trans.flush()
5637 
 
4259 anupam.sin 5638 
  def process_refundTransaction(self, seqid, iprot, oprot):
5639 
    args = refundTransaction_args()
5640 
    args.read(iprot)
5641 
    iprot.readMessageEnd()
5642 
    result = refundTransaction_result()
5643 
    try:
5644 
      self._handler.refundTransaction(args.transactionId, args.refundedBy, args.reason)
5645 
    except TransactionServiceException, ex:
5646 
      result.ex = ex
5647 
    oprot.writeMessageBegin("refundTransaction", TMessageType.REPLY, seqid)
5648 
    result.write(oprot)
5649 
    oprot.writeMessageEnd()
5650 
    oprot.trans.flush()
4247 rajveer 5651 
 
4324 mandeep.dh 5652 
  def process_updateShipmentAddress(self, seqid, iprot, oprot):
5653 
    args = updateShipmentAddress_args()
5654 
    args.read(iprot)
5655 
    iprot.readMessageEnd()
5656 
    result = updateShipmentAddress_result()
5657 
    try:
5658 
      self._handler.updateShipmentAddress(args.orderId, args.addressId)
5659 
    except TransactionServiceException, ex:
5660 
      result.ex = ex
5661 
    oprot.writeMessageBegin("updateShipmentAddress", TMessageType.REPLY, seqid)
5662 
    result.write(oprot)
5663 
    oprot.writeMessageEnd()
5664 
    oprot.trans.flush()
5665 
 
4285 rajveer 5666 
  def process_acceptOrdersForItemId(self, seqid, iprot, oprot):
5667 
    args = acceptOrdersForItemId_args()
5668 
    args.read(iprot)
5669 
    iprot.readMessageEnd()
5670 
    result = acceptOrdersForItemId_result()
5671 
    try:
5672 
      result.success = self._handler.acceptOrdersForItemId(args.itemId, args.inventory)
5673 
    except TransactionServiceException, ex:
5674 
      result.ex = ex
5675 
    oprot.writeMessageBegin("acceptOrdersForItemId", TMessageType.REPLY, seqid)
5676 
    result.write(oprot)
5677 
    oprot.writeMessageEnd()
5678 
    oprot.trans.flush()
4259 anupam.sin 5679 
 
4303 rajveer 5680 
  def process_markOrdersAsPORaised(self, seqid, iprot, oprot):
5681 
    args = markOrdersAsPORaised_args()
5682 
    args.read(iprot)
5683 
    iprot.readMessageEnd()
5684 
    result = markOrdersAsPORaised_result()
5685 
    try:
4369 rajveer 5686 
      self._handler.markOrdersAsPORaised(args.vendorId, args.itemId, args.quantity, args.estimate, args.isReminder)
4303 rajveer 5687 
    except TransactionServiceException, ex:
5688 
      result.ex = ex
5689 
    oprot.writeMessageBegin("markOrdersAsPORaised", TMessageType.REPLY, seqid)
5690 
    result.write(oprot)
5691 
    oprot.writeMessageEnd()
5692 
    oprot.trans.flush()
4285 rajveer 5693 
 
4303 rajveer 5694 
  def process_markOrdersAsReversalInitiated(self, seqid, iprot, oprot):
5695 
    args = markOrdersAsReversalInitiated_args()
5696 
    args.read(iprot)
5697 
    iprot.readMessageEnd()
5698 
    result = markOrdersAsReversalInitiated_result()
5699 
    try:
4369 rajveer 5700 
      self._handler.markOrdersAsReversalInitiated(args.vendorId, args.itemId, args.quantity, args.estimate, args.isReminder)
4303 rajveer 5701 
    except TransactionServiceException, ex:
5702 
      result.ex = ex
5703 
    oprot.writeMessageBegin("markOrdersAsReversalInitiated", TMessageType.REPLY, seqid)
5704 
    result.write(oprot)
5705 
    oprot.writeMessageEnd()
5706 
    oprot.trans.flush()
5707 
 
5708 
  def process_markOrdersAsNotAvailabke(self, seqid, iprot, oprot):
5709 
    args = markOrdersAsNotAvailabke_args()
5710 
    args.read(iprot)
5711 
    iprot.readMessageEnd()
5712 
    result = markOrdersAsNotAvailabke_result()
5713 
    try:
4369 rajveer 5714 
      self._handler.markOrdersAsNotAvailabke(args.vendorId, args.itemId, args.quantity, args.estimate, args.isReminder)
4303 rajveer 5715 
    except TransactionServiceException, ex:
5716 
      result.ex = ex
5717 
    oprot.writeMessageBegin("markOrdersAsNotAvailabke", TMessageType.REPLY, seqid)
5718 
    result.write(oprot)
5719 
    oprot.writeMessageEnd()
5720 
    oprot.trans.flush()
5721 
 
4369 rajveer 5722 
  def process_markOrdersAsTimeout(self, seqid, iprot, oprot):
5723 
    args = markOrdersAsTimeout_args()
5724 
    args.read(iprot)
5725 
    iprot.readMessageEnd()
5726 
    result = markOrdersAsTimeout_result()
5727 
    try:
5728 
      result.success = self._handler.markOrdersAsTimeout(args.vendorId)
5729 
    except TransactionServiceException, ex:
5730 
      result.ex = ex
5731 
    oprot.writeMessageBegin("markOrdersAsTimeout", TMessageType.REPLY, seqid)
5732 
    result.write(oprot)
5733 
    oprot.writeMessageEnd()
5734 
    oprot.trans.flush()
4303 rajveer 5735 
 
4662 rajveer 5736 
  def process_markOrderAsLostInTransit(self, seqid, iprot, oprot):
5737 
    args = markOrderAsLostInTransit_args()
5738 
    args.read(iprot)
5739 
    iprot.readMessageEnd()
5740 
    result = markOrderAsLostInTransit_result()
5741 
    try:
5742 
      result.success = self._handler.markOrderAsLostInTransit(args.orderId)
5743 
    except TransactionServiceException, ex:
5744 
      result.ex = ex
5745 
    oprot.writeMessageBegin("markOrderAsLostInTransit", TMessageType.REPLY, seqid)
5746 
    result.write(oprot)
5747 
    oprot.writeMessageEnd()
5748 
    oprot.trans.flush()
5749 
 
4386 anupam.sin 5750 
  def process_getOrderForAwb(self, seqid, iprot, oprot):
5751 
    args = getOrderForAwb_args()
5752 
    args.read(iprot)
5753 
    iprot.readMessageEnd()
5754 
    result = getOrderForAwb_result()
5755 
    try:
5756 
      result.success = self._handler.getOrderForAwb(args.awb)
5757 
    except TransactionServiceException, ex:
5758 
      result.ex = ex
5759 
    oprot.writeMessageBegin("getOrderForAwb", TMessageType.REPLY, seqid)
5760 
    result.write(oprot)
5761 
    oprot.writeMessageEnd()
5762 
    oprot.trans.flush()
4369 rajveer 5763 
 
4506 phani.kuma 5764 
  def process_getOrdersForProviderForStatus(self, seqid, iprot, oprot):
5765 
    args = getOrdersForProviderForStatus_args()
5766 
    args.read(iprot)
5767 
    iprot.readMessageEnd()
5768 
    result = getOrdersForProviderForStatus_result()
5769 
    try:
5770 
      result.success = self._handler.getOrdersForProviderForStatus(args.logistics_provider_id, args.order_status)
5771 
    except TransactionServiceException, ex:
5772 
      result.ex = ex
5773 
    oprot.writeMessageBegin("getOrdersForProviderForStatus", TMessageType.REPLY, seqid)
5774 
    result.write(oprot)
5775 
    oprot.writeMessageEnd()
5776 
    oprot.trans.flush()
4386 anupam.sin 5777 
 
4600 varun.gupt 5778 
  def process_getBilledOrdersForVendor(self, seqid, iprot, oprot):
5779 
    args = getBilledOrdersForVendor_args()
5780 
    args.read(iprot)
5781 
    iprot.readMessageEnd()
5782 
    result = getBilledOrdersForVendor_result()
5783 
    try:
5784 
      result.success = self._handler.getBilledOrdersForVendor(args.vendorId, args.billingDateFrom, args.billingDateTo)
5785 
    except TransactionServiceException, ex:
5786 
      result.ex = ex
5787 
    oprot.writeMessageBegin("getBilledOrdersForVendor", TMessageType.REPLY, seqid)
5788 
    result.write(oprot)
5789 
    oprot.writeMessageEnd()
5790 
    oprot.trans.flush()
4506 phani.kuma 5791 
 
4607 rajveer 5792 
  def process_getSlippedSippingDateOrders(self, seqid, iprot, oprot):
5793 
    args = getSlippedSippingDateOrders_args()
5794 
    args.read(iprot)
5795 
    iprot.readMessageEnd()
5796 
    result = getSlippedSippingDateOrders_result()
5797 
    try:
5798 
      result.success = self._handler.getSlippedSippingDateOrders()
5799 
    except TransactionServiceException, ex:
5800 
      result.ex = ex
5801 
    oprot.writeMessageBegin("getSlippedSippingDateOrders", TMessageType.REPLY, seqid)
5802 
    result.write(oprot)
5803 
    oprot.writeMessageEnd()
5804 
    oprot.trans.flush()
5805 
 
4709 rajveer 5806 
  def process_getCancelledOrders(self, seqid, iprot, oprot):
5807 
    args = getCancelledOrders_args()
5808 
    args.read(iprot)
5809 
    iprot.readMessageEnd()
5810 
    result = getCancelledOrders_result()
5811 
    try:
5812 
      result.success = self._handler.getCancelledOrders(args.cancelDateFrom, args.cancelDateTo)
5813 
    except TransactionServiceException, ex:
5814 
      result.ex = ex
5815 
    oprot.writeMessageBegin("getCancelledOrders", TMessageType.REPLY, seqid)
5816 
    result.write(oprot)
5817 
    oprot.writeMessageEnd()
5818 
    oprot.trans.flush()
5819 
 
4600 varun.gupt 5820 
  def process_saveBluedartSettlements(self, seqid, iprot, oprot):
5821 
    args = saveBluedartSettlements_args()
5822 
    args.read(iprot)
5823 
    iprot.readMessageEnd()
5824 
    result = saveBluedartSettlements_result()
5825 
    try:
5826 
      self._handler.saveBluedartSettlements(args.mapAWBAndAmount)
5827 
    except TransactionServiceException, ex:
5828 
      result.ex = ex
5829 
    oprot.writeMessageBegin("saveBluedartSettlements", TMessageType.REPLY, seqid)
5830 
    result.write(oprot)
5831 
    oprot.writeMessageEnd()
5832 
    oprot.trans.flush()
5833 
 
5834 
  def process_savePaymentSettlements(self, seqid, iprot, oprot):
5835 
    args = savePaymentSettlements_args()
5836 
    args.read(iprot)
5837 
    iprot.readMessageEnd()
5838 
    result = savePaymentSettlements_result()
5839 
    try:
5840 
      self._handler.savePaymentSettlements(args.settlementDate, args.paymentGatewayId, args.paymentId, args.serviceTax, args.otherCharges, args.netCollection)
5841 
    except TransactionServiceException, ex:
5842 
      result.ex = ex
5843 
    oprot.writeMessageBegin("savePaymentSettlements", TMessageType.REPLY, seqid)
5844 
    result.write(oprot)
5845 
    oprot.writeMessageEnd()
5846 
    oprot.trans.flush()
5847 
 
4875 varun.gupt 5848 
  def process_saveCODPaymentSettlement(self, seqid, iprot, oprot):
5849 
    args = saveCODPaymentSettlement_args()
5850 
    args.read(iprot)
5851 
    iprot.readMessageEnd()
5852 
    result = saveCODPaymentSettlement_result()
5853 
    try:
5854 
      self._handler.saveCODPaymentSettlement(args.orderId, args.settlementDate, args.collection)
5855 
    except TransactionServiceException, ex:
5856 
      result.ex = ex
5857 
    oprot.writeMessageBegin("saveCODPaymentSettlement", TMessageType.REPLY, seqid)
5858 
    result.write(oprot)
5859 
    oprot.writeMessageEnd()
5860 
    oprot.trans.flush()
5861 
 
4600 varun.gupt 5862 
  def process_saveEBSSettlementSummary(self, seqid, iprot, oprot):
5863 
    args = saveEBSSettlementSummary_args()
5864 
    args.read(iprot)
5865 
    iprot.readMessageEnd()
5866 
    result = saveEBSSettlementSummary_result()
5867 
    try:
5868 
      self._handler.saveEBSSettlementSummary(args.settlementId, args.settlementDate, args.transactionDateFrom, args.transactionDateTo, args.amount)
5869 
    except TransactionServiceException, ex:
5870 
      result.ex = ex
5871 
    oprot.writeMessageBegin("saveEBSSettlementSummary", TMessageType.REPLY, seqid)
5872 
    result.write(oprot)
5873 
    oprot.writeMessageEnd()
5874 
    oprot.trans.flush()
5875 
 
5876 
  def process_getSettlementForPaymentId(self, seqid, iprot, oprot):
5877 
    args = getSettlementForPaymentId_args()
5878 
    args.read(iprot)
5879 
    iprot.readMessageEnd()
5880 
    result = getSettlementForPaymentId_result()
5881 
    try:
5882 
      result.success = self._handler.getSettlementForPaymentId(args.paymentId)
5883 
    except TransactionServiceException, ex:
5884 
      result.ex = ex
5885 
    oprot.writeMessageBegin("getSettlementForPaymentId", TMessageType.REPLY, seqid)
5886 
    result.write(oprot)
5887 
    oprot.writeMessageEnd()
5888 
    oprot.trans.flush()
5889 
 
5890 
  def process_getEBSSettlementSummaries(self, seqid, iprot, oprot):
5891 
    args = getEBSSettlementSummaries_args()
5892 
    args.read(iprot)
5893 
    iprot.readMessageEnd()
5894 
    result = getEBSSettlementSummaries_result()
5895 
    try:
5896 
      result.success = self._handler.getEBSSettlementSummaries()
5897 
    except TransactionServiceException, ex:
5898 
      result.ex = ex
5899 
    oprot.writeMessageBegin("getEBSSettlementSummaries", TMessageType.REPLY, seqid)
5900 
    result.write(oprot)
5901 
    oprot.writeMessageEnd()
5902 
    oprot.trans.flush()
5903 
 
5904 
  def process_markEBSSettlementUploaded(self, seqid, iprot, oprot):
5905 
    args = markEBSSettlementUploaded_args()
5906 
    args.read(iprot)
5907 
    iprot.readMessageEnd()
5908 
    result = markEBSSettlementUploaded_result()
5909 
    try:
5910 
      self._handler.markEBSSettlementUploaded(args.settlementId)
5911 
    except TransactionServiceException, ex:
5912 
      result.ex = ex
5913 
    oprot.writeMessageBegin("markEBSSettlementUploaded", TMessageType.REPLY, seqid)
5914 
    result.write(oprot)
5915 
    oprot.writeMessageEnd()
5916 
    oprot.trans.flush()
5917 
 
5918 
  def process_getEBSSettlementDate(self, seqid, iprot, oprot):
5919 
    args = getEBSSettlementDate_args()
5920 
    args.read(iprot)
5921 
    iprot.readMessageEnd()
5922 
    result = getEBSSettlementDate_result()
5923 
    try:
5924 
      result.success = self._handler.getEBSSettlementDate(args.settlementId)
5925 
    except TransactionServiceException, ex:
5926 
      result.ex = ex
5927 
    oprot.writeMessageBegin("getEBSSettlementDate", TMessageType.REPLY, seqid)
5928 
    result.write(oprot)
5929 
    oprot.writeMessageEnd()
5930 
    oprot.trans.flush()
5931 
 
4715 varun.gupt 5932 
  def process_getSettlementsByDate(self, seqid, iprot, oprot):
5933 
    args = getSettlementsByDate_args()
5934 
    args.read(iprot)
5935 
    iprot.readMessageEnd()
5936 
    result = getSettlementsByDate_result()
5937 
    try:
5938 
      result.success = self._handler.getSettlementsByDate(args.settlementDateFrom, args.settlementDateTo, args.isRefund)
5939 
    except TransactionServiceException, ex:
5940 
      result.ex = ex
5941 
    oprot.writeMessageBegin("getSettlementsByDate", TMessageType.REPLY, seqid)
5942 
    result.write(oprot)
5943 
    oprot.writeMessageEnd()
5944 
    oprot.trans.flush()
4600 varun.gupt 5945 
 
4715 varun.gupt 5946 
  def process_getReshippedOrderIds(self, seqid, iprot, oprot):
5947 
    args = getReshippedOrderIds_args()
5948 
    args.read(iprot)
5949 
    iprot.readMessageEnd()
5950 
    result = getReshippedOrderIds_result()
5951 
    try:
5952 
      result.success = self._handler.getReshippedOrderIds(args.orderIds)
5953 
    except TransactionServiceException, ex:
5954 
      result.ex = ex
5955 
    oprot.writeMessageBegin("getReshippedOrderIds", TMessageType.REPLY, seqid)
5956 
    result.write(oprot)
5957 
    oprot.writeMessageEnd()
5958 
    oprot.trans.flush()
5959 
 
4757 mandeep.dh 5960 
  def process_updateOrdersAsPORaised(self, seqid, iprot, oprot):
5961 
    args = updateOrdersAsPORaised_args()
5962 
    args.read(iprot)
5963 
    iprot.readMessageEnd()
5964 
    result = updateOrdersAsPORaised_result()
5965 
    try:
5966 
      self._handler.updateOrdersAsPORaised(args.itemIdQuantityMap, args.purchaseOrderId, args.warehouseId)
5967 
    except TransactionServiceException, ex:
5968 
      result.ex = ex
5969 
    oprot.writeMessageBegin("updateOrdersAsPORaised", TMessageType.REPLY, seqid)
5970 
    result.write(oprot)
5971 
    oprot.writeMessageEnd()
5972 
    oprot.trans.flush()
4715 varun.gupt 5973 
 
4875 varun.gupt 5974 
  def process_getOrdersWhereVendorNotPaid(self, seqid, iprot, oprot):
5975 
    args = getOrdersWhereVendorNotPaid_args()
5976 
    args.read(iprot)
5977 
    iprot.readMessageEnd()
5978 
    result = getOrdersWhereVendorNotPaid_result()
5979 
    try:
5980 
      result.success = self._handler.getOrdersWhereVendorNotPaid(args.vendorId)
5981 
    except TransactionServiceException, ex:
5982 
      result.ex = ex
5983 
    oprot.writeMessageBegin("getOrdersWhereVendorNotPaid", TMessageType.REPLY, seqid)
5984 
    result.write(oprot)
5985 
    oprot.writeMessageEnd()
5986 
    oprot.trans.flush()
4757 mandeep.dh 5987 
 
4875 varun.gupt 5988 
 
94 ashish 5989 
# HELPER FUNCTIONS AND STRUCTURES
5990 
 
5991 
class createTransaction_args:
5992 
  """
5993 
  Attributes:
5994 
   - transaction
5995 
  """
5996 
 
5997 
  thrift_spec = (
5998 
    None, # 0
5999 
    (1, TType.STRUCT, 'transaction', (Transaction, Transaction.thrift_spec), None, ), # 1
6000 
  )
6001 
 
6002 
  def __init__(self, transaction=None,):
6003 
    self.transaction = transaction
6004 
 
6005 
  def read(self, iprot):
6006 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
6007 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
6008 
      return
6009 
    iprot.readStructBegin()
6010 
    while True:
6011 
      (fname, ftype, fid) = iprot.readFieldBegin()
6012 
      if ftype == TType.STOP:
6013 
        break
6014 
      if fid == 1:
6015 
        if ftype == TType.STRUCT:
6016 
          self.transaction = Transaction()
6017 
          self.transaction.read(iprot)
6018 
        else:
6019 
          iprot.skip(ftype)
6020 
      else:
6021 
        iprot.skip(ftype)
6022 
      iprot.readFieldEnd()
6023 
    iprot.readStructEnd()
6024 
 
6025 
  def write(self, oprot):
6026 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
6027 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
6028 
      return
6029 
    oprot.writeStructBegin('createTransaction_args')
3431 rajveer 6030 
    if self.transaction is not None:
94 ashish 6031 
      oprot.writeFieldBegin('transaction', TType.STRUCT, 1)
6032 
      self.transaction.write(oprot)
6033 
      oprot.writeFieldEnd()
6034 
    oprot.writeFieldStop()
6035 
    oprot.writeStructEnd()
6036 
 
3431 rajveer 6037 
  def validate(self):
6038 
    return
6039 
 
6040 
 
94 ashish 6041 
  def __repr__(self):
6042 
    L = ['%s=%r' % (key, value)
6043 
      for key, value in self.__dict__.iteritems()]
6044 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
6045 
 
6046 
  def __eq__(self, other):
6047 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
6048 
 
6049 
  def __ne__(self, other):
6050 
    return not (self == other)
6051 
 
6052 
class createTransaction_result:
6053 
  """
6054 
  Attributes:
132 ashish 6055 
   - success
94 ashish 6056 
   - ex
6057 
  """
6058 
 
6059 
  thrift_spec = (
132 ashish 6060 
    (0, TType.I64, 'success', None, None, ), # 0
94 ashish 6061 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
6062 
  )
6063 
 
132 ashish 6064 
  def __init__(self, success=None, ex=None,):
6065 
    self.success = success
94 ashish 6066 
    self.ex = ex
6067 
 
6068 
  def read(self, iprot):
6069 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
6070 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
6071 
      return
6072 
    iprot.readStructBegin()
6073 
    while True:
6074 
      (fname, ftype, fid) = iprot.readFieldBegin()
6075 
      if ftype == TType.STOP:
6076 
        break
132 ashish 6077 
      if fid == 0:
6078 
        if ftype == TType.I64:
6079 
          self.success = iprot.readI64();
6080 
        else:
6081 
          iprot.skip(ftype)
6082 
      elif fid == 1:
94 ashish 6083 
        if ftype == TType.STRUCT:
6084 
          self.ex = TransactionServiceException()
6085 
          self.ex.read(iprot)
6086 
        else:
6087 
          iprot.skip(ftype)
6088 
      else:
6089 
        iprot.skip(ftype)
6090 
      iprot.readFieldEnd()
6091 
    iprot.readStructEnd()
6092 
 
6093 
  def write(self, oprot):
6094 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
6095 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
6096 
      return
6097 
    oprot.writeStructBegin('createTransaction_result')
3431 rajveer 6098 
    if self.success is not None:
132 ashish 6099 
      oprot.writeFieldBegin('success', TType.I64, 0)
6100 
      oprot.writeI64(self.success)
6101 
      oprot.writeFieldEnd()
3431 rajveer 6102 
    if self.ex is not None:
94 ashish 6103 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
6104 
      self.ex.write(oprot)
6105 
      oprot.writeFieldEnd()
6106 
    oprot.writeFieldStop()
6107 
    oprot.writeStructEnd()
6108 
 
3431 rajveer 6109 
  def validate(self):
6110 
    return
6111 
 
6112 
 
94 ashish 6113 
  def __repr__(self):
6114 
    L = ['%s=%r' % (key, value)
6115 
      for key, value in self.__dict__.iteritems()]
6116 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
6117 
 
6118 
  def __eq__(self, other):
6119 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
6120 
 
6121 
  def __ne__(self, other):
6122 
    return not (self == other)
6123 
 
6124 
class getTransaction_args:
6125 
  """
6126 
  Attributes:
6127 
   - id
6128 
  """
6129 
 
6130 
  thrift_spec = (
6131 
    None, # 0
6132 
    (1, TType.I64, 'id', None, None, ), # 1
6133 
  )
6134 
 
6135 
  def __init__(self, id=None,):
6136 
    self.id = id
6137 
 
6138 
  def read(self, iprot):
6139 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
6140 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
6141 
      return
6142 
    iprot.readStructBegin()
6143 
    while True:
6144 
      (fname, ftype, fid) = iprot.readFieldBegin()
6145 
      if ftype == TType.STOP:
6146 
        break
6147 
      if fid == 1:
6148 
        if ftype == TType.I64:
6149 
          self.id = iprot.readI64();
6150 
        else:
6151 
          iprot.skip(ftype)
6152 
      else:
6153 
        iprot.skip(ftype)
6154 
      iprot.readFieldEnd()
6155 
    iprot.readStructEnd()
6156 
 
6157 
  def write(self, oprot):
6158 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
6159 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
6160 
      return
6161 
    oprot.writeStructBegin('getTransaction_args')
3431 rajveer 6162 
    if self.id is not None:
94 ashish 6163 
      oprot.writeFieldBegin('id', TType.I64, 1)
6164 
      oprot.writeI64(self.id)
6165 
      oprot.writeFieldEnd()
6166 
    oprot.writeFieldStop()
6167 
    oprot.writeStructEnd()
6168 
 
3431 rajveer 6169 
  def validate(self):
6170 
    return
6171 
 
6172 
 
94 ashish 6173 
  def __repr__(self):
6174 
    L = ['%s=%r' % (key, value)
6175 
      for key, value in self.__dict__.iteritems()]
6176 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
6177 
 
6178 
  def __eq__(self, other):
6179 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
6180 
 
6181 
  def __ne__(self, other):
6182 
    return not (self == other)
6183 
 
6184 
class getTransaction_result:
6185 
  """
6186 
  Attributes:
6187 
   - success
6188 
   - ex
6189 
  """
6190 
 
6191 
  thrift_spec = (
6192 
    (0, TType.STRUCT, 'success', (Transaction, Transaction.thrift_spec), None, ), # 0
6193 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
6194 
  )
6195 
 
6196 
  def __init__(self, success=None, ex=None,):
6197 
    self.success = success
6198 
    self.ex = ex
6199 
 
6200 
  def read(self, iprot):
6201 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
6202 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
6203 
      return
6204 
    iprot.readStructBegin()
6205 
    while True:
6206 
      (fname, ftype, fid) = iprot.readFieldBegin()
6207 
      if ftype == TType.STOP:
6208 
        break
6209 
      if fid == 0:
6210 
        if ftype == TType.STRUCT:
6211 
          self.success = Transaction()
6212 
          self.success.read(iprot)
6213 
        else:
6214 
          iprot.skip(ftype)
6215 
      elif fid == 1:
6216 
        if ftype == TType.STRUCT:
6217 
          self.ex = TransactionServiceException()
6218 
          self.ex.read(iprot)
6219 
        else:
6220 
          iprot.skip(ftype)
6221 
      else:
6222 
        iprot.skip(ftype)
6223 
      iprot.readFieldEnd()
6224 
    iprot.readStructEnd()
6225 
 
6226 
  def write(self, oprot):
6227 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
6228 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
6229 
      return
6230 
    oprot.writeStructBegin('getTransaction_result')
3431 rajveer 6231 
    if self.success is not None:
94 ashish 6232 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
6233 
      self.success.write(oprot)
6234 
      oprot.writeFieldEnd()
3431 rajveer 6235 
    if self.ex is not None:
94 ashish 6236 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
6237 
      self.ex.write(oprot)
6238 
      oprot.writeFieldEnd()
6239 
    oprot.writeFieldStop()
6240 
    oprot.writeStructEnd()
6241 
 
3431 rajveer 6242 
  def validate(self):
6243 
    return
6244 
 
6245 
 
94 ashish 6246 
  def __repr__(self):
6247 
    L = ['%s=%r' % (key, value)
6248 
      for key, value in self.__dict__.iteritems()]
6249 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
6250 
 
6251 
  def __eq__(self, other):
6252 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
6253 
 
6254 
  def __ne__(self, other):
6255 
    return not (self == other)
6256 
 
6257 
class getTransactionsForCustomer_args:
6258 
  """
6259 
  Attributes:
6260 
   - customerId
6261 
   - from_date
6262 
   - to_date
6263 
   - status
6264 
  """
6265 
 
6266 
  thrift_spec = (
6267 
    None, # 0
6268 
    (1, TType.I64, 'customerId', None, None, ), # 1
6269 
    (2, TType.I64, 'from_date', None, None, ), # 2
6270 
    (3, TType.I64, 'to_date', None, None, ), # 3
6271 
    (4, TType.I32, 'status', None, None, ), # 4
6272 
  )
6273 
 
6274 
  def __init__(self, customerId=None, from_date=None, to_date=None, status=None,):
6275 
    self.customerId = customerId
6276 
    self.from_date = from_date
6277 
    self.to_date = to_date
6278 
    self.status = status
6279 
 
6280 
  def read(self, iprot):
6281 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
6282 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
6283 
      return
6284 
    iprot.readStructBegin()
6285 
    while True:
6286 
      (fname, ftype, fid) = iprot.readFieldBegin()
6287 
      if ftype == TType.STOP:
6288 
        break
6289 
      if fid == 1:
6290 
        if ftype == TType.I64:
6291 
          self.customerId = iprot.readI64();
6292 
        else:
6293 
          iprot.skip(ftype)
6294 
      elif fid == 2:
6295 
        if ftype == TType.I64:
6296 
          self.from_date = iprot.readI64();
6297 
        else:
6298 
          iprot.skip(ftype)
6299 
      elif fid == 3:
6300 
        if ftype == TType.I64:
6301 
          self.to_date = iprot.readI64();
6302 
        else:
6303 
          iprot.skip(ftype)
6304 
      elif fid == 4:
6305 
        if ftype == TType.I32:
6306 
          self.status = iprot.readI32();
6307 
        else:
6308 
          iprot.skip(ftype)
6309 
      else:
6310 
        iprot.skip(ftype)
6311 
      iprot.readFieldEnd()
6312 
    iprot.readStructEnd()
6313 
 
6314 
  def write(self, oprot):
6315 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
6316 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
6317 
      return
6318 
    oprot.writeStructBegin('getTransactionsForCustomer_args')
3431 rajveer 6319 
    if self.customerId is not None:
94 ashish 6320 
      oprot.writeFieldBegin('customerId', TType.I64, 1)
6321 
      oprot.writeI64(self.customerId)
6322 
      oprot.writeFieldEnd()
3431 rajveer 6323 
    if self.from_date is not None:
94 ashish 6324 
      oprot.writeFieldBegin('from_date', TType.I64, 2)
6325 
      oprot.writeI64(self.from_date)
6326 
      oprot.writeFieldEnd()
3431 rajveer 6327 
    if self.to_date is not None:
94 ashish 6328 
      oprot.writeFieldBegin('to_date', TType.I64, 3)
6329 
      oprot.writeI64(self.to_date)
6330 
      oprot.writeFieldEnd()
3431 rajveer 6331 
    if self.status is not None:
94 ashish 6332 
      oprot.writeFieldBegin('status', TType.I32, 4)
6333 
      oprot.writeI32(self.status)
6334 
      oprot.writeFieldEnd()
6335 
    oprot.writeFieldStop()
6336 
    oprot.writeStructEnd()
6337 
 
3431 rajveer 6338 
  def validate(self):
6339 
    return
6340 
 
6341 
 
94 ashish 6342 
  def __repr__(self):
6343 
    L = ['%s=%r' % (key, value)
6344 
      for key, value in self.__dict__.iteritems()]
6345 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
6346 
 
6347 
  def __eq__(self, other):
6348 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
6349 
 
6350 
  def __ne__(self, other):
6351 
    return not (self == other)
6352 
 
6353 
class getTransactionsForCustomer_result:
6354 
  """
6355 
  Attributes:
6356 
   - success
6357 
   - ex
6358 
  """
6359 
 
6360 
  thrift_spec = (
6361 
    (0, TType.LIST, 'success', (TType.STRUCT,(Transaction, Transaction.thrift_spec)), None, ), # 0
6362 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
6363 
  )
6364 
 
6365 
  def __init__(self, success=None, ex=None,):
6366 
    self.success = success
6367 
    self.ex = ex
6368 
 
6369 
  def read(self, iprot):
6370 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
6371 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
6372 
      return
6373 
    iprot.readStructBegin()
6374 
    while True:
6375 
      (fname, ftype, fid) = iprot.readFieldBegin()
6376 
      if ftype == TType.STOP:
6377 
        break
6378 
      if fid == 0:
6379 
        if ftype == TType.LIST:
6380 
          self.success = []
4837 varun.gupt 6381 
          (_etype45, _size42) = iprot.readListBegin()
6382 
          for _i46 in xrange(_size42):
6383 
            _elem47 = Transaction()
6384 
            _elem47.read(iprot)
6385 
            self.success.append(_elem47)
94 ashish 6386 
          iprot.readListEnd()
6387 
        else:
6388 
          iprot.skip(ftype)
6389 
      elif fid == 1:
6390 
        if ftype == TType.STRUCT:
6391 
          self.ex = TransactionServiceException()
6392 
          self.ex.read(iprot)
6393 
        else:
6394 
          iprot.skip(ftype)
6395 
      else:
6396 
        iprot.skip(ftype)
6397 
      iprot.readFieldEnd()
6398 
    iprot.readStructEnd()
6399 
 
6400 
  def write(self, oprot):
6401 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
6402 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
6403 
      return
6404 
    oprot.writeStructBegin('getTransactionsForCustomer_result')
3431 rajveer 6405 
    if self.success is not None:
94 ashish 6406 
      oprot.writeFieldBegin('success', TType.LIST, 0)
6407 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
4837 varun.gupt 6408 
      for iter48 in self.success:
6409 
        iter48.write(oprot)
94 ashish 6410 
      oprot.writeListEnd()
6411 
      oprot.writeFieldEnd()
3431 rajveer 6412 
    if self.ex is not None:
94 ashish 6413 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
6414 
      self.ex.write(oprot)
6415 
      oprot.writeFieldEnd()
6416 
    oprot.writeFieldStop()
6417 
    oprot.writeStructEnd()
6418 
 
3431 rajveer 6419 
  def validate(self):
6420 
    return
6421 
 
6422 
 
94 ashish 6423 
  def __repr__(self):
6424 
    L = ['%s=%r' % (key, value)
6425 
      for key, value in self.__dict__.iteritems()]
6426 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
6427 
 
6428 
  def __eq__(self, other):
6429 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
6430 
 
6431 
  def __ne__(self, other):
6432 
    return not (self == other)
6433 
 
132 ashish 6434 
class getTransactionsForShoppingCartId_args:
6435 
  """
6436 
  Attributes:
6437 
   - shoppingCartId
6438 
  """
6439 
 
6440 
  thrift_spec = (
6441 
    None, # 0
6442 
    (1, TType.I64, 'shoppingCartId', None, None, ), # 1
6443 
  )
6444 
 
6445 
  def __init__(self, shoppingCartId=None,):
6446 
    self.shoppingCartId = shoppingCartId
6447 
 
6448 
  def read(self, iprot):
6449 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
6450 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
6451 
      return
6452 
    iprot.readStructBegin()
6453 
    while True:
6454 
      (fname, ftype, fid) = iprot.readFieldBegin()
6455 
      if ftype == TType.STOP:
6456 
        break
6457 
      if fid == 1:
6458 
        if ftype == TType.I64:
6459 
          self.shoppingCartId = iprot.readI64();
6460 
        else:
6461 
          iprot.skip(ftype)
6462 
      else:
6463 
        iprot.skip(ftype)
6464 
      iprot.readFieldEnd()
6465 
    iprot.readStructEnd()
6466 
 
6467 
  def write(self, oprot):
6468 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
6469 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
6470 
      return
6471 
    oprot.writeStructBegin('getTransactionsForShoppingCartId_args')
3431 rajveer 6472 
    if self.shoppingCartId is not None:
132 ashish 6473 
      oprot.writeFieldBegin('shoppingCartId', TType.I64, 1)
6474 
      oprot.writeI64(self.shoppingCartId)
6475 
      oprot.writeFieldEnd()
6476 
    oprot.writeFieldStop()
6477 
    oprot.writeStructEnd()
6478 
 
3431 rajveer 6479 
  def validate(self):
6480 
    return
6481 
 
6482 
 
132 ashish 6483 
  def __repr__(self):
6484 
    L = ['%s=%r' % (key, value)
6485 
      for key, value in self.__dict__.iteritems()]
6486 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
6487 
 
6488 
  def __eq__(self, other):
6489 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
6490 
 
6491 
  def __ne__(self, other):
6492 
    return not (self == other)
6493 
 
6494 
class getTransactionsForShoppingCartId_result:
6495 
  """
6496 
  Attributes:
6497 
   - success
6498 
   - ex
6499 
  """
6500 
 
6501 
  thrift_spec = (
6502 
    (0, TType.LIST, 'success', (TType.STRUCT,(Transaction, Transaction.thrift_spec)), None, ), # 0
6503 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
6504 
  )
6505 
 
6506 
  def __init__(self, success=None, ex=None,):
6507 
    self.success = success
6508 
    self.ex = ex
6509 
 
6510 
  def read(self, iprot):
6511 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
6512 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
6513 
      return
6514 
    iprot.readStructBegin()
6515 
    while True:
6516 
      (fname, ftype, fid) = iprot.readFieldBegin()
6517 
      if ftype == TType.STOP:
6518 
        break
6519 
      if fid == 0:
6520 
        if ftype == TType.LIST:
6521 
          self.success = []
4837 varun.gupt 6522 
          (_etype52, _size49) = iprot.readListBegin()
6523 
          for _i53 in xrange(_size49):
6524 
            _elem54 = Transaction()
6525 
            _elem54.read(iprot)
6526 
            self.success.append(_elem54)
132 ashish 6527 
          iprot.readListEnd()
6528 
        else:
6529 
          iprot.skip(ftype)
6530 
      elif fid == 1:
6531 
        if ftype == TType.STRUCT:
6532 
          self.ex = TransactionServiceException()
6533 
          self.ex.read(iprot)
6534 
        else:
6535 
          iprot.skip(ftype)
6536 
      else:
6537 
        iprot.skip(ftype)
6538 
      iprot.readFieldEnd()
6539 
    iprot.readStructEnd()
6540 
 
6541 
  def write(self, oprot):
6542 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
6543 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
6544 
      return
6545 
    oprot.writeStructBegin('getTransactionsForShoppingCartId_result')
3431 rajveer 6546 
    if self.success is not None:
132 ashish 6547 
      oprot.writeFieldBegin('success', TType.LIST, 0)
6548 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
4837 varun.gupt 6549 
      for iter55 in self.success:
6550 
        iter55.write(oprot)
132 ashish 6551 
      oprot.writeListEnd()
6552 
      oprot.writeFieldEnd()
3431 rajveer 6553 
    if self.ex is not None:
132 ashish 6554 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
6555 
      self.ex.write(oprot)
6556 
      oprot.writeFieldEnd()
6557 
    oprot.writeFieldStop()
6558 
    oprot.writeStructEnd()
6559 
 
3431 rajveer 6560 
  def validate(self):
6561 
    return
6562 
 
6563 
 
132 ashish 6564 
  def __repr__(self):
6565 
    L = ['%s=%r' % (key, value)
6566 
      for key, value in self.__dict__.iteritems()]
6567 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
6568 
 
6569 
  def __eq__(self, other):
6570 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
6571 
 
6572 
  def __ne__(self, other):
6573 
    return not (self == other)
6574 
 
94 ashish 6575 
class getTransactionStatus_args:
6576 
  """
6577 
  Attributes:
6578 
   - transactionId
6579 
  """
6580 
 
6581 
  thrift_spec = (
6582 
    None, # 0
6583 
    (1, TType.I64, 'transactionId', None, None, ), # 1
6584 
  )
6585 
 
6586 
  def __init__(self, transactionId=None,):
6587 
    self.transactionId = transactionId
6588 
 
6589 
  def read(self, iprot):
6590 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
6591 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
6592 
      return
6593 
    iprot.readStructBegin()
6594 
    while True:
6595 
      (fname, ftype, fid) = iprot.readFieldBegin()
6596 
      if ftype == TType.STOP:
6597 
        break
6598 
      if fid == 1:
6599 
        if ftype == TType.I64:
6600 
          self.transactionId = iprot.readI64();
6601 
        else:
6602 
          iprot.skip(ftype)
6603 
      else:
6604 
        iprot.skip(ftype)
6605 
      iprot.readFieldEnd()
6606 
    iprot.readStructEnd()
6607 
 
6608 
  def write(self, oprot):
6609 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
6610 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
6611 
      return
6612 
    oprot.writeStructBegin('getTransactionStatus_args')
3431 rajveer 6613 
    if self.transactionId is not None:
94 ashish 6614 
      oprot.writeFieldBegin('transactionId', TType.I64, 1)
6615 
      oprot.writeI64(self.transactionId)
6616 
      oprot.writeFieldEnd()
6617 
    oprot.writeFieldStop()
6618 
    oprot.writeStructEnd()
6619 
 
3431 rajveer 6620 
  def validate(self):
6621 
    return
6622 
 
6623 
 
94 ashish 6624 
  def __repr__(self):
6625 
    L = ['%s=%r' % (key, value)
6626 
      for key, value in self.__dict__.iteritems()]
6627 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
6628 
 
6629 
  def __eq__(self, other):
6630 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
6631 
 
6632 
  def __ne__(self, other):
6633 
    return not (self == other)
6634 
 
6635 
class getTransactionStatus_result:
6636 
  """
6637 
  Attributes:
6638 
   - success
6639 
   - ex
6640 
  """
6641 
 
6642 
  thrift_spec = (
6643 
    (0, TType.I32, 'success', None, None, ), # 0
6644 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
6645 
  )
6646 
 
6647 
  def __init__(self, success=None, ex=None,):
6648 
    self.success = success
6649 
    self.ex = ex
6650 
 
6651 
  def read(self, iprot):
6652 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
6653 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
6654 
      return
6655 
    iprot.readStructBegin()
6656 
    while True:
6657 
      (fname, ftype, fid) = iprot.readFieldBegin()
6658 
      if ftype == TType.STOP:
6659 
        break
6660 
      if fid == 0:
6661 
        if ftype == TType.I32:
6662 
          self.success = iprot.readI32();
6663 
        else:
6664 
          iprot.skip(ftype)
6665 
      elif fid == 1:
6666 
        if ftype == TType.STRUCT:
6667 
          self.ex = TransactionServiceException()
6668 
          self.ex.read(iprot)
6669 
        else:
6670 
          iprot.skip(ftype)
6671 
      else:
6672 
        iprot.skip(ftype)
6673 
      iprot.readFieldEnd()
6674 
    iprot.readStructEnd()
6675 
 
6676 
  def write(self, oprot):
6677 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
6678 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
6679 
      return
6680 
    oprot.writeStructBegin('getTransactionStatus_result')
3431 rajveer 6681 
    if self.success is not None:
94 ashish 6682 
      oprot.writeFieldBegin('success', TType.I32, 0)
6683 
      oprot.writeI32(self.success)
6684 
      oprot.writeFieldEnd()
3431 rajveer 6685 
    if self.ex is not None:
94 ashish 6686 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
6687 
      self.ex.write(oprot)
6688 
      oprot.writeFieldEnd()
6689 
    oprot.writeFieldStop()
6690 
    oprot.writeStructEnd()
6691 
 
3431 rajveer 6692 
  def validate(self):
6693 
    return
6694 
 
6695 
 
94 ashish 6696 
  def __repr__(self):
6697 
    L = ['%s=%r' % (key, value)
6698 
      for key, value in self.__dict__.iteritems()]
6699 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
6700 
 
6701 
  def __eq__(self, other):
6702 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
6703 
 
6704 
  def __ne__(self, other):
6705 
    return not (self == other)
6706 
 
6707 
class changeTransactionStatus_args:
6708 
  """
6709 
  Attributes:
6710 
   - transactionId
6711 
   - status
6712 
   - description
6713 
  """
6714 
 
6715 
  thrift_spec = (
6716 
    None, # 0
6717 
    (1, TType.I64, 'transactionId', None, None, ), # 1
6718 
    (2, TType.I32, 'status', None, None, ), # 2
6719 
    (3, TType.STRING, 'description', None, None, ), # 3
6720 
  )
6721 
 
6722 
  def __init__(self, transactionId=None, status=None, description=None,):
6723 
    self.transactionId = transactionId
6724 
    self.status = status
6725 
    self.description = description
6726 
 
6727 
  def read(self, iprot):
6728 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
6729 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
6730 
      return
6731 
    iprot.readStructBegin()
6732 
    while True:
6733 
      (fname, ftype, fid) = iprot.readFieldBegin()
6734 
      if ftype == TType.STOP:
6735 
        break
6736 
      if fid == 1:
6737 
        if ftype == TType.I64:
6738 
          self.transactionId = iprot.readI64();
6739 
        else:
6740 
          iprot.skip(ftype)
6741 
      elif fid == 2:
6742 
        if ftype == TType.I32:
6743 
          self.status = iprot.readI32();
6744 
        else:
6745 
          iprot.skip(ftype)
6746 
      elif fid == 3:
6747 
        if ftype == TType.STRING:
6748 
          self.description = iprot.readString();
6749 
        else:
6750 
          iprot.skip(ftype)
6751 
      else:
6752 
        iprot.skip(ftype)
6753 
      iprot.readFieldEnd()
6754 
    iprot.readStructEnd()
6755 
 
6756 
  def write(self, oprot):
6757 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
6758 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
6759 
      return
6760 
    oprot.writeStructBegin('changeTransactionStatus_args')
3431 rajveer 6761 
    if self.transactionId is not None:
94 ashish 6762 
      oprot.writeFieldBegin('transactionId', TType.I64, 1)
6763 
      oprot.writeI64(self.transactionId)
6764 
      oprot.writeFieldEnd()
3431 rajveer 6765 
    if self.status is not None:
94 ashish 6766 
      oprot.writeFieldBegin('status', TType.I32, 2)
6767 
      oprot.writeI32(self.status)
6768 
      oprot.writeFieldEnd()
3431 rajveer 6769 
    if self.description is not None:
94 ashish 6770 
      oprot.writeFieldBegin('description', TType.STRING, 3)
6771 
      oprot.writeString(self.description)
6772 
      oprot.writeFieldEnd()
6773 
    oprot.writeFieldStop()
6774 
    oprot.writeStructEnd()
6775 
 
3431 rajveer 6776 
  def validate(self):
6777 
    return
6778 
 
6779 
 
94 ashish 6780 
  def __repr__(self):
6781 
    L = ['%s=%r' % (key, value)
6782 
      for key, value in self.__dict__.iteritems()]
6783 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
6784 
 
6785 
  def __eq__(self, other):
6786 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
6787 
 
6788 
  def __ne__(self, other):
6789 
    return not (self == other)
6790 
 
6791 
class changeTransactionStatus_result:
6792 
  """
6793 
  Attributes:
6794 
   - success
6795 
   - ex
6796 
  """
6797 
 
6798 
  thrift_spec = (
6799 
    (0, TType.BOOL, 'success', None, None, ), # 0
6800 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
6801 
  )
6802 
 
6803 
  def __init__(self, success=None, ex=None,):
6804 
    self.success = success
6805 
    self.ex = ex
6806 
 
6807 
  def read(self, iprot):
6808 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
6809 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
6810 
      return
6811 
    iprot.readStructBegin()
6812 
    while True:
6813 
      (fname, ftype, fid) = iprot.readFieldBegin()
6814 
      if ftype == TType.STOP:
6815 
        break
6816 
      if fid == 0:
6817 
        if ftype == TType.BOOL:
6818 
          self.success = iprot.readBool();
6819 
        else:
6820 
          iprot.skip(ftype)
6821 
      elif fid == 1:
6822 
        if ftype == TType.STRUCT:
6823 
          self.ex = TransactionServiceException()
6824 
          self.ex.read(iprot)
6825 
        else:
6826 
          iprot.skip(ftype)
6827 
      else:
6828 
        iprot.skip(ftype)
6829 
      iprot.readFieldEnd()
6830 
    iprot.readStructEnd()
6831 
 
6832 
  def write(self, oprot):
6833 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
6834 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
6835 
      return
6836 
    oprot.writeStructBegin('changeTransactionStatus_result')
3431 rajveer 6837 
    if self.success is not None:
94 ashish 6838 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
6839 
      oprot.writeBool(self.success)
6840 
      oprot.writeFieldEnd()
3431 rajveer 6841 
    if self.ex is not None:
94 ashish 6842 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
6843 
      self.ex.write(oprot)
6844 
      oprot.writeFieldEnd()
6845 
    oprot.writeFieldStop()
6846 
    oprot.writeStructEnd()
6847 
 
3431 rajveer 6848 
  def validate(self):
6849 
    return
6850 
 
6851 
 
94 ashish 6852 
  def __repr__(self):
6853 
    L = ['%s=%r' % (key, value)
6854 
      for key, value in self.__dict__.iteritems()]
6855 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
6856 
 
6857 
  def __eq__(self, other):
6858 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
6859 
 
6860 
  def __ne__(self, other):
6861 
    return not (self == other)
6862 
 
1398 varun.gupt 6863 
class enqueueTransactionInfoEmail_args:
1382 varun.gupt 6864 
  """
6865 
  Attributes:
6866 
   - transactionId
6867 
  """
6868 
 
6869 
  thrift_spec = (
6870 
    None, # 0
6871 
    (1, TType.I64, 'transactionId', None, None, ), # 1
6872 
  )
6873 
 
6874 
  def __init__(self, transactionId=None,):
6875 
    self.transactionId = transactionId
6876 
 
6877 
  def read(self, iprot):
6878 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
6879 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
6880 
      return
6881 
    iprot.readStructBegin()
6882 
    while True:
6883 
      (fname, ftype, fid) = iprot.readFieldBegin()
6884 
      if ftype == TType.STOP:
6885 
        break
6886 
      if fid == 1:
6887 
        if ftype == TType.I64:
6888 
          self.transactionId = iprot.readI64();
6889 
        else:
6890 
          iprot.skip(ftype)
6891 
      else:
6892 
        iprot.skip(ftype)
6893 
      iprot.readFieldEnd()
6894 
    iprot.readStructEnd()
6895 
 
6896 
  def write(self, oprot):
6897 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
6898 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
6899 
      return
1398 varun.gupt 6900 
    oprot.writeStructBegin('enqueueTransactionInfoEmail_args')
3431 rajveer 6901 
    if self.transactionId is not None:
1382 varun.gupt 6902 
      oprot.writeFieldBegin('transactionId', TType.I64, 1)
6903 
      oprot.writeI64(self.transactionId)
6904 
      oprot.writeFieldEnd()
6905 
    oprot.writeFieldStop()
6906 
    oprot.writeStructEnd()
6907 
 
3431 rajveer 6908 
  def validate(self):
6909 
    return
6910 
 
6911 
 
1382 varun.gupt 6912 
  def __repr__(self):
6913 
    L = ['%s=%r' % (key, value)
6914 
      for key, value in self.__dict__.iteritems()]
6915 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
6916 
 
6917 
  def __eq__(self, other):
6918 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
6919 
 
6920 
  def __ne__(self, other):
6921 
    return not (self == other)
6922 
 
1398 varun.gupt 6923 
class enqueueTransactionInfoEmail_result:
1382 varun.gupt 6924 
  """
6925 
  Attributes:
6926 
   - success
6927 
   - ex
6928 
  """
6929 
 
6930 
  thrift_spec = (
6931 
    (0, TType.BOOL, 'success', None, None, ), # 0
6932 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
6933 
  )
6934 
 
6935 
  def __init__(self, success=None, ex=None,):
6936 
    self.success = success
6937 
    self.ex = ex
6938 
 
6939 
  def read(self, iprot):
6940 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
6941 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
6942 
      return
6943 
    iprot.readStructBegin()
6944 
    while True:
6945 
      (fname, ftype, fid) = iprot.readFieldBegin()
6946 
      if ftype == TType.STOP:
6947 
        break
6948 
      if fid == 0:
6949 
        if ftype == TType.BOOL:
6950 
          self.success = iprot.readBool();
6951 
        else:
6952 
          iprot.skip(ftype)
6953 
      elif fid == 1:
6954 
        if ftype == TType.STRUCT:
6955 
          self.ex = TransactionServiceException()
6956 
          self.ex.read(iprot)
6957 
        else:
6958 
          iprot.skip(ftype)
6959 
      else:
6960 
        iprot.skip(ftype)
6961 
      iprot.readFieldEnd()
6962 
    iprot.readStructEnd()
6963 
 
6964 
  def write(self, oprot):
6965 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
6966 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
6967 
      return
1398 varun.gupt 6968 
    oprot.writeStructBegin('enqueueTransactionInfoEmail_result')
3431 rajveer 6969 
    if self.success is not None:
1382 varun.gupt 6970 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
6971 
      oprot.writeBool(self.success)
6972 
      oprot.writeFieldEnd()
3431 rajveer 6973 
    if self.ex is not None:
1382 varun.gupt 6974 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
6975 
      self.ex.write(oprot)
6976 
      oprot.writeFieldEnd()
6977 
    oprot.writeFieldStop()
6978 
    oprot.writeStructEnd()
6979 
 
3431 rajveer 6980 
  def validate(self):
6981 
    return
6982 
 
6983 
 
1382 varun.gupt 6984 
  def __repr__(self):
6985 
    L = ['%s=%r' % (key, value)
6986 
      for key, value in self.__dict__.iteritems()]
6987 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
6988 
 
6989 
  def __eq__(self, other):
6990 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
6991 
 
6992 
  def __ne__(self, other):
6993 
    return not (self == other)
6994 
 
483 rajveer 6995 
class getAllOrders_args:
94 ashish 6996 
  """
6997 
  Attributes:
4801 anupam.sin 6998 
   - statuses
483 rajveer 6999 
   - from_date
7000 
   - to_date
7001 
   - warehouse_id
94 ashish 7002 
  """
7003 
 
7004 
  thrift_spec = (
7005 
    None, # 0
4801 anupam.sin 7006 
    (1, TType.LIST, 'statuses', (TType.I32,None), None, ), # 1
483 rajveer 7007 
    (2, TType.I64, 'from_date', None, None, ), # 2
7008 
    (3, TType.I64, 'to_date', None, None, ), # 3
7009 
    (4, TType.I64, 'warehouse_id', None, None, ), # 4
94 ashish 7010 
  )
7011 
 
4801 anupam.sin 7012 
  def __init__(self, statuses=None, from_date=None, to_date=None, warehouse_id=None,):
7013 
    self.statuses = statuses
483 rajveer 7014 
    self.from_date = from_date
7015 
    self.to_date = to_date
7016 
    self.warehouse_id = warehouse_id
94 ashish 7017 
 
7018 
  def read(self, iprot):
7019 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
7020 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
7021 
      return
7022 
    iprot.readStructBegin()
7023 
    while True:
7024 
      (fname, ftype, fid) = iprot.readFieldBegin()
7025 
      if ftype == TType.STOP:
7026 
        break
7027 
      if fid == 1:
4801 anupam.sin 7028 
        if ftype == TType.LIST:
7029 
          self.statuses = []
4837 varun.gupt 7030 
          (_etype59, _size56) = iprot.readListBegin()
7031 
          for _i60 in xrange(_size56):
7032 
            _elem61 = iprot.readI32();
7033 
            self.statuses.append(_elem61)
4801 anupam.sin 7034 
          iprot.readListEnd()
94 ashish 7035 
        else:
7036 
          iprot.skip(ftype)
483 rajveer 7037 
      elif fid == 2:
7038 
        if ftype == TType.I64:
7039 
          self.from_date = iprot.readI64();
94 ashish 7040 
        else:
7041 
          iprot.skip(ftype)
483 rajveer 7042 
      elif fid == 3:
7043 
        if ftype == TType.I64:
7044 
          self.to_date = iprot.readI64();
94 ashish 7045 
        else:
7046 
          iprot.skip(ftype)
483 rajveer 7047 
      elif fid == 4:
94 ashish 7048 
        if ftype == TType.I64:
483 rajveer 7049 
          self.warehouse_id = iprot.readI64();
94 ashish 7050 
        else:
7051 
          iprot.skip(ftype)
7052 
      else:
7053 
        iprot.skip(ftype)
7054 
      iprot.readFieldEnd()
7055 
    iprot.readStructEnd()
7056 
 
7057 
  def write(self, oprot):
7058 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
7059 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
7060 
      return
483 rajveer 7061 
    oprot.writeStructBegin('getAllOrders_args')
4801 anupam.sin 7062 
    if self.statuses is not None:
7063 
      oprot.writeFieldBegin('statuses', TType.LIST, 1)
7064 
      oprot.writeListBegin(TType.I32, len(self.statuses))
4837 varun.gupt 7065 
      for iter62 in self.statuses:
7066 
        oprot.writeI32(iter62)
4801 anupam.sin 7067 
      oprot.writeListEnd()
94 ashish 7068 
      oprot.writeFieldEnd()
3431 rajveer 7069 
    if self.from_date is not None:
483 rajveer 7070 
      oprot.writeFieldBegin('from_date', TType.I64, 2)
7071 
      oprot.writeI64(self.from_date)
94 ashish 7072 
      oprot.writeFieldEnd()
3431 rajveer 7073 
    if self.to_date is not None:
483 rajveer 7074 
      oprot.writeFieldBegin('to_date', TType.I64, 3)
7075 
      oprot.writeI64(self.to_date)
94 ashish 7076 
      oprot.writeFieldEnd()
3431 rajveer 7077 
    if self.warehouse_id is not None:
483 rajveer 7078 
      oprot.writeFieldBegin('warehouse_id', TType.I64, 4)
7079 
      oprot.writeI64(self.warehouse_id)
94 ashish 7080 
      oprot.writeFieldEnd()
7081 
    oprot.writeFieldStop()
7082 
    oprot.writeStructEnd()
7083 
 
3431 rajveer 7084 
  def validate(self):
7085 
    return
7086 
 
7087 
 
94 ashish 7088 
  def __repr__(self):
7089 
    L = ['%s=%r' % (key, value)
7090 
      for key, value in self.__dict__.iteritems()]
7091 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
7092 
 
7093 
  def __eq__(self, other):
7094 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
7095 
 
7096 
  def __ne__(self, other):
7097 
    return not (self == other)
7098 
 
483 rajveer 7099 
class getAllOrders_result:
94 ashish 7100 
  """
7101 
  Attributes:
7102 
   - success
7103 
   - ex
7104 
  """
7105 
 
7106 
  thrift_spec = (
483 rajveer 7107 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
94 ashish 7108 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
7109 
  )
7110 
 
7111 
  def __init__(self, success=None, ex=None,):
7112 
    self.success = success
7113 
    self.ex = ex
7114 
 
7115 
  def read(self, iprot):
7116 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
7117 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
7118 
      return
7119 
    iprot.readStructBegin()
7120 
    while True:
7121 
      (fname, ftype, fid) = iprot.readFieldBegin()
7122 
      if ftype == TType.STOP:
7123 
        break
7124 
      if fid == 0:
483 rajveer 7125 
        if ftype == TType.LIST:
7126 
          self.success = []
4837 varun.gupt 7127 
          (_etype66, _size63) = iprot.readListBegin()
7128 
          for _i67 in xrange(_size63):
7129 
            _elem68 = Order()
7130 
            _elem68.read(iprot)
7131 
            self.success.append(_elem68)
483 rajveer 7132 
          iprot.readListEnd()
94 ashish 7133 
        else:
7134 
          iprot.skip(ftype)
7135 
      elif fid == 1:
7136 
        if ftype == TType.STRUCT:
7137 
          self.ex = TransactionServiceException()
7138 
          self.ex.read(iprot)
7139 
        else:
7140 
          iprot.skip(ftype)
7141 
      else:
7142 
        iprot.skip(ftype)
7143 
      iprot.readFieldEnd()
7144 
    iprot.readStructEnd()
7145 
 
7146 
  def write(self, oprot):
7147 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
7148 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
7149 
      return
483 rajveer 7150 
    oprot.writeStructBegin('getAllOrders_result')
3431 rajveer 7151 
    if self.success is not None:
483 rajveer 7152 
      oprot.writeFieldBegin('success', TType.LIST, 0)
7153 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
4837 varun.gupt 7154 
      for iter69 in self.success:
7155 
        iter69.write(oprot)
483 rajveer 7156 
      oprot.writeListEnd()
94 ashish 7157 
      oprot.writeFieldEnd()
3431 rajveer 7158 
    if self.ex is not None:
94 ashish 7159 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
7160 
      self.ex.write(oprot)
7161 
      oprot.writeFieldEnd()
7162 
    oprot.writeFieldStop()
7163 
    oprot.writeStructEnd()
7164 
 
3431 rajveer 7165 
  def validate(self):
7166 
    return
7167 
 
7168 
 
94 ashish 7169 
  def __repr__(self):
7170 
    L = ['%s=%r' % (key, value)
7171 
      for key, value in self.__dict__.iteritems()]
7172 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
7173 
 
7174 
  def __eq__(self, other):
7175 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
7176 
 
7177 
  def __ne__(self, other):
7178 
    return not (self == other)
7179 
 
4133 chandransh 7180 
class getOrdersInBatch_args:
7181 
  """
7182 
  Attributes:
7183 
   - statuses
7184 
   - offset
7185 
   - limit
7186 
   - warehouse_id
7187 
  """
7188 
 
7189 
  thrift_spec = (
7190 
    None, # 0
7191 
    (1, TType.LIST, 'statuses', (TType.I32,None), None, ), # 1
7192 
    (2, TType.I64, 'offset', None, None, ), # 2
7193 
    (3, TType.I64, 'limit', None, None, ), # 3
7194 
    (4, TType.I64, 'warehouse_id', None, None, ), # 4
7195 
  )
7196 
 
7197 
  def __init__(self, statuses=None, offset=None, limit=None, warehouse_id=None,):
7198 
    self.statuses = statuses
7199 
    self.offset = offset
7200 
    self.limit = limit
7201 
    self.warehouse_id = warehouse_id
7202 
 
7203 
  def read(self, iprot):
7204 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
7205 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
7206 
      return
7207 
    iprot.readStructBegin()
7208 
    while True:
7209 
      (fname, ftype, fid) = iprot.readFieldBegin()
7210 
      if ftype == TType.STOP:
7211 
        break
7212 
      if fid == 1:
7213 
        if ftype == TType.LIST:
7214 
          self.statuses = []
4837 varun.gupt 7215 
          (_etype73, _size70) = iprot.readListBegin()
7216 
          for _i74 in xrange(_size70):
7217 
            _elem75 = iprot.readI32();
7218 
            self.statuses.append(_elem75)
4133 chandransh 7219 
          iprot.readListEnd()
7220 
        else:
7221 
          iprot.skip(ftype)
7222 
      elif fid == 2:
7223 
        if ftype == TType.I64:
7224 
          self.offset = iprot.readI64();
7225 
        else:
7226 
          iprot.skip(ftype)
7227 
      elif fid == 3:
7228 
        if ftype == TType.I64:
7229 
          self.limit = iprot.readI64();
7230 
        else:
7231 
          iprot.skip(ftype)
7232 
      elif fid == 4:
7233 
        if ftype == TType.I64:
7234 
          self.warehouse_id = iprot.readI64();
7235 
        else:
7236 
          iprot.skip(ftype)
7237 
      else:
7238 
        iprot.skip(ftype)
7239 
      iprot.readFieldEnd()
7240 
    iprot.readStructEnd()
7241 
 
7242 
  def write(self, oprot):
7243 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
7244 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
7245 
      return
7246 
    oprot.writeStructBegin('getOrdersInBatch_args')
7247 
    if self.statuses is not None:
7248 
      oprot.writeFieldBegin('statuses', TType.LIST, 1)
7249 
      oprot.writeListBegin(TType.I32, len(self.statuses))
4837 varun.gupt 7250 
      for iter76 in self.statuses:
7251 
        oprot.writeI32(iter76)
4133 chandransh 7252 
      oprot.writeListEnd()
7253 
      oprot.writeFieldEnd()
7254 
    if self.offset is not None:
7255 
      oprot.writeFieldBegin('offset', TType.I64, 2)
7256 
      oprot.writeI64(self.offset)
7257 
      oprot.writeFieldEnd()
7258 
    if self.limit is not None:
7259 
      oprot.writeFieldBegin('limit', TType.I64, 3)
7260 
      oprot.writeI64(self.limit)
7261 
      oprot.writeFieldEnd()
7262 
    if self.warehouse_id is not None:
7263 
      oprot.writeFieldBegin('warehouse_id', TType.I64, 4)
7264 
      oprot.writeI64(self.warehouse_id)
7265 
      oprot.writeFieldEnd()
7266 
    oprot.writeFieldStop()
7267 
    oprot.writeStructEnd()
7268 
 
7269 
  def validate(self):
7270 
    return
7271 
 
7272 
 
7273 
  def __repr__(self):
7274 
    L = ['%s=%r' % (key, value)
7275 
      for key, value in self.__dict__.iteritems()]
7276 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
7277 
 
7278 
  def __eq__(self, other):
7279 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
7280 
 
7281 
  def __ne__(self, other):
7282 
    return not (self == other)
7283 
 
7284 
class getOrdersInBatch_result:
7285 
  """
7286 
  Attributes:
7287 
   - success
7288 
   - ex
7289 
  """
7290 
 
7291 
  thrift_spec = (
7292 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
7293 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
7294 
  )
7295 
 
7296 
  def __init__(self, success=None, ex=None,):
7297 
    self.success = success
7298 
    self.ex = ex
7299 
 
7300 
  def read(self, iprot):
7301 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
7302 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
7303 
      return
7304 
    iprot.readStructBegin()
7305 
    while True:
7306 
      (fname, ftype, fid) = iprot.readFieldBegin()
7307 
      if ftype == TType.STOP:
7308 
        break
7309 
      if fid == 0:
7310 
        if ftype == TType.LIST:
7311 
          self.success = []
4837 varun.gupt 7312 
          (_etype80, _size77) = iprot.readListBegin()
7313 
          for _i81 in xrange(_size77):
7314 
            _elem82 = Order()
7315 
            _elem82.read(iprot)
7316 
            self.success.append(_elem82)
4133 chandransh 7317 
          iprot.readListEnd()
7318 
        else:
7319 
          iprot.skip(ftype)
7320 
      elif fid == 1:
7321 
        if ftype == TType.STRUCT:
7322 
          self.ex = TransactionServiceException()
7323 
          self.ex.read(iprot)
7324 
        else:
7325 
          iprot.skip(ftype)
7326 
      else:
7327 
        iprot.skip(ftype)
7328 
      iprot.readFieldEnd()
7329 
    iprot.readStructEnd()
7330 
 
7331 
  def write(self, oprot):
7332 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
7333 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
7334 
      return
7335 
    oprot.writeStructBegin('getOrdersInBatch_result')
7336 
    if self.success is not None:
7337 
      oprot.writeFieldBegin('success', TType.LIST, 0)
7338 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
4837 varun.gupt 7339 
      for iter83 in self.success:
7340 
        iter83.write(oprot)
4133 chandransh 7341 
      oprot.writeListEnd()
7342 
      oprot.writeFieldEnd()
7343 
    if self.ex is not None:
7344 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
7345 
      self.ex.write(oprot)
7346 
      oprot.writeFieldEnd()
7347 
    oprot.writeFieldStop()
7348 
    oprot.writeStructEnd()
7349 
 
7350 
  def validate(self):
7351 
    return
7352 
 
7353 
 
7354 
  def __repr__(self):
7355 
    L = ['%s=%r' % (key, value)
7356 
      for key, value in self.__dict__.iteritems()]
7357 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
7358 
 
7359 
  def __eq__(self, other):
7360 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
7361 
 
7362 
  def __ne__(self, other):
7363 
    return not (self == other)
7364 
 
7365 
class getOrderCount_args:
7366 
  """
7367 
  Attributes:
7368 
   - statuses
7369 
   - warehouseId
7370 
  """
7371 
 
7372 
  thrift_spec = (
7373 
    None, # 0
7374 
    (1, TType.LIST, 'statuses', (TType.I32,None), None, ), # 1
7375 
    (2, TType.I64, 'warehouseId', None, None, ), # 2
7376 
  )
7377 
 
7378 
  def __init__(self, statuses=None, warehouseId=None,):
7379 
    self.statuses = statuses
7380 
    self.warehouseId = warehouseId
7381 
 
7382 
  def read(self, iprot):
7383 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
7384 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
7385 
      return
7386 
    iprot.readStructBegin()
7387 
    while True:
7388 
      (fname, ftype, fid) = iprot.readFieldBegin()
7389 
      if ftype == TType.STOP:
7390 
        break
7391 
      if fid == 1:
7392 
        if ftype == TType.LIST:
7393 
          self.statuses = []
4837 varun.gupt 7394 
          (_etype87, _size84) = iprot.readListBegin()
7395 
          for _i88 in xrange(_size84):
7396 
            _elem89 = iprot.readI32();
7397 
            self.statuses.append(_elem89)
4133 chandransh 7398 
          iprot.readListEnd()
7399 
        else:
7400 
          iprot.skip(ftype)
7401 
      elif fid == 2:
7402 
        if ftype == TType.I64:
7403 
          self.warehouseId = iprot.readI64();
7404 
        else:
7405 
          iprot.skip(ftype)
7406 
      else:
7407 
        iprot.skip(ftype)
7408 
      iprot.readFieldEnd()
7409 
    iprot.readStructEnd()
7410 
 
7411 
  def write(self, oprot):
7412 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
7413 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
7414 
      return
7415 
    oprot.writeStructBegin('getOrderCount_args')
7416 
    if self.statuses is not None:
7417 
      oprot.writeFieldBegin('statuses', TType.LIST, 1)
7418 
      oprot.writeListBegin(TType.I32, len(self.statuses))
4837 varun.gupt 7419 
      for iter90 in self.statuses:
7420 
        oprot.writeI32(iter90)
4133 chandransh 7421 
      oprot.writeListEnd()
7422 
      oprot.writeFieldEnd()
7423 
    if self.warehouseId is not None:
7424 
      oprot.writeFieldBegin('warehouseId', TType.I64, 2)
7425 
      oprot.writeI64(self.warehouseId)
7426 
      oprot.writeFieldEnd()
7427 
    oprot.writeFieldStop()
7428 
    oprot.writeStructEnd()
7429 
 
7430 
  def validate(self):
7431 
    return
7432 
 
7433 
 
7434 
  def __repr__(self):
7435 
    L = ['%s=%r' % (key, value)
7436 
      for key, value in self.__dict__.iteritems()]
7437 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
7438 
 
7439 
  def __eq__(self, other):
7440 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
7441 
 
7442 
  def __ne__(self, other):
7443 
    return not (self == other)
7444 
 
7445 
class getOrderCount_result:
7446 
  """
7447 
  Attributes:
7448 
   - success
7449 
   - ex
7450 
  """
7451 
 
7452 
  thrift_spec = (
7453 
    (0, TType.I32, 'success', None, None, ), # 0
7454 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
7455 
  )
7456 
 
7457 
  def __init__(self, success=None, ex=None,):
7458 
    self.success = success
7459 
    self.ex = ex
7460 
 
7461 
  def read(self, iprot):
7462 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
7463 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
7464 
      return
7465 
    iprot.readStructBegin()
7466 
    while True:
7467 
      (fname, ftype, fid) = iprot.readFieldBegin()
7468 
      if ftype == TType.STOP:
7469 
        break
7470 
      if fid == 0:
7471 
        if ftype == TType.I32:
7472 
          self.success = iprot.readI32();
7473 
        else:
7474 
          iprot.skip(ftype)
7475 
      elif fid == 1:
7476 
        if ftype == TType.STRUCT:
7477 
          self.ex = TransactionServiceException()
7478 
          self.ex.read(iprot)
7479 
        else:
7480 
          iprot.skip(ftype)
7481 
      else:
7482 
        iprot.skip(ftype)
7483 
      iprot.readFieldEnd()
7484 
    iprot.readStructEnd()
7485 
 
7486 
  def write(self, oprot):
7487 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
7488 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
7489 
      return
7490 
    oprot.writeStructBegin('getOrderCount_result')
7491 
    if self.success is not None:
7492 
      oprot.writeFieldBegin('success', TType.I32, 0)
7493 
      oprot.writeI32(self.success)
7494 
      oprot.writeFieldEnd()
7495 
    if self.ex is not None:
7496 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
7497 
      self.ex.write(oprot)
7498 
      oprot.writeFieldEnd()
7499 
    oprot.writeFieldStop()
7500 
    oprot.writeStructEnd()
7501 
 
7502 
  def validate(self):
7503 
    return
7504 
 
7505 
 
7506 
  def __repr__(self):
7507 
    L = ['%s=%r' % (key, value)
7508 
      for key, value in self.__dict__.iteritems()]
7509 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
7510 
 
7511 
  def __eq__(self, other):
7512 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
7513 
 
7514 
  def __ne__(self, other):
7515 
    return not (self == other)
7516 
 
999 varun.gupt 7517 
class getOrdersByBillingDate_args:
7518 
  """
7519 
  Attributes:
7520 
   - status
7521 
   - start_billing_date
7522 
   - end_billing_date
7523 
   - warehouse_id
7524 
  """
7525 
 
7526 
  thrift_spec = (
7527 
    None, # 0
7528 
    (1, TType.I32, 'status', None, None, ), # 1
7529 
    (2, TType.I64, 'start_billing_date', None, None, ), # 2
7530 
    (3, TType.I64, 'end_billing_date', None, None, ), # 3
7531 
    (4, TType.I64, 'warehouse_id', None, None, ), # 4
7532 
  )
7533 
 
7534 
  def __init__(self, status=None, start_billing_date=None, end_billing_date=None, warehouse_id=None,):
7535 
    self.status = status
7536 
    self.start_billing_date = start_billing_date
7537 
    self.end_billing_date = end_billing_date
7538 
    self.warehouse_id = warehouse_id
7539 
 
7540 
  def read(self, iprot):
7541 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
7542 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
7543 
      return
7544 
    iprot.readStructBegin()
7545 
    while True:
7546 
      (fname, ftype, fid) = iprot.readFieldBegin()
7547 
      if ftype == TType.STOP:
7548 
        break
7549 
      if fid == 1:
7550 
        if ftype == TType.I32:
7551 
          self.status = iprot.readI32();
7552 
        else:
7553 
          iprot.skip(ftype)
7554 
      elif fid == 2:
7555 
        if ftype == TType.I64:
7556 
          self.start_billing_date = iprot.readI64();
7557 
        else:
7558 
          iprot.skip(ftype)
7559 
      elif fid == 3:
7560 
        if ftype == TType.I64:
7561 
          self.end_billing_date = iprot.readI64();
7562 
        else:
7563 
          iprot.skip(ftype)
7564 
      elif fid == 4:
7565 
        if ftype == TType.I64:
7566 
          self.warehouse_id = iprot.readI64();
7567 
        else:
7568 
          iprot.skip(ftype)
7569 
      else:
7570 
        iprot.skip(ftype)
7571 
      iprot.readFieldEnd()
7572 
    iprot.readStructEnd()
7573 
 
7574 
  def write(self, oprot):
7575 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
7576 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
7577 
      return
7578 
    oprot.writeStructBegin('getOrdersByBillingDate_args')
3431 rajveer 7579 
    if self.status is not None:
999 varun.gupt 7580 
      oprot.writeFieldBegin('status', TType.I32, 1)
7581 
      oprot.writeI32(self.status)
7582 
      oprot.writeFieldEnd()
3431 rajveer 7583 
    if self.start_billing_date is not None:
999 varun.gupt 7584 
      oprot.writeFieldBegin('start_billing_date', TType.I64, 2)
7585 
      oprot.writeI64(self.start_billing_date)
7586 
      oprot.writeFieldEnd()
3431 rajveer 7587 
    if self.end_billing_date is not None:
999 varun.gupt 7588 
      oprot.writeFieldBegin('end_billing_date', TType.I64, 3)
7589 
      oprot.writeI64(self.end_billing_date)
7590 
      oprot.writeFieldEnd()
3431 rajveer 7591 
    if self.warehouse_id is not None:
999 varun.gupt 7592 
      oprot.writeFieldBegin('warehouse_id', TType.I64, 4)
7593 
      oprot.writeI64(self.warehouse_id)
7594 
      oprot.writeFieldEnd()
7595 
    oprot.writeFieldStop()
7596 
    oprot.writeStructEnd()
7597 
 
3431 rajveer 7598 
  def validate(self):
7599 
    return
7600 
 
7601 
 
999 varun.gupt 7602 
  def __repr__(self):
7603 
    L = ['%s=%r' % (key, value)
7604 
      for key, value in self.__dict__.iteritems()]
7605 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
7606 
 
7607 
  def __eq__(self, other):
7608 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
7609 
 
7610 
  def __ne__(self, other):
7611 
    return not (self == other)
7612 
 
7613 
class getOrdersByBillingDate_result:
7614 
  """
7615 
  Attributes:
7616 
   - success
7617 
   - ex
7618 
  """
7619 
 
7620 
  thrift_spec = (
7621 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
7622 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
7623 
  )
7624 
 
7625 
  def __init__(self, success=None, ex=None,):
7626 
    self.success = success
7627 
    self.ex = ex
7628 
 
7629 
  def read(self, iprot):
7630 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
7631 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
7632 
      return
7633 
    iprot.readStructBegin()
7634 
    while True:
7635 
      (fname, ftype, fid) = iprot.readFieldBegin()
7636 
      if ftype == TType.STOP:
7637 
        break
7638 
      if fid == 0:
7639 
        if ftype == TType.LIST:
7640 
          self.success = []
4837 varun.gupt 7641 
          (_etype94, _size91) = iprot.readListBegin()
7642 
          for _i95 in xrange(_size91):
7643 
            _elem96 = Order()
7644 
            _elem96.read(iprot)
7645 
            self.success.append(_elem96)
999 varun.gupt 7646 
          iprot.readListEnd()
7647 
        else:
7648 
          iprot.skip(ftype)
7649 
      elif fid == 1:
7650 
        if ftype == TType.STRUCT:
7651 
          self.ex = TransactionServiceException()
7652 
          self.ex.read(iprot)
7653 
        else:
7654 
          iprot.skip(ftype)
7655 
      else:
7656 
        iprot.skip(ftype)
7657 
      iprot.readFieldEnd()
7658 
    iprot.readStructEnd()
7659 
 
7660 
  def write(self, oprot):
7661 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
7662 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
7663 
      return
7664 
    oprot.writeStructBegin('getOrdersByBillingDate_result')
3431 rajveer 7665 
    if self.success is not None:
999 varun.gupt 7666 
      oprot.writeFieldBegin('success', TType.LIST, 0)
7667 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
4837 varun.gupt 7668 
      for iter97 in self.success:
7669 
        iter97.write(oprot)
999 varun.gupt 7670 
      oprot.writeListEnd()
7671 
      oprot.writeFieldEnd()
3431 rajveer 7672 
    if self.ex is not None:
999 varun.gupt 7673 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
7674 
      self.ex.write(oprot)
7675 
      oprot.writeFieldEnd()
7676 
    oprot.writeFieldStop()
7677 
    oprot.writeStructEnd()
7678 
 
3431 rajveer 7679 
  def validate(self):
7680 
    return
7681 
 
7682 
 
999 varun.gupt 7683 
  def __repr__(self):
7684 
    L = ['%s=%r' % (key, value)
7685 
      for key, value in self.__dict__.iteritems()]
7686 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
7687 
 
7688 
  def __eq__(self, other):
7689 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
7690 
 
7691 
  def __ne__(self, other):
7692 
    return not (self == other)
7693 
 
3427 chandransh 7694 
class getOrdersByShippingDate_args:
7695 
  """
7696 
  Attributes:
7697 
   - fromShippingDate
7698 
   - toShippingDate
7699 
   - providerId
7700 
   - warehouseId
3451 chandransh 7701 
   - cod
3427 chandransh 7702 
  """
7703 
 
7704 
  thrift_spec = (
7705 
    None, # 0
7706 
    (1, TType.I64, 'fromShippingDate', None, None, ), # 1
7707 
    (2, TType.I64, 'toShippingDate', None, None, ), # 2
7708 
    (3, TType.I64, 'providerId', None, None, ), # 3
7709 
    (4, TType.I64, 'warehouseId', None, None, ), # 4
3451 chandransh 7710 
    (5, TType.BOOL, 'cod', None, None, ), # 5
3427 chandransh 7711 
  )
7712 
 
3451 chandransh 7713 
  def __init__(self, fromShippingDate=None, toShippingDate=None, providerId=None, warehouseId=None, cod=None,):
3427 chandransh 7714 
    self.fromShippingDate = fromShippingDate
7715 
    self.toShippingDate = toShippingDate
7716 
    self.providerId = providerId
7717 
    self.warehouseId = warehouseId
3451 chandransh 7718 
    self.cod = cod
3427 chandransh 7719 
 
7720 
  def read(self, iprot):
7721 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
7722 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
7723 
      return
7724 
    iprot.readStructBegin()
7725 
    while True:
7726 
      (fname, ftype, fid) = iprot.readFieldBegin()
7727 
      if ftype == TType.STOP:
7728 
        break
7729 
      if fid == 1:
7730 
        if ftype == TType.I64:
7731 
          self.fromShippingDate = iprot.readI64();
7732 
        else:
7733 
          iprot.skip(ftype)
7734 
      elif fid == 2:
7735 
        if ftype == TType.I64:
7736 
          self.toShippingDate = iprot.readI64();
7737 
        else:
7738 
          iprot.skip(ftype)
7739 
      elif fid == 3:
7740 
        if ftype == TType.I64:
7741 
          self.providerId = iprot.readI64();
7742 
        else:
7743 
          iprot.skip(ftype)
7744 
      elif fid == 4:
7745 
        if ftype == TType.I64:
7746 
          self.warehouseId = iprot.readI64();
7747 
        else:
7748 
          iprot.skip(ftype)
3451 chandransh 7749 
      elif fid == 5:
7750 
        if ftype == TType.BOOL:
7751 
          self.cod = iprot.readBool();
7752 
        else:
7753 
          iprot.skip(ftype)
3427 chandransh 7754 
      else:
7755 
        iprot.skip(ftype)
7756 
      iprot.readFieldEnd()
7757 
    iprot.readStructEnd()
7758 
 
7759 
  def write(self, oprot):
7760 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
7761 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
7762 
      return
7763 
    oprot.writeStructBegin('getOrdersByShippingDate_args')
3431 rajveer 7764 
    if self.fromShippingDate is not None:
3427 chandransh 7765 
      oprot.writeFieldBegin('fromShippingDate', TType.I64, 1)
7766 
      oprot.writeI64(self.fromShippingDate)
7767 
      oprot.writeFieldEnd()
3431 rajveer 7768 
    if self.toShippingDate is not None:
3427 chandransh 7769 
      oprot.writeFieldBegin('toShippingDate', TType.I64, 2)
7770 
      oprot.writeI64(self.toShippingDate)
7771 
      oprot.writeFieldEnd()
3431 rajveer 7772 
    if self.providerId is not None:
3427 chandransh 7773 
      oprot.writeFieldBegin('providerId', TType.I64, 3)
7774 
      oprot.writeI64(self.providerId)
7775 
      oprot.writeFieldEnd()
3431 rajveer 7776 
    if self.warehouseId is not None:
3427 chandransh 7777 
      oprot.writeFieldBegin('warehouseId', TType.I64, 4)
7778 
      oprot.writeI64(self.warehouseId)
7779 
      oprot.writeFieldEnd()
3451 chandransh 7780 
    if self.cod is not None:
7781 
      oprot.writeFieldBegin('cod', TType.BOOL, 5)
7782 
      oprot.writeBool(self.cod)
7783 
      oprot.writeFieldEnd()
3427 chandransh 7784 
    oprot.writeFieldStop()
7785 
    oprot.writeStructEnd()
7786 
 
3431 rajveer 7787 
  def validate(self):
7788 
    return
7789 
 
7790 
 
3427 chandransh 7791 
  def __repr__(self):
7792 
    L = ['%s=%r' % (key, value)
7793 
      for key, value in self.__dict__.iteritems()]
7794 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
7795 
 
7796 
  def __eq__(self, other):
7797 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
7798 
 
7799 
  def __ne__(self, other):
7800 
    return not (self == other)
7801 
 
7802 
class getOrdersByShippingDate_result:
7803 
  """
7804 
  Attributes:
7805 
   - success
7806 
   - ex
7807 
  """
7808 
 
7809 
  thrift_spec = (
7810 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
7811 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
7812 
  )
7813 
 
7814 
  def __init__(self, success=None, ex=None,):
7815 
    self.success = success
7816 
    self.ex = ex
7817 
 
7818 
  def read(self, iprot):
7819 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
7820 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
7821 
      return
7822 
    iprot.readStructBegin()
7823 
    while True:
7824 
      (fname, ftype, fid) = iprot.readFieldBegin()
7825 
      if ftype == TType.STOP:
7826 
        break
7827 
      if fid == 0:
7828 
        if ftype == TType.LIST:
7829 
          self.success = []
4837 varun.gupt 7830 
          (_etype101, _size98) = iprot.readListBegin()
7831 
          for _i102 in xrange(_size98):
7832 
            _elem103 = Order()
7833 
            _elem103.read(iprot)
7834 
            self.success.append(_elem103)
3427 chandransh 7835 
          iprot.readListEnd()
7836 
        else:
7837 
          iprot.skip(ftype)
7838 
      elif fid == 1:
7839 
        if ftype == TType.STRUCT:
7840 
          self.ex = TransactionServiceException()
7841 
          self.ex.read(iprot)
7842 
        else:
7843 
          iprot.skip(ftype)
7844 
      else:
7845 
        iprot.skip(ftype)
7846 
      iprot.readFieldEnd()
7847 
    iprot.readStructEnd()
7848 
 
7849 
  def write(self, oprot):
7850 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
7851 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
7852 
      return
7853 
    oprot.writeStructBegin('getOrdersByShippingDate_result')
3431 rajveer 7854 
    if self.success is not None:
3427 chandransh 7855 
      oprot.writeFieldBegin('success', TType.LIST, 0)
7856 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
4837 varun.gupt 7857 
      for iter104 in self.success:
7858 
        iter104.write(oprot)
3427 chandransh 7859 
      oprot.writeListEnd()
7860 
      oprot.writeFieldEnd()
3431 rajveer 7861 
    if self.ex is not None:
3427 chandransh 7862 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
7863 
      self.ex.write(oprot)
7864 
      oprot.writeFieldEnd()
7865 
    oprot.writeFieldStop()
7866 
    oprot.writeStructEnd()
7867 
 
3431 rajveer 7868 
  def validate(self):
7869 
    return
7870 
 
7871 
 
3427 chandransh 7872 
  def __repr__(self):
7873 
    L = ['%s=%r' % (key, value)
7874 
      for key, value in self.__dict__.iteritems()]
7875 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
7876 
 
7877 
  def __eq__(self, other):
7878 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
7879 
 
7880 
  def __ne__(self, other):
7881 
    return not (self == other)
7882 
 
1382 varun.gupt 7883 
class getReturnableOrdersForCustomer_args:
7884 
  """
7885 
  Attributes:
7886 
   - customer_id
7887 
   - limit
7888 
  """
7889 
 
7890 
  thrift_spec = (
7891 
    None, # 0
7892 
    (1, TType.I64, 'customer_id', None, None, ), # 1
7893 
    (2, TType.I64, 'limit', None, None, ), # 2
7894 
  )
7895 
 
7896 
  def __init__(self, customer_id=None, limit=None,):
7897 
    self.customer_id = customer_id
7898 
    self.limit = limit
7899 
 
7900 
  def read(self, iprot):
7901 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
7902 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
7903 
      return
7904 
    iprot.readStructBegin()
7905 
    while True:
7906 
      (fname, ftype, fid) = iprot.readFieldBegin()
7907 
      if ftype == TType.STOP:
7908 
        break
7909 
      if fid == 1:
7910 
        if ftype == TType.I64:
7911 
          self.customer_id = iprot.readI64();
7912 
        else:
7913 
          iprot.skip(ftype)
7914 
      elif fid == 2:
7915 
        if ftype == TType.I64:
7916 
          self.limit = iprot.readI64();
7917 
        else:
7918 
          iprot.skip(ftype)
7919 
      else:
7920 
        iprot.skip(ftype)
7921 
      iprot.readFieldEnd()
7922 
    iprot.readStructEnd()
7923 
 
7924 
  def write(self, oprot):
7925 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
7926 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
7927 
      return
7928 
    oprot.writeStructBegin('getReturnableOrdersForCustomer_args')
3431 rajveer 7929 
    if self.customer_id is not None:
1382 varun.gupt 7930 
      oprot.writeFieldBegin('customer_id', TType.I64, 1)
7931 
      oprot.writeI64(self.customer_id)
7932 
      oprot.writeFieldEnd()
3431 rajveer 7933 
    if self.limit is not None:
1382 varun.gupt 7934 
      oprot.writeFieldBegin('limit', TType.I64, 2)
7935 
      oprot.writeI64(self.limit)
7936 
      oprot.writeFieldEnd()
7937 
    oprot.writeFieldStop()
7938 
    oprot.writeStructEnd()
7939 
 
3431 rajveer 7940 
  def validate(self):
7941 
    return
7942 
 
7943 
 
1382 varun.gupt 7944 
  def __repr__(self):
7945 
    L = ['%s=%r' % (key, value)
7946 
      for key, value in self.__dict__.iteritems()]
7947 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
7948 
 
7949 
  def __eq__(self, other):
7950 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
7951 
 
7952 
  def __ne__(self, other):
7953 
    return not (self == other)
7954 
 
7955 
class getReturnableOrdersForCustomer_result:
7956 
  """
7957 
  Attributes:
7958 
   - success
7959 
   - ex
7960 
  """
7961 
 
7962 
  thrift_spec = (
7963 
    (0, TType.LIST, 'success', (TType.I64,None), None, ), # 0
7964 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
7965 
  )
7966 
 
7967 
  def __init__(self, success=None, ex=None,):
7968 
    self.success = success
7969 
    self.ex = ex
7970 
 
7971 
  def read(self, iprot):
7972 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
7973 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
7974 
      return
7975 
    iprot.readStructBegin()
7976 
    while True:
7977 
      (fname, ftype, fid) = iprot.readFieldBegin()
7978 
      if ftype == TType.STOP:
7979 
        break
7980 
      if fid == 0:
7981 
        if ftype == TType.LIST:
7982 
          self.success = []
4837 varun.gupt 7983 
          (_etype108, _size105) = iprot.readListBegin()
7984 
          for _i109 in xrange(_size105):
7985 
            _elem110 = iprot.readI64();
7986 
            self.success.append(_elem110)
1382 varun.gupt 7987 
          iprot.readListEnd()
7988 
        else:
7989 
          iprot.skip(ftype)
7990 
      elif fid == 1:
7991 
        if ftype == TType.STRUCT:
7992 
          self.ex = TransactionServiceException()
7993 
          self.ex.read(iprot)
7994 
        else:
7995 
          iprot.skip(ftype)
7996 
      else:
7997 
        iprot.skip(ftype)
7998 
      iprot.readFieldEnd()
7999 
    iprot.readStructEnd()
8000 
 
8001 
  def write(self, oprot):
8002 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8003 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8004 
      return
8005 
    oprot.writeStructBegin('getReturnableOrdersForCustomer_result')
3431 rajveer 8006 
    if self.success is not None:
1382 varun.gupt 8007 
      oprot.writeFieldBegin('success', TType.LIST, 0)
8008 
      oprot.writeListBegin(TType.I64, len(self.success))
4837 varun.gupt 8009 
      for iter111 in self.success:
8010 
        oprot.writeI64(iter111)
1382 varun.gupt 8011 
      oprot.writeListEnd()
8012 
      oprot.writeFieldEnd()
3431 rajveer 8013 
    if self.ex is not None:
1382 varun.gupt 8014 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
8015 
      self.ex.write(oprot)
8016 
      oprot.writeFieldEnd()
8017 
    oprot.writeFieldStop()
8018 
    oprot.writeStructEnd()
8019 
 
3431 rajveer 8020 
  def validate(self):
8021 
    return
8022 
 
8023 
 
1382 varun.gupt 8024 
  def __repr__(self):
8025 
    L = ['%s=%r' % (key, value)
8026 
      for key, value in self.__dict__.iteritems()]
8027 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8028 
 
8029 
  def __eq__(self, other):
8030 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8031 
 
8032 
  def __ne__(self, other):
8033 
    return not (self == other)
8034 
 
8035 
class getCancellableOrdersForCustomer_args:
8036 
  """
8037 
  Attributes:
8038 
   - customer_id
8039 
   - limit
8040 
  """
8041 
 
8042 
  thrift_spec = (
8043 
    None, # 0
8044 
    (1, TType.I64, 'customer_id', None, None, ), # 1
8045 
    (2, TType.I64, 'limit', None, None, ), # 2
8046 
  )
8047 
 
8048 
  def __init__(self, customer_id=None, limit=None,):
8049 
    self.customer_id = customer_id
8050 
    self.limit = limit
8051 
 
8052 
  def read(self, iprot):
8053 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8054 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8055 
      return
8056 
    iprot.readStructBegin()
8057 
    while True:
8058 
      (fname, ftype, fid) = iprot.readFieldBegin()
8059 
      if ftype == TType.STOP:
8060 
        break
8061 
      if fid == 1:
8062 
        if ftype == TType.I64:
8063 
          self.customer_id = iprot.readI64();
8064 
        else:
8065 
          iprot.skip(ftype)
8066 
      elif fid == 2:
8067 
        if ftype == TType.I64:
8068 
          self.limit = iprot.readI64();
8069 
        else:
8070 
          iprot.skip(ftype)
8071 
      else:
8072 
        iprot.skip(ftype)
8073 
      iprot.readFieldEnd()
8074 
    iprot.readStructEnd()
8075 
 
8076 
  def write(self, oprot):
8077 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8078 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8079 
      return
8080 
    oprot.writeStructBegin('getCancellableOrdersForCustomer_args')
3431 rajveer 8081 
    if self.customer_id is not None:
1382 varun.gupt 8082 
      oprot.writeFieldBegin('customer_id', TType.I64, 1)
8083 
      oprot.writeI64(self.customer_id)
8084 
      oprot.writeFieldEnd()
3431 rajveer 8085 
    if self.limit is not None:
1382 varun.gupt 8086 
      oprot.writeFieldBegin('limit', TType.I64, 2)
8087 
      oprot.writeI64(self.limit)
8088 
      oprot.writeFieldEnd()
8089 
    oprot.writeFieldStop()
8090 
    oprot.writeStructEnd()
8091 
 
3431 rajveer 8092 
  def validate(self):
8093 
    return
8094 
 
8095 
 
1382 varun.gupt 8096 
  def __repr__(self):
8097 
    L = ['%s=%r' % (key, value)
8098 
      for key, value in self.__dict__.iteritems()]
8099 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8100 
 
8101 
  def __eq__(self, other):
8102 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8103 
 
8104 
  def __ne__(self, other):
8105 
    return not (self == other)
8106 
 
8107 
class getCancellableOrdersForCustomer_result:
8108 
  """
8109 
  Attributes:
8110 
   - success
8111 
   - ex
8112 
  """
8113 
 
8114 
  thrift_spec = (
8115 
    (0, TType.LIST, 'success', (TType.I64,None), None, ), # 0
8116 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
8117 
  )
8118 
 
8119 
  def __init__(self, success=None, ex=None,):
8120 
    self.success = success
8121 
    self.ex = ex
8122 
 
8123 
  def read(self, iprot):
8124 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8125 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8126 
      return
8127 
    iprot.readStructBegin()
8128 
    while True:
8129 
      (fname, ftype, fid) = iprot.readFieldBegin()
8130 
      if ftype == TType.STOP:
8131 
        break
8132 
      if fid == 0:
8133 
        if ftype == TType.LIST:
8134 
          self.success = []
4837 varun.gupt 8135 
          (_etype115, _size112) = iprot.readListBegin()
8136 
          for _i116 in xrange(_size112):
8137 
            _elem117 = iprot.readI64();
8138 
            self.success.append(_elem117)
1382 varun.gupt 8139 
          iprot.readListEnd()
8140 
        else:
8141 
          iprot.skip(ftype)
8142 
      elif fid == 1:
8143 
        if ftype == TType.STRUCT:
8144 
          self.ex = TransactionServiceException()
8145 
          self.ex.read(iprot)
8146 
        else:
8147 
          iprot.skip(ftype)
8148 
      else:
8149 
        iprot.skip(ftype)
8150 
      iprot.readFieldEnd()
8151 
    iprot.readStructEnd()
8152 
 
8153 
  def write(self, oprot):
8154 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8155 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8156 
      return
8157 
    oprot.writeStructBegin('getCancellableOrdersForCustomer_result')
3431 rajveer 8158 
    if self.success is not None:
1382 varun.gupt 8159 
      oprot.writeFieldBegin('success', TType.LIST, 0)
8160 
      oprot.writeListBegin(TType.I64, len(self.success))
4837 varun.gupt 8161 
      for iter118 in self.success:
8162 
        oprot.writeI64(iter118)
1382 varun.gupt 8163 
      oprot.writeListEnd()
8164 
      oprot.writeFieldEnd()
3431 rajveer 8165 
    if self.ex is not None:
1382 varun.gupt 8166 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
8167 
      self.ex.write(oprot)
8168 
      oprot.writeFieldEnd()
8169 
    oprot.writeFieldStop()
8170 
    oprot.writeStructEnd()
8171 
 
3431 rajveer 8172 
  def validate(self):
8173 
    return
8174 
 
8175 
 
1382 varun.gupt 8176 
  def __repr__(self):
8177 
    L = ['%s=%r' % (key, value)
8178 
      for key, value in self.__dict__.iteritems()]
8179 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8180 
 
8181 
  def __eq__(self, other):
8182 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8183 
 
8184 
  def __ne__(self, other):
8185 
    return not (self == other)
8186 
 
483 rajveer 8187 
class changeOrderStatus_args:
94 ashish 8188 
  """
8189 
  Attributes:
483 rajveer 8190 
   - orderId
8191 
   - status
8192 
   - description
94 ashish 8193 
  """
8194 
 
8195 
  thrift_spec = (
8196 
    None, # 0
483 rajveer 8197 
    (1, TType.I64, 'orderId', None, None, ), # 1
8198 
    (2, TType.I32, 'status', None, None, ), # 2
8199 
    (3, TType.STRING, 'description', None, None, ), # 3
94 ashish 8200 
  )
8201 
 
483 rajveer 8202 
  def __init__(self, orderId=None, status=None, description=None,):
8203 
    self.orderId = orderId
8204 
    self.status = status
8205 
    self.description = description
94 ashish 8206 
 
8207 
  def read(self, iprot):
8208 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8209 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8210 
      return
8211 
    iprot.readStructBegin()
8212 
    while True:
8213 
      (fname, ftype, fid) = iprot.readFieldBegin()
8214 
      if ftype == TType.STOP:
8215 
        break
8216 
      if fid == 1:
8217 
        if ftype == TType.I64:
483 rajveer 8218 
          self.orderId = iprot.readI64();
94 ashish 8219 
        else:
8220 
          iprot.skip(ftype)
8221 
      elif fid == 2:
483 rajveer 8222 
        if ftype == TType.I32:
8223 
          self.status = iprot.readI32();
94 ashish 8224 
        else:
8225 
          iprot.skip(ftype)
483 rajveer 8226 
      elif fid == 3:
8227 
        if ftype == TType.STRING:
8228 
          self.description = iprot.readString();
8229 
        else:
8230 
          iprot.skip(ftype)
94 ashish 8231 
      else:
8232 
        iprot.skip(ftype)
8233 
      iprot.readFieldEnd()
8234 
    iprot.readStructEnd()
8235 
 
8236 
  def write(self, oprot):
8237 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8238 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8239 
      return
483 rajveer 8240 
    oprot.writeStructBegin('changeOrderStatus_args')
3431 rajveer 8241 
    if self.orderId is not None:
483 rajveer 8242 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
8243 
      oprot.writeI64(self.orderId)
94 ashish 8244 
      oprot.writeFieldEnd()
3431 rajveer 8245 
    if self.status is not None:
483 rajveer 8246 
      oprot.writeFieldBegin('status', TType.I32, 2)
8247 
      oprot.writeI32(self.status)
94 ashish 8248 
      oprot.writeFieldEnd()
3431 rajveer 8249 
    if self.description is not None:
483 rajveer 8250 
      oprot.writeFieldBegin('description', TType.STRING, 3)
8251 
      oprot.writeString(self.description)
8252 
      oprot.writeFieldEnd()
94 ashish 8253 
    oprot.writeFieldStop()
8254 
    oprot.writeStructEnd()
8255 
 
3431 rajveer 8256 
  def validate(self):
8257 
    return
8258 
 
8259 
 
94 ashish 8260 
  def __repr__(self):
8261 
    L = ['%s=%r' % (key, value)
8262 
      for key, value in self.__dict__.iteritems()]
8263 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8264 
 
8265 
  def __eq__(self, other):
8266 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8267 
 
8268 
  def __ne__(self, other):
8269 
    return not (self == other)
8270 
 
483 rajveer 8271 
class changeOrderStatus_result:
94 ashish 8272 
  """
8273 
  Attributes:
8274 
   - success
8275 
   - ex
8276 
  """
8277 
 
8278 
  thrift_spec = (
8279 
    (0, TType.BOOL, 'success', None, None, ), # 0
8280 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
8281 
  )
8282 
 
8283 
  def __init__(self, success=None, ex=None,):
8284 
    self.success = success
8285 
    self.ex = ex
8286 
 
8287 
  def read(self, iprot):
8288 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8289 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8290 
      return
8291 
    iprot.readStructBegin()
8292 
    while True:
8293 
      (fname, ftype, fid) = iprot.readFieldBegin()
8294 
      if ftype == TType.STOP:
8295 
        break
8296 
      if fid == 0:
8297 
        if ftype == TType.BOOL:
8298 
          self.success = iprot.readBool();
8299 
        else:
8300 
          iprot.skip(ftype)
8301 
      elif fid == 1:
8302 
        if ftype == TType.STRUCT:
8303 
          self.ex = TransactionServiceException()
8304 
          self.ex.read(iprot)
8305 
        else:
8306 
          iprot.skip(ftype)
8307 
      else:
8308 
        iprot.skip(ftype)
8309 
      iprot.readFieldEnd()
8310 
    iprot.readStructEnd()
8311 
 
8312 
  def write(self, oprot):
8313 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8314 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8315 
      return
483 rajveer 8316 
    oprot.writeStructBegin('changeOrderStatus_result')
3431 rajveer 8317 
    if self.success is not None:
94 ashish 8318 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
8319 
      oprot.writeBool(self.success)
8320 
      oprot.writeFieldEnd()
3431 rajveer 8321 
    if self.ex is not None:
94 ashish 8322 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
8323 
      self.ex.write(oprot)
8324 
      oprot.writeFieldEnd()
8325 
    oprot.writeFieldStop()
8326 
    oprot.writeStructEnd()
8327 
 
3431 rajveer 8328 
  def validate(self):
8329 
    return
8330 
 
8331 
 
94 ashish 8332 
  def __repr__(self):
8333 
    L = ['%s=%r' % (key, value)
8334 
      for key, value in self.__dict__.iteritems()]
8335 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8336 
 
8337 
  def __eq__(self, other):
8338 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8339 
 
8340 
  def __ne__(self, other):
8341 
    return not (self == other)
8342 
 
3064 chandransh 8343 
class getOrdersForTransaction_args:
494 rajveer 8344 
  """
8345 
  Attributes:
3064 chandransh 8346 
   - transactionId
8347 
   - customerId
494 rajveer 8348 
  """
8349 
 
8350 
  thrift_spec = (
8351 
    None, # 0
3064 chandransh 8352 
    (1, TType.I64, 'transactionId', None, None, ), # 1
8353 
    (2, TType.I64, 'customerId', None, None, ), # 2
494 rajveer 8354 
  )
8355 
 
3064 chandransh 8356 
  def __init__(self, transactionId=None, customerId=None,):
8357 
    self.transactionId = transactionId
8358 
    self.customerId = customerId
494 rajveer 8359 
 
8360 
  def read(self, iprot):
8361 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8362 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8363 
      return
8364 
    iprot.readStructBegin()
8365 
    while True:
8366 
      (fname, ftype, fid) = iprot.readFieldBegin()
8367 
      if ftype == TType.STOP:
8368 
        break
8369 
      if fid == 1:
8370 
        if ftype == TType.I64:
3064 chandransh 8371 
          self.transactionId = iprot.readI64();
494 rajveer 8372 
        else:
8373 
          iprot.skip(ftype)
8374 
      elif fid == 2:
3064 chandransh 8375 
        if ftype == TType.I64:
8376 
          self.customerId = iprot.readI64();
494 rajveer 8377 
        else:
8378 
          iprot.skip(ftype)
8379 
      else:
8380 
        iprot.skip(ftype)
8381 
      iprot.readFieldEnd()
8382 
    iprot.readStructEnd()
8383 
 
8384 
  def write(self, oprot):
8385 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8386 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8387 
      return
3064 chandransh 8388 
    oprot.writeStructBegin('getOrdersForTransaction_args')
3431 rajveer 8389 
    if self.transactionId is not None:
3064 chandransh 8390 
      oprot.writeFieldBegin('transactionId', TType.I64, 1)
8391 
      oprot.writeI64(self.transactionId)
494 rajveer 8392 
      oprot.writeFieldEnd()
3431 rajveer 8393 
    if self.customerId is not None:
3064 chandransh 8394 
      oprot.writeFieldBegin('customerId', TType.I64, 2)
8395 
      oprot.writeI64(self.customerId)
494 rajveer 8396 
      oprot.writeFieldEnd()
8397 
    oprot.writeFieldStop()
8398 
    oprot.writeStructEnd()
8399 
 
3431 rajveer 8400 
  def validate(self):
8401 
    return
8402 
 
8403 
 
494 rajveer 8404 
  def __repr__(self):
8405 
    L = ['%s=%r' % (key, value)
8406 
      for key, value in self.__dict__.iteritems()]
8407 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8408 
 
8409 
  def __eq__(self, other):
8410 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8411 
 
8412 
  def __ne__(self, other):
8413 
    return not (self == other)
8414 
 
3064 chandransh 8415 
class getOrdersForTransaction_result:
494 rajveer 8416 
  """
8417 
  Attributes:
8418 
   - success
8419 
   - ex
8420 
  """
8421 
 
8422 
  thrift_spec = (
3064 chandransh 8423 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
494 rajveer 8424 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
8425 
  )
8426 
 
8427 
  def __init__(self, success=None, ex=None,):
8428 
    self.success = success
8429 
    self.ex = ex
8430 
 
8431 
  def read(self, iprot):
8432 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8433 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8434 
      return
8435 
    iprot.readStructBegin()
8436 
    while True:
8437 
      (fname, ftype, fid) = iprot.readFieldBegin()
8438 
      if ftype == TType.STOP:
8439 
        break
8440 
      if fid == 0:
3064 chandransh 8441 
        if ftype == TType.LIST:
8442 
          self.success = []
4837 varun.gupt 8443 
          (_etype122, _size119) = iprot.readListBegin()
8444 
          for _i123 in xrange(_size119):
8445 
            _elem124 = Order()
8446 
            _elem124.read(iprot)
8447 
            self.success.append(_elem124)
3064 chandransh 8448 
          iprot.readListEnd()
494 rajveer 8449 
        else:
8450 
          iprot.skip(ftype)
8451 
      elif fid == 1:
8452 
        if ftype == TType.STRUCT:
8453 
          self.ex = TransactionServiceException()
8454 
          self.ex.read(iprot)
8455 
        else:
8456 
          iprot.skip(ftype)
8457 
      else:
8458 
        iprot.skip(ftype)
8459 
      iprot.readFieldEnd()
8460 
    iprot.readStructEnd()
8461 
 
8462 
  def write(self, oprot):
8463 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8464 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8465 
      return
3064 chandransh 8466 
    oprot.writeStructBegin('getOrdersForTransaction_result')
3431 rajveer 8467 
    if self.success is not None:
3064 chandransh 8468 
      oprot.writeFieldBegin('success', TType.LIST, 0)
8469 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
4837 varun.gupt 8470 
      for iter125 in self.success:
8471 
        iter125.write(oprot)
3064 chandransh 8472 
      oprot.writeListEnd()
494 rajveer 8473 
      oprot.writeFieldEnd()
3431 rajveer 8474 
    if self.ex is not None:
494 rajveer 8475 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
8476 
      self.ex.write(oprot)
8477 
      oprot.writeFieldEnd()
8478 
    oprot.writeFieldStop()
8479 
    oprot.writeStructEnd()
8480 
 
3431 rajveer 8481 
  def validate(self):
8482 
    return
8483 
 
8484 
 
494 rajveer 8485 
  def __repr__(self):
8486 
    L = ['%s=%r' % (key, value)
8487 
      for key, value in self.__dict__.iteritems()]
8488 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8489 
 
8490 
  def __eq__(self, other):
8491 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8492 
 
8493 
  def __ne__(self, other):
8494 
    return not (self == other)
8495 
 
3064 chandransh 8496 
class getOrdersForCustomer_args:
1149 chandransh 8497 
  """
8498 
  Attributes:
3064 chandransh 8499 
   - customerId
8500 
   - from_date
8501 
   - to_date
8502 
   - statuses
1149 chandransh 8503 
  """
8504 
 
8505 
  thrift_spec = (
8506 
    None, # 0
3064 chandransh 8507 
    (1, TType.I64, 'customerId', None, None, ), # 1
8508 
    (2, TType.I64, 'from_date', None, None, ), # 2
8509 
    (3, TType.I64, 'to_date', None, None, ), # 3
8510 
    (4, TType.LIST, 'statuses', (TType.I32,None), None, ), # 4
1149 chandransh 8511 
  )
8512 
 
3064 chandransh 8513 
  def __init__(self, customerId=None, from_date=None, to_date=None, statuses=None,):
8514 
    self.customerId = customerId
8515 
    self.from_date = from_date
8516 
    self.to_date = to_date
8517 
    self.statuses = statuses
1149 chandransh 8518 
 
8519 
  def read(self, iprot):
8520 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8521 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8522 
      return
8523 
    iprot.readStructBegin()
8524 
    while True:
8525 
      (fname, ftype, fid) = iprot.readFieldBegin()
8526 
      if ftype == TType.STOP:
8527 
        break
8528 
      if fid == 1:
8529 
        if ftype == TType.I64:
3064 chandransh 8530 
          self.customerId = iprot.readI64();
1149 chandransh 8531 
        else:
8532 
          iprot.skip(ftype)
8533 
      elif fid == 2:
8534 
        if ftype == TType.I64:
3064 chandransh 8535 
          self.from_date = iprot.readI64();
1149 chandransh 8536 
        else:
8537 
          iprot.skip(ftype)
2783 chandransh 8538 
      elif fid == 3:
8539 
        if ftype == TType.I64:
3064 chandransh 8540 
          self.to_date = iprot.readI64();
2783 chandransh 8541 
        else:
8542 
          iprot.skip(ftype)
8543 
      elif fid == 4:
3064 chandransh 8544 
        if ftype == TType.LIST:
8545 
          self.statuses = []
4837 varun.gupt 8546 
          (_etype129, _size126) = iprot.readListBegin()
8547 
          for _i130 in xrange(_size126):
8548 
            _elem131 = iprot.readI32();
8549 
            self.statuses.append(_elem131)
3064 chandransh 8550 
          iprot.readListEnd()
2783 chandransh 8551 
        else:
8552 
          iprot.skip(ftype)
1149 chandransh 8553 
      else:
8554 
        iprot.skip(ftype)
8555 
      iprot.readFieldEnd()
8556 
    iprot.readStructEnd()
8557 
 
8558 
  def write(self, oprot):
8559 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8560 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8561 
      return
3064 chandransh 8562 
    oprot.writeStructBegin('getOrdersForCustomer_args')
3431 rajveer 8563 
    if self.customerId is not None:
3064 chandransh 8564 
      oprot.writeFieldBegin('customerId', TType.I64, 1)
8565 
      oprot.writeI64(self.customerId)
1149 chandransh 8566 
      oprot.writeFieldEnd()
3431 rajveer 8567 
    if self.from_date is not None:
3064 chandransh 8568 
      oprot.writeFieldBegin('from_date', TType.I64, 2)
8569 
      oprot.writeI64(self.from_date)
1149 chandransh 8570 
      oprot.writeFieldEnd()
3431 rajveer 8571 
    if self.to_date is not None:
3064 chandransh 8572 
      oprot.writeFieldBegin('to_date', TType.I64, 3)
8573 
      oprot.writeI64(self.to_date)
2783 chandransh 8574 
      oprot.writeFieldEnd()
3431 rajveer 8575 
    if self.statuses is not None:
3064 chandransh 8576 
      oprot.writeFieldBegin('statuses', TType.LIST, 4)
8577 
      oprot.writeListBegin(TType.I32, len(self.statuses))
4837 varun.gupt 8578 
      for iter132 in self.statuses:
8579 
        oprot.writeI32(iter132)
3064 chandransh 8580 
      oprot.writeListEnd()
2783 chandransh 8581 
      oprot.writeFieldEnd()
1149 chandransh 8582 
    oprot.writeFieldStop()
8583 
    oprot.writeStructEnd()
8584 
 
3431 rajveer 8585 
  def validate(self):
8586 
    return
8587 
 
8588 
 
1149 chandransh 8589 
  def __repr__(self):
8590 
    L = ['%s=%r' % (key, value)
8591 
      for key, value in self.__dict__.iteritems()]
8592 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8593 
 
8594 
  def __eq__(self, other):
8595 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8596 
 
8597 
  def __ne__(self, other):
8598 
    return not (self == other)
8599 
 
3064 chandransh 8600 
class getOrdersForCustomer_result:
1149 chandransh 8601 
  """
8602 
  Attributes:
8603 
   - success
8604 
   - ex
8605 
  """
8606 
 
8607 
  thrift_spec = (
3064 chandransh 8608 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
1149 chandransh 8609 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
8610 
  )
8611 
 
8612 
  def __init__(self, success=None, ex=None,):
8613 
    self.success = success
8614 
    self.ex = ex
8615 
 
8616 
  def read(self, iprot):
8617 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8618 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8619 
      return
8620 
    iprot.readStructBegin()
8621 
    while True:
8622 
      (fname, ftype, fid) = iprot.readFieldBegin()
8623 
      if ftype == TType.STOP:
8624 
        break
8625 
      if fid == 0:
3064 chandransh 8626 
        if ftype == TType.LIST:
8627 
          self.success = []
4837 varun.gupt 8628 
          (_etype136, _size133) = iprot.readListBegin()
8629 
          for _i137 in xrange(_size133):
8630 
            _elem138 = Order()
8631 
            _elem138.read(iprot)
8632 
            self.success.append(_elem138)
3064 chandransh 8633 
          iprot.readListEnd()
1149 chandransh 8634 
        else:
8635 
          iprot.skip(ftype)
8636 
      elif fid == 1:
8637 
        if ftype == TType.STRUCT:
8638 
          self.ex = TransactionServiceException()
8639 
          self.ex.read(iprot)
8640 
        else:
8641 
          iprot.skip(ftype)
8642 
      else:
8643 
        iprot.skip(ftype)
8644 
      iprot.readFieldEnd()
8645 
    iprot.readStructEnd()
8646 
 
8647 
  def write(self, oprot):
8648 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8649 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8650 
      return
3064 chandransh 8651 
    oprot.writeStructBegin('getOrdersForCustomer_result')
3431 rajveer 8652 
    if self.success is not None:
3064 chandransh 8653 
      oprot.writeFieldBegin('success', TType.LIST, 0)
8654 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
4837 varun.gupt 8655 
      for iter139 in self.success:
8656 
        iter139.write(oprot)
3064 chandransh 8657 
      oprot.writeListEnd()
1149 chandransh 8658 
      oprot.writeFieldEnd()
3431 rajveer 8659 
    if self.ex is not None:
1149 chandransh 8660 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
8661 
      self.ex.write(oprot)
8662 
      oprot.writeFieldEnd()
8663 
    oprot.writeFieldStop()
8664 
    oprot.writeStructEnd()
8665 
 
3431 rajveer 8666 
  def validate(self):
8667 
    return
8668 
 
8669 
 
1149 chandransh 8670 
  def __repr__(self):
8671 
    L = ['%s=%r' % (key, value)
8672 
      for key, value in self.__dict__.iteritems()]
8673 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8674 
 
8675 
  def __eq__(self, other):
8676 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8677 
 
8678 
  def __ne__(self, other):
8679 
    return not (self == other)
8680 
 
3064 chandransh 8681 
class createOrder_args:
921 rajveer 8682 
  """
8683 
  Attributes:
3064 chandransh 8684 
   - order
921 rajveer 8685 
  """
8686 
 
8687 
  thrift_spec = (
8688 
    None, # 0
3064 chandransh 8689 
    (1, TType.STRUCT, 'order', (Order, Order.thrift_spec), None, ), # 1
921 rajveer 8690 
  )
8691 
 
3064 chandransh 8692 
  def __init__(self, order=None,):
8693 
    self.order = order
921 rajveer 8694 
 
8695 
  def read(self, iprot):
8696 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8697 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8698 
      return
8699 
    iprot.readStructBegin()
8700 
    while True:
8701 
      (fname, ftype, fid) = iprot.readFieldBegin()
8702 
      if ftype == TType.STOP:
8703 
        break
8704 
      if fid == 1:
3064 chandransh 8705 
        if ftype == TType.STRUCT:
8706 
          self.order = Order()
8707 
          self.order.read(iprot)
921 rajveer 8708 
        else:
8709 
          iprot.skip(ftype)
8710 
      else:
8711 
        iprot.skip(ftype)
8712 
      iprot.readFieldEnd()
8713 
    iprot.readStructEnd()
8714 
 
8715 
  def write(self, oprot):
8716 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8717 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8718 
      return
3064 chandransh 8719 
    oprot.writeStructBegin('createOrder_args')
3431 rajveer 8720 
    if self.order is not None:
3064 chandransh 8721 
      oprot.writeFieldBegin('order', TType.STRUCT, 1)
8722 
      self.order.write(oprot)
921 rajveer 8723 
      oprot.writeFieldEnd()
8724 
    oprot.writeFieldStop()
8725 
    oprot.writeStructEnd()
8726 
 
3431 rajveer 8727 
  def validate(self):
8728 
    return
8729 
 
8730 
 
921 rajveer 8731 
  def __repr__(self):
8732 
    L = ['%s=%r' % (key, value)
8733 
      for key, value in self.__dict__.iteritems()]
8734 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8735 
 
8736 
  def __eq__(self, other):
8737 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8738 
 
8739 
  def __ne__(self, other):
8740 
    return not (self == other)
8741 
 
3064 chandransh 8742 
class createOrder_result:
921 rajveer 8743 
  """
8744 
  Attributes:
8745 
   - success
8746 
   - ex
8747 
  """
8748 
 
8749 
  thrift_spec = (
3064 chandransh 8750 
    (0, TType.I64, 'success', None, None, ), # 0
921 rajveer 8751 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
8752 
  )
8753 
 
8754 
  def __init__(self, success=None, ex=None,):
8755 
    self.success = success
8756 
    self.ex = ex
8757 
 
8758 
  def read(self, iprot):
8759 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8760 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8761 
      return
8762 
    iprot.readStructBegin()
8763 
    while True:
8764 
      (fname, ftype, fid) = iprot.readFieldBegin()
8765 
      if ftype == TType.STOP:
8766 
        break
8767 
      if fid == 0:
3064 chandransh 8768 
        if ftype == TType.I64:
8769 
          self.success = iprot.readI64();
921 rajveer 8770 
        else:
8771 
          iprot.skip(ftype)
8772 
      elif fid == 1:
8773 
        if ftype == TType.STRUCT:
8774 
          self.ex = TransactionServiceException()
8775 
          self.ex.read(iprot)
8776 
        else:
8777 
          iprot.skip(ftype)
8778 
      else:
8779 
        iprot.skip(ftype)
8780 
      iprot.readFieldEnd()
8781 
    iprot.readStructEnd()
8782 
 
8783 
  def write(self, oprot):
8784 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8785 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8786 
      return
3064 chandransh 8787 
    oprot.writeStructBegin('createOrder_result')
3431 rajveer 8788 
    if self.success is not None:
3064 chandransh 8789 
      oprot.writeFieldBegin('success', TType.I64, 0)
8790 
      oprot.writeI64(self.success)
921 rajveer 8791 
      oprot.writeFieldEnd()
3431 rajveer 8792 
    if self.ex is not None:
921 rajveer 8793 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
8794 
      self.ex.write(oprot)
8795 
      oprot.writeFieldEnd()
8796 
    oprot.writeFieldStop()
8797 
    oprot.writeStructEnd()
8798 
 
3431 rajveer 8799 
  def validate(self):
8800 
    return
8801 
 
8802 
 
921 rajveer 8803 
  def __repr__(self):
8804 
    L = ['%s=%r' % (key, value)
8805 
      for key, value in self.__dict__.iteritems()]
8806 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8807 
 
8808 
  def __eq__(self, other):
8809 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8810 
 
8811 
  def __ne__(self, other):
8812 
    return not (self == other)
8813 
 
3064 chandransh 8814 
class getOrder_args:
921 rajveer 8815 
  """
8816 
  Attributes:
3064 chandransh 8817 
   - id
921 rajveer 8818 
  """
8819 
 
8820 
  thrift_spec = (
8821 
    None, # 0
3064 chandransh 8822 
    (1, TType.I64, 'id', None, None, ), # 1
921 rajveer 8823 
  )
8824 
 
3064 chandransh 8825 
  def __init__(self, id=None,):
8826 
    self.id = id
921 rajveer 8827 
 
8828 
  def read(self, iprot):
8829 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8830 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8831 
      return
8832 
    iprot.readStructBegin()
8833 
    while True:
8834 
      (fname, ftype, fid) = iprot.readFieldBegin()
8835 
      if ftype == TType.STOP:
8836 
        break
8837 
      if fid == 1:
8838 
        if ftype == TType.I64:
3064 chandransh 8839 
          self.id = iprot.readI64();
921 rajveer 8840 
        else:
8841 
          iprot.skip(ftype)
8842 
      else:
8843 
        iprot.skip(ftype)
8844 
      iprot.readFieldEnd()
8845 
    iprot.readStructEnd()
8846 
 
8847 
  def write(self, oprot):
8848 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8849 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8850 
      return
3064 chandransh 8851 
    oprot.writeStructBegin('getOrder_args')
3431 rajveer 8852 
    if self.id is not None:
3064 chandransh 8853 
      oprot.writeFieldBegin('id', TType.I64, 1)
8854 
      oprot.writeI64(self.id)
921 rajveer 8855 
      oprot.writeFieldEnd()
8856 
    oprot.writeFieldStop()
8857 
    oprot.writeStructEnd()
8858 
 
3431 rajveer 8859 
  def validate(self):
8860 
    return
8861 
 
8862 
 
921 rajveer 8863 
  def __repr__(self):
8864 
    L = ['%s=%r' % (key, value)
8865 
      for key, value in self.__dict__.iteritems()]
8866 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8867 
 
8868 
  def __eq__(self, other):
8869 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8870 
 
8871 
  def __ne__(self, other):
8872 
    return not (self == other)
8873 
 
3064 chandransh 8874 
class getOrder_result:
921 rajveer 8875 
  """
8876 
  Attributes:
8877 
   - success
8878 
   - ex
8879 
  """
8880 
 
8881 
  thrift_spec = (
3064 chandransh 8882 
    (0, TType.STRUCT, 'success', (Order, Order.thrift_spec), None, ), # 0
921 rajveer 8883 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
8884 
  )
8885 
 
8886 
  def __init__(self, success=None, ex=None,):
8887 
    self.success = success
8888 
    self.ex = ex
8889 
 
8890 
  def read(self, iprot):
8891 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8892 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8893 
      return
8894 
    iprot.readStructBegin()
8895 
    while True:
8896 
      (fname, ftype, fid) = iprot.readFieldBegin()
8897 
      if ftype == TType.STOP:
8898 
        break
8899 
      if fid == 0:
3064 chandransh 8900 
        if ftype == TType.STRUCT:
8901 
          self.success = Order()
8902 
          self.success.read(iprot)
921 rajveer 8903 
        else:
8904 
          iprot.skip(ftype)
8905 
      elif fid == 1:
8906 
        if ftype == TType.STRUCT:
8907 
          self.ex = TransactionServiceException()
8908 
          self.ex.read(iprot)
8909 
        else:
8910 
          iprot.skip(ftype)
8911 
      else:
8912 
        iprot.skip(ftype)
8913 
      iprot.readFieldEnd()
8914 
    iprot.readStructEnd()
8915 
 
8916 
  def write(self, oprot):
8917 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8918 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8919 
      return
3064 chandransh 8920 
    oprot.writeStructBegin('getOrder_result')
3431 rajveer 8921 
    if self.success is not None:
3064 chandransh 8922 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
8923 
      self.success.write(oprot)
921 rajveer 8924 
      oprot.writeFieldEnd()
3431 rajveer 8925 
    if self.ex is not None:
921 rajveer 8926 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
8927 
      self.ex.write(oprot)
8928 
      oprot.writeFieldEnd()
8929 
    oprot.writeFieldStop()
8930 
    oprot.writeStructEnd()
8931 
 
3431 rajveer 8932 
  def validate(self):
8933 
    return
8934 
 
8935 
 
921 rajveer 8936 
  def __repr__(self):
8937 
    L = ['%s=%r' % (key, value)
8938 
      for key, value in self.__dict__.iteritems()]
8939 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8940 
 
8941 
  def __eq__(self, other):
8942 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8943 
 
8944 
  def __ne__(self, other):
8945 
    return not (self == other)
8946 
 
3064 chandransh 8947 
class getLineItemsForOrder_args:
94 ashish 8948 
  """
8949 
  Attributes:
3064 chandransh 8950 
   - orderId
94 ashish 8951 
  """
8952 
 
8953 
  thrift_spec = (
8954 
    None, # 0
3064 chandransh 8955 
    (1, TType.I64, 'orderId', None, None, ), # 1
94 ashish 8956 
  )
8957 
 
3064 chandransh 8958 
  def __init__(self, orderId=None,):
8959 
    self.orderId = orderId
94 ashish 8960 
 
8961 
  def read(self, iprot):
8962 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8963 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8964 
      return
8965 
    iprot.readStructBegin()
8966 
    while True:
8967 
      (fname, ftype, fid) = iprot.readFieldBegin()
8968 
      if ftype == TType.STOP:
8969 
        break
8970 
      if fid == 1:
8971 
        if ftype == TType.I64:
3064 chandransh 8972 
          self.orderId = iprot.readI64();
94 ashish 8973 
        else:
8974 
          iprot.skip(ftype)
8975 
      else:
8976 
        iprot.skip(ftype)
8977 
      iprot.readFieldEnd()
8978 
    iprot.readStructEnd()
8979 
 
8980 
  def write(self, oprot):
8981 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8982 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8983 
      return
3064 chandransh 8984 
    oprot.writeStructBegin('getLineItemsForOrder_args')
3431 rajveer 8985 
    if self.orderId is not None:
3064 chandransh 8986 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
8987 
      oprot.writeI64(self.orderId)
94 ashish 8988 
      oprot.writeFieldEnd()
8989 
    oprot.writeFieldStop()
8990 
    oprot.writeStructEnd()
8991 
 
3431 rajveer 8992 
  def validate(self):
8993 
    return
8994 
 
8995 
 
94 ashish 8996 
  def __repr__(self):
8997 
    L = ['%s=%r' % (key, value)
8998 
      for key, value in self.__dict__.iteritems()]
8999 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9000 
 
9001 
  def __eq__(self, other):
9002 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9003 
 
9004 
  def __ne__(self, other):
9005 
    return not (self == other)
9006 
 
3064 chandransh 9007 
class getLineItemsForOrder_result:
94 ashish 9008 
  """
9009 
  Attributes:
9010 
   - success
9011 
   - ex
9012 
  """
9013 
 
9014 
  thrift_spec = (
3064 chandransh 9015 
    (0, TType.LIST, 'success', (TType.STRUCT,(LineItem, LineItem.thrift_spec)), None, ), # 0
94 ashish 9016 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
9017 
  )
9018 
 
9019 
  def __init__(self, success=None, ex=None,):
9020 
    self.success = success
9021 
    self.ex = ex
9022 
 
9023 
  def read(self, iprot):
9024 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9025 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9026 
      return
9027 
    iprot.readStructBegin()
9028 
    while True:
9029 
      (fname, ftype, fid) = iprot.readFieldBegin()
9030 
      if ftype == TType.STOP:
9031 
        break
9032 
      if fid == 0:
483 rajveer 9033 
        if ftype == TType.LIST:
9034 
          self.success = []
4837 varun.gupt 9035 
          (_etype143, _size140) = iprot.readListBegin()
9036 
          for _i144 in xrange(_size140):
9037 
            _elem145 = LineItem()
9038 
            _elem145.read(iprot)
9039 
            self.success.append(_elem145)
483 rajveer 9040 
          iprot.readListEnd()
94 ashish 9041 
        else:
9042 
          iprot.skip(ftype)
9043 
      elif fid == 1:
9044 
        if ftype == TType.STRUCT:
9045 
          self.ex = TransactionServiceException()
9046 
          self.ex.read(iprot)
9047 
        else:
9048 
          iprot.skip(ftype)
9049 
      else:
9050 
        iprot.skip(ftype)
9051 
      iprot.readFieldEnd()
9052 
    iprot.readStructEnd()
9053 
 
9054 
  def write(self, oprot):
9055 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9056 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9057 
      return
3064 chandransh 9058 
    oprot.writeStructBegin('getLineItemsForOrder_result')
3431 rajveer 9059 
    if self.success is not None:
483 rajveer 9060 
      oprot.writeFieldBegin('success', TType.LIST, 0)
9061 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
4837 varun.gupt 9062 
      for iter146 in self.success:
9063 
        iter146.write(oprot)
483 rajveer 9064 
      oprot.writeListEnd()
94 ashish 9065 
      oprot.writeFieldEnd()
3431 rajveer 9066 
    if self.ex is not None:
94 ashish 9067 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
9068 
      self.ex.write(oprot)
9069 
      oprot.writeFieldEnd()
9070 
    oprot.writeFieldStop()
9071 
    oprot.writeStructEnd()
9072 
 
3431 rajveer 9073 
  def validate(self):
9074 
    return
9075 
 
9076 
 
94 ashish 9077 
  def __repr__(self):
9078 
    L = ['%s=%r' % (key, value)
9079 
      for key, value in self.__dict__.iteritems()]
9080 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9081 
 
9082 
  def __eq__(self, other):
9083 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9084 
 
9085 
  def __ne__(self, other):
9086 
    return not (self == other)
9087 
 
3064 chandransh 9088 
class getOrderForCustomer_args:
94 ashish 9089 
  """
9090 
  Attributes:
3064 chandransh 9091 
   - orderId
483 rajveer 9092 
   - customerId
94 ashish 9093 
  """
9094 
 
9095 
  thrift_spec = (
9096 
    None, # 0
3064 chandransh 9097 
    (1, TType.I64, 'orderId', None, None, ), # 1
9098 
    (2, TType.I64, 'customerId', None, None, ), # 2
94 ashish 9099 
  )
9100 
 
3064 chandransh 9101 
  def __init__(self, orderId=None, customerId=None,):
9102 
    self.orderId = orderId
483 rajveer 9103 
    self.customerId = customerId
94 ashish 9104 
 
9105 
  def read(self, iprot):
9106 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9107 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9108 
      return
9109 
    iprot.readStructBegin()
9110 
    while True:
9111 
      (fname, ftype, fid) = iprot.readFieldBegin()
9112 
      if ftype == TType.STOP:
9113 
        break
9114 
      if fid == 1:
9115 
        if ftype == TType.I64:
3064 chandransh 9116 
          self.orderId = iprot.readI64();
94 ashish 9117 
        else:
9118 
          iprot.skip(ftype)
9119 
      elif fid == 2:
9120 
        if ftype == TType.I64:
3064 chandransh 9121 
          self.customerId = iprot.readI64();
94 ashish 9122 
        else:
9123 
          iprot.skip(ftype)
9124 
      else:
9125 
        iprot.skip(ftype)
9126 
      iprot.readFieldEnd()
9127 
    iprot.readStructEnd()
9128 
 
9129 
  def write(self, oprot):
9130 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9131 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9132 
      return
3064 chandransh 9133 
    oprot.writeStructBegin('getOrderForCustomer_args')
3431 rajveer 9134 
    if self.orderId is not None:
3064 chandransh 9135 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
9136 
      oprot.writeI64(self.orderId)
9137 
      oprot.writeFieldEnd()
3431 rajveer 9138 
    if self.customerId is not None:
3064 chandransh 9139 
      oprot.writeFieldBegin('customerId', TType.I64, 2)
483 rajveer 9140 
      oprot.writeI64(self.customerId)
94 ashish 9141 
      oprot.writeFieldEnd()
9142 
    oprot.writeFieldStop()
9143 
    oprot.writeStructEnd()
9144 
 
3431 rajveer 9145 
  def validate(self):
9146 
    return
9147 
 
9148 
 
94 ashish 9149 
  def __repr__(self):
9150 
    L = ['%s=%r' % (key, value)
9151 
      for key, value in self.__dict__.iteritems()]
9152 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9153 
 
9154 
  def __eq__(self, other):
9155 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9156 
 
9157 
  def __ne__(self, other):
9158 
    return not (self == other)
9159 
 
3064 chandransh 9160 
class getOrderForCustomer_result:
94 ashish 9161 
  """
9162 
  Attributes:
9163 
   - success
9164 
   - ex
9165 
  """
9166 
 
9167 
  thrift_spec = (
3064 chandransh 9168 
    (0, TType.STRUCT, 'success', (Order, Order.thrift_spec), None, ), # 0
94 ashish 9169 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
9170 
  )
9171 
 
9172 
  def __init__(self, success=None, ex=None,):
9173 
    self.success = success
9174 
    self.ex = ex
9175 
 
9176 
  def read(self, iprot):
9177 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9178 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9179 
      return
9180 
    iprot.readStructBegin()
9181 
    while True:
9182 
      (fname, ftype, fid) = iprot.readFieldBegin()
9183 
      if ftype == TType.STOP:
9184 
        break
9185 
      if fid == 0:
3064 chandransh 9186 
        if ftype == TType.STRUCT:
9187 
          self.success = Order()
9188 
          self.success.read(iprot)
94 ashish 9189 
        else:
9190 
          iprot.skip(ftype)
9191 
      elif fid == 1:
9192 
        if ftype == TType.STRUCT:
9193 
          self.ex = TransactionServiceException()
9194 
          self.ex.read(iprot)
9195 
        else:
9196 
          iprot.skip(ftype)
9197 
      else:
9198 
        iprot.skip(ftype)
9199 
      iprot.readFieldEnd()
9200 
    iprot.readStructEnd()
9201 
 
9202 
  def write(self, oprot):
9203 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9204 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9205 
      return
3064 chandransh 9206 
    oprot.writeStructBegin('getOrderForCustomer_result')
3431 rajveer 9207 
    if self.success is not None:
3064 chandransh 9208 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
9209 
      self.success.write(oprot)
94 ashish 9210 
      oprot.writeFieldEnd()
3431 rajveer 9211 
    if self.ex is not None:
94 ashish 9212 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
9213 
      self.ex.write(oprot)
9214 
      oprot.writeFieldEnd()
9215 
    oprot.writeFieldStop()
9216 
    oprot.writeStructEnd()
9217 
 
3431 rajveer 9218 
  def validate(self):
9219 
    return
9220 
 
9221 
 
94 ashish 9222 
  def __repr__(self):
9223 
    L = ['%s=%r' % (key, value)
9224 
      for key, value in self.__dict__.iteritems()]
9225 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9226 
 
9227 
  def __eq__(self, other):
9228 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9229 
 
9230 
  def __ne__(self, other):
9231 
    return not (self == other)
9232 
 
3064 chandransh 9233 
class getAlerts_args:
94 ashish 9234 
  """
9235 
  Attributes:
4394 rajveer 9236 
   - type
4444 rajveer 9237 
   - warehouseId
4394 rajveer 9238 
   - status
9239 
   - timestamp
94 ashish 9240 
  """
9241 
 
9242 
  thrift_spec = (
9243 
    None, # 0
4394 rajveer 9244 
    (1, TType.I64, 'type', None, None, ), # 1
4444 rajveer 9245 
    (2, TType.I64, 'warehouseId', None, None, ), # 2
9246 
    (3, TType.I64, 'status', None, None, ), # 3
9247 
    (4, TType.I64, 'timestamp', None, None, ), # 4
94 ashish 9248 
  )
9249 
 
4444 rajveer 9250 
  def __init__(self, type=None, warehouseId=None, status=None, timestamp=None,):
4394 rajveer 9251 
    self.type = type
4444 rajveer 9252 
    self.warehouseId = warehouseId
4394 rajveer 9253 
    self.status = status
9254 
    self.timestamp = timestamp
94 ashish 9255 
 
9256 
  def read(self, iprot):
9257 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9258 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9259 
      return
9260 
    iprot.readStructBegin()
9261 
    while True:
9262 
      (fname, ftype, fid) = iprot.readFieldBegin()
9263 
      if ftype == TType.STOP:
9264 
        break
9265 
      if fid == 1:
3064 chandransh 9266 
        if ftype == TType.I64:
4394 rajveer 9267 
          self.type = iprot.readI64();
94 ashish 9268 
        else:
9269 
          iprot.skip(ftype)
3064 chandransh 9270 
      elif fid == 2:
4394 rajveer 9271 
        if ftype == TType.I64:
4444 rajveer 9272 
          self.warehouseId = iprot.readI64();
3064 chandransh 9273 
        else:
9274 
          iprot.skip(ftype)
4394 rajveer 9275 
      elif fid == 3:
9276 
        if ftype == TType.I64:
4444 rajveer 9277 
          self.status = iprot.readI64();
9278 
        else:
9279 
          iprot.skip(ftype)
9280 
      elif fid == 4:
9281 
        if ftype == TType.I64:
4394 rajveer 9282 
          self.timestamp = iprot.readI64();
9283 
        else:
9284 
          iprot.skip(ftype)
94 ashish 9285 
      else:
9286 
        iprot.skip(ftype)
9287 
      iprot.readFieldEnd()
9288 
    iprot.readStructEnd()
9289 
 
9290 
  def write(self, oprot):
9291 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9292 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9293 
      return
3064 chandransh 9294 
    oprot.writeStructBegin('getAlerts_args')
4394 rajveer 9295 
    if self.type is not None:
9296 
      oprot.writeFieldBegin('type', TType.I64, 1)
9297 
      oprot.writeI64(self.type)
94 ashish 9298 
      oprot.writeFieldEnd()
4444 rajveer 9299 
    if self.warehouseId is not None:
9300 
      oprot.writeFieldBegin('warehouseId', TType.I64, 2)
9301 
      oprot.writeI64(self.warehouseId)
9302 
      oprot.writeFieldEnd()
4394 rajveer 9303 
    if self.status is not None:
4444 rajveer 9304 
      oprot.writeFieldBegin('status', TType.I64, 3)
4394 rajveer 9305 
      oprot.writeI64(self.status)
3064 chandransh 9306 
      oprot.writeFieldEnd()
4394 rajveer 9307 
    if self.timestamp is not None:
4444 rajveer 9308 
      oprot.writeFieldBegin('timestamp', TType.I64, 4)
4394 rajveer 9309 
      oprot.writeI64(self.timestamp)
9310 
      oprot.writeFieldEnd()
94 ashish 9311 
    oprot.writeFieldStop()
9312 
    oprot.writeStructEnd()
9313 
 
3431 rajveer 9314 
  def validate(self):
9315 
    return
9316 
 
9317 
 
94 ashish 9318 
  def __repr__(self):
9319 
    L = ['%s=%r' % (key, value)
9320 
      for key, value in self.__dict__.iteritems()]
9321 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9322 
 
9323 
  def __eq__(self, other):
9324 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9325 
 
9326 
  def __ne__(self, other):
9327 
    return not (self == other)
9328 
 
3064 chandransh 9329 
class getAlerts_result:
94 ashish 9330 
  """
9331 
  Attributes:
9332 
   - success
9333 
  """
9334 
 
9335 
  thrift_spec = (
3064 chandransh 9336 
    (0, TType.LIST, 'success', (TType.STRUCT,(Alert, Alert.thrift_spec)), None, ), # 0
94 ashish 9337 
  )
9338 
 
3064 chandransh 9339 
  def __init__(self, success=None,):
94 ashish 9340 
    self.success = success
9341 
 
9342 
  def read(self, iprot):
9343 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9344 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9345 
      return
9346 
    iprot.readStructBegin()
9347 
    while True:
9348 
      (fname, ftype, fid) = iprot.readFieldBegin()
9349 
      if ftype == TType.STOP:
9350 
        break
9351 
      if fid == 0:
3064 chandransh 9352 
        if ftype == TType.LIST:
9353 
          self.success = []
4837 varun.gupt 9354 
          (_etype150, _size147) = iprot.readListBegin()
9355 
          for _i151 in xrange(_size147):
9356 
            _elem152 = Alert()
9357 
            _elem152.read(iprot)
9358 
            self.success.append(_elem152)
3064 chandransh 9359 
          iprot.readListEnd()
94 ashish 9360 
        else:
9361 
          iprot.skip(ftype)
9362 
      else:
9363 
        iprot.skip(ftype)
9364 
      iprot.readFieldEnd()
9365 
    iprot.readStructEnd()
9366 
 
9367 
  def write(self, oprot):
9368 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9369 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9370 
      return
3064 chandransh 9371 
    oprot.writeStructBegin('getAlerts_result')
3431 rajveer 9372 
    if self.success is not None:
3064 chandransh 9373 
      oprot.writeFieldBegin('success', TType.LIST, 0)
9374 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
4837 varun.gupt 9375 
      for iter153 in self.success:
9376 
        iter153.write(oprot)
3064 chandransh 9377 
      oprot.writeListEnd()
94 ashish 9378 
      oprot.writeFieldEnd()
9379 
    oprot.writeFieldStop()
9380 
    oprot.writeStructEnd()
9381 
 
3431 rajveer 9382 
  def validate(self):
9383 
    return
9384 
 
9385 
 
94 ashish 9386 
  def __repr__(self):
9387 
    L = ['%s=%r' % (key, value)
9388 
      for key, value in self.__dict__.iteritems()]
9389 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9390 
 
9391 
  def __eq__(self, other):
9392 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9393 
 
9394 
  def __ne__(self, other):
9395 
    return not (self == other)
9396 
 
4394 rajveer 9397 
class addAlert_args:
94 ashish 9398 
  """
9399 
  Attributes:
3064 chandransh 9400 
   - type
4444 rajveer 9401 
   - warehouseId
4394 rajveer 9402 
   - description
94 ashish 9403 
  """
9404 
 
9405 
  thrift_spec = (
9406 
    None, # 0
4394 rajveer 9407 
    (1, TType.I64, 'type', None, None, ), # 1
4444 rajveer 9408 
    (2, TType.I64, 'warehouseId', None, None, ), # 2
9409 
    (3, TType.STRING, 'description', None, None, ), # 3
94 ashish 9410 
  )
9411 
 
4444 rajveer 9412 
  def __init__(self, type=None, warehouseId=None, description=None,):
3064 chandransh 9413 
    self.type = type
4444 rajveer 9414 
    self.warehouseId = warehouseId
4394 rajveer 9415 
    self.description = description
94 ashish 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:
4394 rajveer 9428 
          self.type = iprot.readI64();
94 ashish 9429 
        else:
9430 
          iprot.skip(ftype)
3064 chandransh 9431 
      elif fid == 2:
4444 rajveer 9432 
        if ftype == TType.I64:
9433 
          self.warehouseId = iprot.readI64();
9434 
        else:
9435 
          iprot.skip(ftype)
9436 
      elif fid == 3:
3064 chandransh 9437 
        if ftype == TType.STRING:
4394 rajveer 9438 
          self.description = iprot.readString();
3064 chandransh 9439 
        else:
9440 
          iprot.skip(ftype)
94 ashish 9441 
      else:
9442 
        iprot.skip(ftype)
9443 
      iprot.readFieldEnd()
9444 
    iprot.readStructEnd()
9445 
 
9446 
  def write(self, oprot):
9447 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9448 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9449 
      return
4394 rajveer 9450 
    oprot.writeStructBegin('addAlert_args')
3431 rajveer 9451 
    if self.type is not None:
4394 rajveer 9452 
      oprot.writeFieldBegin('type', TType.I64, 1)
3064 chandransh 9453 
      oprot.writeI64(self.type)
9454 
      oprot.writeFieldEnd()
4444 rajveer 9455 
    if self.warehouseId is not None:
9456 
      oprot.writeFieldBegin('warehouseId', TType.I64, 2)
9457 
      oprot.writeI64(self.warehouseId)
9458 
      oprot.writeFieldEnd()
4394 rajveer 9459 
    if self.description is not None:
4444 rajveer 9460 
      oprot.writeFieldBegin('description', TType.STRING, 3)
4394 rajveer 9461 
      oprot.writeString(self.description)
3064 chandransh 9462 
      oprot.writeFieldEnd()
94 ashish 9463 
    oprot.writeFieldStop()
9464 
    oprot.writeStructEnd()
9465 
 
3431 rajveer 9466 
  def validate(self):
9467 
    return
9468 
 
9469 
 
94 ashish 9470 
  def __repr__(self):
9471 
    L = ['%s=%r' % (key, value)
9472 
      for key, value in self.__dict__.iteritems()]
9473 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9474 
 
9475 
  def __eq__(self, other):
9476 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9477 
 
9478 
  def __ne__(self, other):
9479 
    return not (self == other)
9480 
 
4394 rajveer 9481 
class addAlert_result:
3064 chandransh 9482 
 
9483 
  thrift_spec = (
9484 
  )
9485 
 
9486 
  def read(self, iprot):
9487 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9488 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9489 
      return
9490 
    iprot.readStructBegin()
9491 
    while True:
9492 
      (fname, ftype, fid) = iprot.readFieldBegin()
9493 
      if ftype == TType.STOP:
9494 
        break
9495 
      else:
9496 
        iprot.skip(ftype)
9497 
      iprot.readFieldEnd()
9498 
    iprot.readStructEnd()
9499 
 
9500 
  def write(self, oprot):
9501 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9502 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9503 
      return
4394 rajveer 9504 
    oprot.writeStructBegin('addAlert_result')
3064 chandransh 9505 
    oprot.writeFieldStop()
9506 
    oprot.writeStructEnd()
9507 
 
3431 rajveer 9508 
  def validate(self):
9509 
    return
9510 
 
9511 
 
3064 chandransh 9512 
  def __repr__(self):
9513 
    L = ['%s=%r' % (key, value)
9514 
      for key, value in self.__dict__.iteritems()]
9515 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9516 
 
9517 
  def __eq__(self, other):
9518 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9519 
 
9520 
  def __ne__(self, other):
9521 
    return not (self == other)
9522 
 
4444 rajveer 9523 
class markAlertsAsSeen_args:
9524 
  """
9525 
  Attributes:
9526 
   - warehouseId
9527 
  """
9528 
 
9529 
  thrift_spec = (
9530 
    None, # 0
9531 
    (1, TType.I64, 'warehouseId', None, None, ), # 1
9532 
  )
9533 
 
9534 
  def __init__(self, warehouseId=None,):
9535 
    self.warehouseId = warehouseId
9536 
 
9537 
  def read(self, iprot):
9538 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9539 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9540 
      return
9541 
    iprot.readStructBegin()
9542 
    while True:
9543 
      (fname, ftype, fid) = iprot.readFieldBegin()
9544 
      if ftype == TType.STOP:
9545 
        break
9546 
      if fid == 1:
9547 
        if ftype == TType.I64:
9548 
          self.warehouseId = iprot.readI64();
9549 
        else:
9550 
          iprot.skip(ftype)
9551 
      else:
9552 
        iprot.skip(ftype)
9553 
      iprot.readFieldEnd()
9554 
    iprot.readStructEnd()
9555 
 
9556 
  def write(self, oprot):
9557 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9558 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9559 
      return
9560 
    oprot.writeStructBegin('markAlertsAsSeen_args')
9561 
    if self.warehouseId is not None:
9562 
      oprot.writeFieldBegin('warehouseId', TType.I64, 1)
9563 
      oprot.writeI64(self.warehouseId)
9564 
      oprot.writeFieldEnd()
9565 
    oprot.writeFieldStop()
9566 
    oprot.writeStructEnd()
9567 
 
9568 
  def validate(self):
9569 
    return
9570 
 
9571 
 
9572 
  def __repr__(self):
9573 
    L = ['%s=%r' % (key, value)
9574 
      for key, value in self.__dict__.iteritems()]
9575 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9576 
 
9577 
  def __eq__(self, other):
9578 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9579 
 
9580 
  def __ne__(self, other):
9581 
    return not (self == other)
9582 
 
9583 
class markAlertsAsSeen_result:
9584 
 
9585 
  thrift_spec = (
9586 
  )
9587 
 
9588 
  def read(self, iprot):
9589 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9590 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9591 
      return
9592 
    iprot.readStructBegin()
9593 
    while True:
9594 
      (fname, ftype, fid) = iprot.readFieldBegin()
9595 
      if ftype == TType.STOP:
9596 
        break
9597 
      else:
9598 
        iprot.skip(ftype)
9599 
      iprot.readFieldEnd()
9600 
    iprot.readStructEnd()
9601 
 
9602 
  def write(self, oprot):
9603 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9604 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9605 
      return
9606 
    oprot.writeStructBegin('markAlertsAsSeen_result')
9607 
    oprot.writeFieldStop()
9608 
    oprot.writeStructEnd()
9609 
 
9610 
  def validate(self):
9611 
    return
9612 
 
9613 
 
9614 
  def __repr__(self):
9615 
    L = ['%s=%r' % (key, value)
9616 
      for key, value in self.__dict__.iteritems()]
9617 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9618 
 
9619 
  def __eq__(self, other):
9620 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9621 
 
9622 
  def __ne__(self, other):
9623 
    return not (self == other)
9624 
 
3064 chandransh 9625 
class getValidOrderCount_args:
9626 
 
9627 
  thrift_spec = (
9628 
  )
9629 
 
9630 
  def read(self, iprot):
9631 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9632 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9633 
      return
9634 
    iprot.readStructBegin()
9635 
    while True:
9636 
      (fname, ftype, fid) = iprot.readFieldBegin()
9637 
      if ftype == TType.STOP:
9638 
        break
9639 
      else:
9640 
        iprot.skip(ftype)
9641 
      iprot.readFieldEnd()
9642 
    iprot.readStructEnd()
9643 
 
9644 
  def write(self, oprot):
9645 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9646 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9647 
      return
9648 
    oprot.writeStructBegin('getValidOrderCount_args')
9649 
    oprot.writeFieldStop()
9650 
    oprot.writeStructEnd()
9651 
 
3431 rajveer 9652 
  def validate(self):
9653 
    return
9654 
 
9655 
 
3064 chandransh 9656 
  def __repr__(self):
9657 
    L = ['%s=%r' % (key, value)
9658 
      for key, value in self.__dict__.iteritems()]
9659 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9660 
 
9661 
  def __eq__(self, other):
9662 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9663 
 
9664 
  def __ne__(self, other):
9665 
    return not (self == other)
9666 
 
9667 
class getValidOrderCount_result:
94 ashish 9668 
  """
9669 
  Attributes:
9670 
   - success
9671 
  """
9672 
 
9673 
  thrift_spec = (
3064 chandransh 9674 
    (0, TType.I64, 'success', None, None, ), # 0
94 ashish 9675 
  )
9676 
 
3064 chandransh 9677 
  def __init__(self, success=None,):
94 ashish 9678 
    self.success = success
9679 
 
9680 
  def read(self, iprot):
9681 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9682 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9683 
      return
9684 
    iprot.readStructBegin()
9685 
    while True:
9686 
      (fname, ftype, fid) = iprot.readFieldBegin()
9687 
      if ftype == TType.STOP:
9688 
        break
9689 
      if fid == 0:
3064 chandransh 9690 
        if ftype == TType.I64:
9691 
          self.success = iprot.readI64();
94 ashish 9692 
        else:
9693 
          iprot.skip(ftype)
9694 
      else:
9695 
        iprot.skip(ftype)
9696 
      iprot.readFieldEnd()
9697 
    iprot.readStructEnd()
9698 
 
9699 
  def write(self, oprot):
9700 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9701 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9702 
      return
3064 chandransh 9703 
    oprot.writeStructBegin('getValidOrderCount_result')
3431 rajveer 9704 
    if self.success is not None:
3064 chandransh 9705 
      oprot.writeFieldBegin('success', TType.I64, 0)
9706 
      oprot.writeI64(self.success)
94 ashish 9707 
      oprot.writeFieldEnd()
9708 
    oprot.writeFieldStop()
9709 
    oprot.writeStructEnd()
9710 
 
3431 rajveer 9711 
  def validate(self):
9712 
    return
9713 
 
9714 
 
94 ashish 9715 
  def __repr__(self):
9716 
    L = ['%s=%r' % (key, value)
9717 
      for key, value in self.__dict__.iteritems()]
9718 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9719 
 
9720 
  def __eq__(self, other):
9721 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9722 
 
9723 
  def __ne__(self, other):
9724 
    return not (self == other)
9725 
 
3064 chandransh 9726 
class getNoOfCustomersWithSuccessfulTransaction_args:
9727 
 
9728 
  thrift_spec = (
9729 
  )
9730 
 
9731 
  def read(self, iprot):
9732 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9733 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9734 
      return
9735 
    iprot.readStructBegin()
9736 
    while True:
9737 
      (fname, ftype, fid) = iprot.readFieldBegin()
9738 
      if ftype == TType.STOP:
9739 
        break
9740 
      else:
9741 
        iprot.skip(ftype)
9742 
      iprot.readFieldEnd()
9743 
    iprot.readStructEnd()
9744 
 
9745 
  def write(self, oprot):
9746 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9747 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9748 
      return
9749 
    oprot.writeStructBegin('getNoOfCustomersWithSuccessfulTransaction_args')
9750 
    oprot.writeFieldStop()
9751 
    oprot.writeStructEnd()
9752 
 
3431 rajveer 9753 
  def validate(self):
9754 
    return
9755 
 
9756 
 
3064 chandransh 9757 
  def __repr__(self):
9758 
    L = ['%s=%r' % (key, value)
9759 
      for key, value in self.__dict__.iteritems()]
9760 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9761 
 
9762 
  def __eq__(self, other):
9763 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9764 
 
9765 
  def __ne__(self, other):
9766 
    return not (self == other)
9767 
 
9768 
class getNoOfCustomersWithSuccessfulTransaction_result:
94 ashish 9769 
  """
9770 
  Attributes:
3064 chandransh 9771 
   - success
94 ashish 9772 
  """
9773 
 
9774 
  thrift_spec = (
3064 chandransh 9775 
    (0, TType.I64, 'success', None, None, ), # 0
94 ashish 9776 
  )
9777 
 
3064 chandransh 9778 
  def __init__(self, success=None,):
9779 
    self.success = success
94 ashish 9780 
 
9781 
  def read(self, iprot):
9782 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9783 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9784 
      return
9785 
    iprot.readStructBegin()
9786 
    while True:
9787 
      (fname, ftype, fid) = iprot.readFieldBegin()
9788 
      if ftype == TType.STOP:
9789 
        break
3064 chandransh 9790 
      if fid == 0:
94 ashish 9791 
        if ftype == TType.I64:
3064 chandransh 9792 
          self.success = iprot.readI64();
94 ashish 9793 
        else:
9794 
          iprot.skip(ftype)
9795 
      else:
9796 
        iprot.skip(ftype)
9797 
      iprot.readFieldEnd()
9798 
    iprot.readStructEnd()
9799 
 
9800 
  def write(self, oprot):
9801 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9802 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9803 
      return
3064 chandransh 9804 
    oprot.writeStructBegin('getNoOfCustomersWithSuccessfulTransaction_result')
3431 rajveer 9805 
    if self.success is not None:
3064 chandransh 9806 
      oprot.writeFieldBegin('success', TType.I64, 0)
9807 
      oprot.writeI64(self.success)
94 ashish 9808 
      oprot.writeFieldEnd()
9809 
    oprot.writeFieldStop()
9810 
    oprot.writeStructEnd()
9811 
 
3431 rajveer 9812 
  def validate(self):
9813 
    return
9814 
 
9815 
 
94 ashish 9816 
  def __repr__(self):
9817 
    L = ['%s=%r' % (key, value)
9818 
      for key, value in self.__dict__.iteritems()]
9819 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9820 
 
9821 
  def __eq__(self, other):
9822 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9823 
 
9824 
  def __ne__(self, other):
9825 
    return not (self == other)
9826 
 
3064 chandransh 9827 
class getValidOrdersAmountRange_args:
9828 
 
9829 
  thrift_spec = (
9830 
  )
9831 
 
9832 
  def read(self, iprot):
9833 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9834 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9835 
      return
9836 
    iprot.readStructBegin()
9837 
    while True:
9838 
      (fname, ftype, fid) = iprot.readFieldBegin()
9839 
      if ftype == TType.STOP:
9840 
        break
9841 
      else:
9842 
        iprot.skip(ftype)
9843 
      iprot.readFieldEnd()
9844 
    iprot.readStructEnd()
9845 
 
9846 
  def write(self, oprot):
9847 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9848 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9849 
      return
9850 
    oprot.writeStructBegin('getValidOrdersAmountRange_args')
9851 
    oprot.writeFieldStop()
9852 
    oprot.writeStructEnd()
9853 
 
3431 rajveer 9854 
  def validate(self):
9855 
    return
9856 
 
9857 
 
3064 chandransh 9858 
  def __repr__(self):
9859 
    L = ['%s=%r' % (key, value)
9860 
      for key, value in self.__dict__.iteritems()]
9861 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9862 
 
9863 
  def __eq__(self, other):
9864 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9865 
 
9866 
  def __ne__(self, other):
9867 
    return not (self == other)
9868 
 
9869 
class getValidOrdersAmountRange_result:
94 ashish 9870 
  """
9871 
  Attributes:
9872 
   - success
9873 
  """
9874 
 
9875 
  thrift_spec = (
3064 chandransh 9876 
    (0, TType.LIST, 'success', (TType.DOUBLE,None), None, ), # 0
94 ashish 9877 
  )
9878 
 
3064 chandransh 9879 
  def __init__(self, success=None,):
94 ashish 9880 
    self.success = success
9881 
 
9882 
  def read(self, iprot):
9883 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9884 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9885 
      return
9886 
    iprot.readStructBegin()
9887 
    while True:
9888 
      (fname, ftype, fid) = iprot.readFieldBegin()
9889 
      if ftype == TType.STOP:
9890 
        break
9891 
      if fid == 0:
483 rajveer 9892 
        if ftype == TType.LIST:
9893 
          self.success = []
4837 varun.gupt 9894 
          (_etype157, _size154) = iprot.readListBegin()
9895 
          for _i158 in xrange(_size154):
9896 
            _elem159 = iprot.readDouble();
9897 
            self.success.append(_elem159)
483 rajveer 9898 
          iprot.readListEnd()
94 ashish 9899 
        else:
9900 
          iprot.skip(ftype)
9901 
      else:
9902 
        iprot.skip(ftype)
9903 
      iprot.readFieldEnd()
9904 
    iprot.readStructEnd()
9905 
 
9906 
  def write(self, oprot):
9907 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9908 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9909 
      return
3064 chandransh 9910 
    oprot.writeStructBegin('getValidOrdersAmountRange_result')
3431 rajveer 9911 
    if self.success is not None:
483 rajveer 9912 
      oprot.writeFieldBegin('success', TType.LIST, 0)
3064 chandransh 9913 
      oprot.writeListBegin(TType.DOUBLE, len(self.success))
4837 varun.gupt 9914 
      for iter160 in self.success:
9915 
        oprot.writeDouble(iter160)
483 rajveer 9916 
      oprot.writeListEnd()
94 ashish 9917 
      oprot.writeFieldEnd()
9918 
    oprot.writeFieldStop()
9919 
    oprot.writeStructEnd()
9920 
 
3431 rajveer 9921 
  def validate(self):
9922 
    return
9923 
 
9924 
 
94 ashish 9925 
  def __repr__(self):
9926 
    L = ['%s=%r' % (key, value)
9927 
      for key, value in self.__dict__.iteritems()]
9928 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9929 
 
9930 
  def __eq__(self, other):
9931 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9932 
 
9933 
  def __ne__(self, other):
9934 
    return not (self == other)
9935 
 
3064 chandransh 9936 
class getValidOrders_args:
1528 ankur.sing 9937 
  """
9938 
  Attributes:
3064 chandransh 9939 
   - limit
1528 ankur.sing 9940 
  """
9941 
 
9942 
  thrift_spec = (
9943 
    None, # 0
3064 chandransh 9944 
    (1, TType.I64, 'limit', None, None, ), # 1
1528 ankur.sing 9945 
  )
9946 
 
3064 chandransh 9947 
  def __init__(self, limit=None,):
9948 
    self.limit = limit
1528 ankur.sing 9949 
 
9950 
  def read(self, iprot):
9951 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9952 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9953 
      return
9954 
    iprot.readStructBegin()
9955 
    while True:
9956 
      (fname, ftype, fid) = iprot.readFieldBegin()
9957 
      if ftype == TType.STOP:
9958 
        break
9959 
      if fid == 1:
9960 
        if ftype == TType.I64:
3064 chandransh 9961 
          self.limit = iprot.readI64();
1528 ankur.sing 9962 
        else:
9963 
          iprot.skip(ftype)
9964 
      else:
9965 
        iprot.skip(ftype)
9966 
      iprot.readFieldEnd()
9967 
    iprot.readStructEnd()
9968 
 
9969 
  def write(self, oprot):
9970 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9971 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9972 
      return
3064 chandransh 9973 
    oprot.writeStructBegin('getValidOrders_args')
3431 rajveer 9974 
    if self.limit is not None:
3064 chandransh 9975 
      oprot.writeFieldBegin('limit', TType.I64, 1)
9976 
      oprot.writeI64(self.limit)
1528 ankur.sing 9977 
      oprot.writeFieldEnd()
9978 
    oprot.writeFieldStop()
9979 
    oprot.writeStructEnd()
9980 
 
3431 rajveer 9981 
  def validate(self):
9982 
    return
9983 
 
9984 
 
1528 ankur.sing 9985 
  def __repr__(self):
9986 
    L = ['%s=%r' % (key, value)
9987 
      for key, value in self.__dict__.iteritems()]
9988 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9989 
 
9990 
  def __eq__(self, other):
9991 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9992 
 
9993 
  def __ne__(self, other):
9994 
    return not (self == other)
9995 
 
3064 chandransh 9996 
class getValidOrders_result:
1528 ankur.sing 9997 
  """
9998 
  Attributes:
9999 
   - success
10000 
  """
10001 
 
10002 
  thrift_spec = (
3064 chandransh 10003 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
1528 ankur.sing 10004 
  )
10005 
 
3064 chandransh 10006 
  def __init__(self, success=None,):
1528 ankur.sing 10007 
    self.success = success
10008 
 
10009 
  def read(self, iprot):
10010 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10011 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10012 
      return
10013 
    iprot.readStructBegin()
10014 
    while True:
10015 
      (fname, ftype, fid) = iprot.readFieldBegin()
10016 
      if ftype == TType.STOP:
10017 
        break
10018 
      if fid == 0:
3064 chandransh 10019 
        if ftype == TType.LIST:
10020 
          self.success = []
4837 varun.gupt 10021 
          (_etype164, _size161) = iprot.readListBegin()
10022 
          for _i165 in xrange(_size161):
10023 
            _elem166 = Order()
10024 
            _elem166.read(iprot)
10025 
            self.success.append(_elem166)
3064 chandransh 10026 
          iprot.readListEnd()
1528 ankur.sing 10027 
        else:
10028 
          iprot.skip(ftype)
10029 
      else:
10030 
        iprot.skip(ftype)
10031 
      iprot.readFieldEnd()
10032 
    iprot.readStructEnd()
10033 
 
10034 
  def write(self, oprot):
10035 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10036 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10037 
      return
3064 chandransh 10038 
    oprot.writeStructBegin('getValidOrders_result')
3431 rajveer 10039 
    if self.success is not None:
3064 chandransh 10040 
      oprot.writeFieldBegin('success', TType.LIST, 0)
10041 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
4837 varun.gupt 10042 
      for iter167 in self.success:
10043 
        iter167.write(oprot)
3064 chandransh 10044 
      oprot.writeListEnd()
1528 ankur.sing 10045 
      oprot.writeFieldEnd()
10046 
    oprot.writeFieldStop()
10047 
    oprot.writeStructEnd()
10048 
 
3431 rajveer 10049 
  def validate(self):
10050 
    return
10051 
 
10052 
 
1528 ankur.sing 10053 
  def __repr__(self):
10054 
    L = ['%s=%r' % (key, value)
10055 
      for key, value in self.__dict__.iteritems()]
10056 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10057 
 
10058 
  def __eq__(self, other):
10059 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10060 
 
10061 
  def __ne__(self, other):
10062 
    return not (self == other)
10063 
 
1220 chandransh 10064 
class batchOrders_args:
10065 
  """
10066 
  Attributes:
10067 
   - warehouseId
10068 
  """
10069 
 
10070 
  thrift_spec = (
10071 
    None, # 0
10072 
    (1, TType.I64, 'warehouseId', None, None, ), # 1
10073 
  )
10074 
 
10075 
  def __init__(self, warehouseId=None,):
10076 
    self.warehouseId = warehouseId
10077 
 
10078 
  def read(self, iprot):
10079 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10080 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10081 
      return
10082 
    iprot.readStructBegin()
10083 
    while True:
10084 
      (fname, ftype, fid) = iprot.readFieldBegin()
10085 
      if ftype == TType.STOP:
10086 
        break
10087 
      if fid == 1:
10088 
        if ftype == TType.I64:
10089 
          self.warehouseId = iprot.readI64();
10090 
        else:
10091 
          iprot.skip(ftype)
10092 
      else:
10093 
        iprot.skip(ftype)
10094 
      iprot.readFieldEnd()
10095 
    iprot.readStructEnd()
10096 
 
10097 
  def write(self, oprot):
10098 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10099 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10100 
      return
10101 
    oprot.writeStructBegin('batchOrders_args')
3431 rajveer 10102 
    if self.warehouseId is not None:
1220 chandransh 10103 
      oprot.writeFieldBegin('warehouseId', TType.I64, 1)
10104 
      oprot.writeI64(self.warehouseId)
10105 
      oprot.writeFieldEnd()
10106 
    oprot.writeFieldStop()
10107 
    oprot.writeStructEnd()
10108 
 
3431 rajveer 10109 
  def validate(self):
10110 
    return
10111 
 
10112 
 
1220 chandransh 10113 
  def __repr__(self):
10114 
    L = ['%s=%r' % (key, value)
10115 
      for key, value in self.__dict__.iteritems()]
10116 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10117 
 
10118 
  def __eq__(self, other):
10119 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10120 
 
10121 
  def __ne__(self, other):
10122 
    return not (self == other)
10123 
 
10124 
class batchOrders_result:
10125 
  """
10126 
  Attributes:
10127 
   - success
10128 
   - ex
10129 
  """
10130 
 
10131 
  thrift_spec = (
10132 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
10133 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
10134 
  )
10135 
 
10136 
  def __init__(self, success=None, ex=None,):
10137 
    self.success = success
10138 
    self.ex = ex
10139 
 
10140 
  def read(self, iprot):
10141 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10142 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10143 
      return
10144 
    iprot.readStructBegin()
10145 
    while True:
10146 
      (fname, ftype, fid) = iprot.readFieldBegin()
10147 
      if ftype == TType.STOP:
10148 
        break
10149 
      if fid == 0:
10150 
        if ftype == TType.LIST:
10151 
          self.success = []
4837 varun.gupt 10152 
          (_etype171, _size168) = iprot.readListBegin()
10153 
          for _i172 in xrange(_size168):
10154 
            _elem173 = Order()
10155 
            _elem173.read(iprot)
10156 
            self.success.append(_elem173)
1220 chandransh 10157 
          iprot.readListEnd()
10158 
        else:
10159 
          iprot.skip(ftype)
10160 
      elif fid == 1:
10161 
        if ftype == TType.STRUCT:
10162 
          self.ex = TransactionServiceException()
10163 
          self.ex.read(iprot)
10164 
        else:
10165 
          iprot.skip(ftype)
10166 
      else:
10167 
        iprot.skip(ftype)
10168 
      iprot.readFieldEnd()
10169 
    iprot.readStructEnd()
10170 
 
10171 
  def write(self, oprot):
10172 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10173 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10174 
      return
10175 
    oprot.writeStructBegin('batchOrders_result')
3431 rajveer 10176 
    if self.success is not None:
1220 chandransh 10177 
      oprot.writeFieldBegin('success', TType.LIST, 0)
10178 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
4837 varun.gupt 10179 
      for iter174 in self.success:
10180 
        iter174.write(oprot)
1220 chandransh 10181 
      oprot.writeListEnd()
10182 
      oprot.writeFieldEnd()
3431 rajveer 10183 
    if self.ex is not None:
1220 chandransh 10184 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
10185 
      self.ex.write(oprot)
10186 
      oprot.writeFieldEnd()
10187 
    oprot.writeFieldStop()
10188 
    oprot.writeStructEnd()
10189 
 
3431 rajveer 10190 
  def validate(self):
10191 
    return
10192 
 
10193 
 
1220 chandransh 10194 
  def __repr__(self):
10195 
    L = ['%s=%r' % (key, value)
10196 
      for key, value in self.__dict__.iteritems()]
10197 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10198 
 
10199 
  def __eq__(self, other):
10200 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10201 
 
10202 
  def __ne__(self, other):
10203 
    return not (self == other)
10204 
 
1208 chandransh 10205 
class markOrderAsOutOfStock_args:
10206 
  """
10207 
  Attributes:
10208 
   - orderId
10209 
  """
10210 
 
10211 
  thrift_spec = (
10212 
    None, # 0
10213 
    (1, TType.I64, 'orderId', None, None, ), # 1
10214 
  )
10215 
 
10216 
  def __init__(self, orderId=None,):
10217 
    self.orderId = orderId
10218 
 
10219 
  def read(self, iprot):
10220 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10221 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10222 
      return
10223 
    iprot.readStructBegin()
10224 
    while True:
10225 
      (fname, ftype, fid) = iprot.readFieldBegin()
10226 
      if ftype == TType.STOP:
10227 
        break
10228 
      if fid == 1:
10229 
        if ftype == TType.I64:
10230 
          self.orderId = iprot.readI64();
10231 
        else:
10232 
          iprot.skip(ftype)
10233 
      else:
10234 
        iprot.skip(ftype)
10235 
      iprot.readFieldEnd()
10236 
    iprot.readStructEnd()
10237 
 
10238 
  def write(self, oprot):
10239 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10240 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10241 
      return
10242 
    oprot.writeStructBegin('markOrderAsOutOfStock_args')
3431 rajveer 10243 
    if self.orderId is not None:
1208 chandransh 10244 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
10245 
      oprot.writeI64(self.orderId)
10246 
      oprot.writeFieldEnd()
10247 
    oprot.writeFieldStop()
10248 
    oprot.writeStructEnd()
10249 
 
3431 rajveer 10250 
  def validate(self):
10251 
    return
10252 
 
10253 
 
1208 chandransh 10254 
  def __repr__(self):
10255 
    L = ['%s=%r' % (key, value)
10256 
      for key, value in self.__dict__.iteritems()]
10257 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10258 
 
10259 
  def __eq__(self, other):
10260 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10261 
 
10262 
  def __ne__(self, other):
10263 
    return not (self == other)
10264 
 
10265 
class markOrderAsOutOfStock_result:
10266 
  """
10267 
  Attributes:
10268 
   - success
10269 
   - ex
10270 
  """
10271 
 
10272 
  thrift_spec = (
10273 
    (0, TType.BOOL, 'success', None, None, ), # 0
10274 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
10275 
  )
10276 
 
10277 
  def __init__(self, success=None, ex=None,):
10278 
    self.success = success
10279 
    self.ex = ex
10280 
 
10281 
  def read(self, iprot):
10282 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10283 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10284 
      return
10285 
    iprot.readStructBegin()
10286 
    while True:
10287 
      (fname, ftype, fid) = iprot.readFieldBegin()
10288 
      if ftype == TType.STOP:
10289 
        break
10290 
      if fid == 0:
10291 
        if ftype == TType.BOOL:
10292 
          self.success = iprot.readBool();
10293 
        else:
10294 
          iprot.skip(ftype)
10295 
      elif fid == 1:
10296 
        if ftype == TType.STRUCT:
10297 
          self.ex = TransactionServiceException()
10298 
          self.ex.read(iprot)
10299 
        else:
10300 
          iprot.skip(ftype)
10301 
      else:
10302 
        iprot.skip(ftype)
10303 
      iprot.readFieldEnd()
10304 
    iprot.readStructEnd()
10305 
 
10306 
  def write(self, oprot):
10307 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10308 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10309 
      return
10310 
    oprot.writeStructBegin('markOrderAsOutOfStock_result')
3431 rajveer 10311 
    if self.success is not None:
1208 chandransh 10312 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
10313 
      oprot.writeBool(self.success)
10314 
      oprot.writeFieldEnd()
3431 rajveer 10315 
    if self.ex is not None:
1208 chandransh 10316 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
10317 
      self.ex.write(oprot)
10318 
      oprot.writeFieldEnd()
10319 
    oprot.writeFieldStop()
10320 
    oprot.writeStructEnd()
10321 
 
3431 rajveer 10322 
  def validate(self):
10323 
    return
10324 
 
10325 
 
1208 chandransh 10326 
  def __repr__(self):
10327 
    L = ['%s=%r' % (key, value)
10328 
      for key, value in self.__dict__.iteritems()]
10329 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10330 
 
10331 
  def __eq__(self, other):
10332 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10333 
 
10334 
  def __ne__(self, other):
10335 
    return not (self == other)
10336 
 
3064 chandransh 10337 
class verifyOrder_args:
759 chandransh 10338 
  """
10339 
  Attributes:
3064 chandransh 10340 
   - orderId
759 chandransh 10341 
  """
10342 
 
10343 
  thrift_spec = (
10344 
    None, # 0
3064 chandransh 10345 
    (1, TType.I64, 'orderId', None, None, ), # 1
759 chandransh 10346 
  )
10347 
 
3064 chandransh 10348 
  def __init__(self, orderId=None,):
10349 
    self.orderId = orderId
759 chandransh 10350 
 
10351 
  def read(self, iprot):
10352 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10353 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10354 
      return
10355 
    iprot.readStructBegin()
10356 
    while True:
10357 
      (fname, ftype, fid) = iprot.readFieldBegin()
10358 
      if ftype == TType.STOP:
10359 
        break
10360 
      if fid == 1:
10361 
        if ftype == TType.I64:
3064 chandransh 10362 
          self.orderId = iprot.readI64();
759 chandransh 10363 
        else:
10364 
          iprot.skip(ftype)
10365 
      else:
10366 
        iprot.skip(ftype)
10367 
      iprot.readFieldEnd()
10368 
    iprot.readStructEnd()
10369 
 
10370 
  def write(self, oprot):
10371 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10372 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10373 
      return
3064 chandransh 10374 
    oprot.writeStructBegin('verifyOrder_args')
3431 rajveer 10375 
    if self.orderId is not None:
3064 chandransh 10376 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
10377 
      oprot.writeI64(self.orderId)
759 chandransh 10378 
      oprot.writeFieldEnd()
10379 
    oprot.writeFieldStop()
10380 
    oprot.writeStructEnd()
10381 
 
3431 rajveer 10382 
  def validate(self):
10383 
    return
10384 
 
10385 
 
759 chandransh 10386 
  def __repr__(self):
10387 
    L = ['%s=%r' % (key, value)
10388 
      for key, value in self.__dict__.iteritems()]
10389 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10390 
 
10391 
  def __eq__(self, other):
10392 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10393 
 
10394 
  def __ne__(self, other):
10395 
    return not (self == other)
10396 
 
3064 chandransh 10397 
class verifyOrder_result:
759 chandransh 10398 
  """
10399 
  Attributes:
10400 
   - success
10401 
   - ex
10402 
  """
10403 
 
10404 
  thrift_spec = (
10405 
    (0, TType.BOOL, 'success', None, None, ), # 0
10406 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
10407 
  )
10408 
 
10409 
  def __init__(self, success=None, ex=None,):
10410 
    self.success = success
10411 
    self.ex = ex
10412 
 
10413 
  def read(self, iprot):
10414 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10415 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10416 
      return
10417 
    iprot.readStructBegin()
10418 
    while True:
10419 
      (fname, ftype, fid) = iprot.readFieldBegin()
10420 
      if ftype == TType.STOP:
10421 
        break
10422 
      if fid == 0:
10423 
        if ftype == TType.BOOL:
10424 
          self.success = iprot.readBool();
10425 
        else:
10426 
          iprot.skip(ftype)
10427 
      elif fid == 1:
10428 
        if ftype == TType.STRUCT:
10429 
          self.ex = TransactionServiceException()
10430 
          self.ex.read(iprot)
10431 
        else:
10432 
          iprot.skip(ftype)
10433 
      else:
10434 
        iprot.skip(ftype)
10435 
      iprot.readFieldEnd()
10436 
    iprot.readStructEnd()
10437 
 
10438 
  def write(self, oprot):
10439 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10440 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10441 
      return
3064 chandransh 10442 
    oprot.writeStructBegin('verifyOrder_result')
3431 rajveer 10443 
    if self.success is not None:
759 chandransh 10444 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
10445 
      oprot.writeBool(self.success)
10446 
      oprot.writeFieldEnd()
3431 rajveer 10447 
    if self.ex is not None:
759 chandransh 10448 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
10449 
      self.ex.write(oprot)
10450 
      oprot.writeFieldEnd()
10451 
    oprot.writeFieldStop()
10452 
    oprot.writeStructEnd()
10453 
 
3431 rajveer 10454 
  def validate(self):
10455 
    return
10456 
 
10457 
 
759 chandransh 10458 
  def __repr__(self):
10459 
    L = ['%s=%r' % (key, value)
10460 
      for key, value in self.__dict__.iteritems()]
10461 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10462 
 
10463 
  def __eq__(self, other):
10464 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10465 
 
10466 
  def __ne__(self, other):
10467 
    return not (self == other)
10468 
 
3064 chandransh 10469 
class acceptOrder_args:
1113 chandransh 10470 
  """
10471 
  Attributes:
3064 chandransh 10472 
   - orderId
1113 chandransh 10473 
  """
10474 
 
10475 
  thrift_spec = (
10476 
    None, # 0
3064 chandransh 10477 
    (1, TType.I64, 'orderId', None, None, ), # 1
1113 chandransh 10478 
  )
10479 
 
3064 chandransh 10480 
  def __init__(self, orderId=None,):
10481 
    self.orderId = orderId
1113 chandransh 10482 
 
10483 
  def read(self, iprot):
10484 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10485 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10486 
      return
10487 
    iprot.readStructBegin()
10488 
    while True:
10489 
      (fname, ftype, fid) = iprot.readFieldBegin()
10490 
      if ftype == TType.STOP:
10491 
        break
10492 
      if fid == 1:
10493 
        if ftype == TType.I64:
3064 chandransh 10494 
          self.orderId = iprot.readI64();
1113 chandransh 10495 
        else:
10496 
          iprot.skip(ftype)
10497 
      else:
10498 
        iprot.skip(ftype)
10499 
      iprot.readFieldEnd()
10500 
    iprot.readStructEnd()
10501 
 
10502 
  def write(self, oprot):
10503 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10504 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10505 
      return
3064 chandransh 10506 
    oprot.writeStructBegin('acceptOrder_args')
3431 rajveer 10507 
    if self.orderId is not None:
3064 chandransh 10508 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
10509 
      oprot.writeI64(self.orderId)
1113 chandransh 10510 
      oprot.writeFieldEnd()
10511 
    oprot.writeFieldStop()
10512 
    oprot.writeStructEnd()
10513 
 
3431 rajveer 10514 
  def validate(self):
10515 
    return
10516 
 
10517 
 
1113 chandransh 10518 
  def __repr__(self):
10519 
    L = ['%s=%r' % (key, value)
10520 
      for key, value in self.__dict__.iteritems()]
10521 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10522 
 
10523 
  def __eq__(self, other):
10524 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10525 
 
10526 
  def __ne__(self, other):
10527 
    return not (self == other)
10528 
 
3064 chandransh 10529 
class acceptOrder_result:
1113 chandransh 10530 
  """
10531 
  Attributes:
10532 
   - success
10533 
   - ex
10534 
  """
10535 
 
10536 
  thrift_spec = (
3064 chandransh 10537 
    (0, TType.BOOL, 'success', None, None, ), # 0
1113 chandransh 10538 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
10539 
  )
10540 
 
10541 
  def __init__(self, success=None, ex=None,):
10542 
    self.success = success
10543 
    self.ex = ex
10544 
 
10545 
  def read(self, iprot):
10546 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10547 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10548 
      return
10549 
    iprot.readStructBegin()
10550 
    while True:
10551 
      (fname, ftype, fid) = iprot.readFieldBegin()
10552 
      if ftype == TType.STOP:
10553 
        break
10554 
      if fid == 0:
3064 chandransh 10555 
        if ftype == TType.BOOL:
10556 
          self.success = iprot.readBool();
1113 chandransh 10557 
        else:
10558 
          iprot.skip(ftype)
10559 
      elif fid == 1:
10560 
        if ftype == TType.STRUCT:
10561 
          self.ex = TransactionServiceException()
10562 
          self.ex.read(iprot)
10563 
        else:
10564 
          iprot.skip(ftype)
10565 
      else:
10566 
        iprot.skip(ftype)
10567 
      iprot.readFieldEnd()
10568 
    iprot.readStructEnd()
10569 
 
10570 
  def write(self, oprot):
10571 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10572 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10573 
      return
3064 chandransh 10574 
    oprot.writeStructBegin('acceptOrder_result')
3431 rajveer 10575 
    if self.success is not None:
3064 chandransh 10576 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
10577 
      oprot.writeBool(self.success)
1113 chandransh 10578 
      oprot.writeFieldEnd()
3431 rajveer 10579 
    if self.ex is not None:
1113 chandransh 10580 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
10581 
      self.ex.write(oprot)
10582 
      oprot.writeFieldEnd()
10583 
    oprot.writeFieldStop()
10584 
    oprot.writeStructEnd()
10585 
 
3431 rajveer 10586 
  def validate(self):
10587 
    return
10588 
 
10589 
 
1113 chandransh 10590 
  def __repr__(self):
10591 
    L = ['%s=%r' % (key, value)
10592 
      for key, value in self.__dict__.iteritems()]
10593 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10594 
 
10595 
  def __eq__(self, other):
10596 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10597 
 
10598 
  def __ne__(self, other):
10599 
    return not (self == other)
10600 
 
3064 chandransh 10601 
class addBillingDetails_args:
1135 chandransh 10602 
  """
10603 
  Attributes:
3064 chandransh 10604 
   - orderId
10605 
   - invoice_number
4658 mandeep.dh 10606 
   - serialNumber
4283 anupam.sin 10607 
   - itemNumber
3064 chandransh 10608 
   - billed_by
4264 rajveer 10609 
   - jacketNumber
4283 anupam.sin 10610 
   - billingType
10611 
   - vendorId
4763 rajveer 10612 
   - authorize
1135 chandransh 10613 
  """
10614 
 
10615 
  thrift_spec = (
10616 
    None, # 0
3064 chandransh 10617 
    (1, TType.I64, 'orderId', None, None, ), # 1
10618 
    (2, TType.STRING, 'invoice_number', None, None, ), # 2
4658 mandeep.dh 10619 
    (3, TType.STRING, 'serialNumber', None, None, ), # 3
4283 anupam.sin 10620 
    (4, TType.STRING, 'itemNumber', None, None, ), # 4
10621 
    (5, TType.STRING, 'billed_by', None, None, ), # 5
10622 
    (6, TType.I64, 'jacketNumber', None, None, ), # 6
10623 
    (7, TType.I64, 'billingType', None, None, ), # 7
10624 
    (8, TType.I64, 'vendorId', None, None, ), # 8
4763 rajveer 10625 
    (9, TType.BOOL, 'authorize', None, None, ), # 9
1135 chandransh 10626 
  )
10627 
 
4763 rajveer 10628 
  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 10629 
    self.orderId = orderId
10630 
    self.invoice_number = invoice_number
4658 mandeep.dh 10631 
    self.serialNumber = serialNumber
4283 anupam.sin 10632 
    self.itemNumber = itemNumber
3064 chandransh 10633 
    self.billed_by = billed_by
4264 rajveer 10634 
    self.jacketNumber = jacketNumber
4283 anupam.sin 10635 
    self.billingType = billingType
10636 
    self.vendorId = vendorId
4763 rajveer 10637 
    self.authorize = authorize
1135 chandransh 10638 
 
10639 
  def read(self, iprot):
10640 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10641 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10642 
      return
10643 
    iprot.readStructBegin()
10644 
    while True:
10645 
      (fname, ftype, fid) = iprot.readFieldBegin()
10646 
      if ftype == TType.STOP:
10647 
        break
10648 
      if fid == 1:
10649 
        if ftype == TType.I64:
3064 chandransh 10650 
          self.orderId = iprot.readI64();
1135 chandransh 10651 
        else:
10652 
          iprot.skip(ftype)
10653 
      elif fid == 2:
3064 chandransh 10654 
        if ftype == TType.STRING:
10655 
          self.invoice_number = iprot.readString();
1135 chandransh 10656 
        else:
10657 
          iprot.skip(ftype)
3064 chandransh 10658 
      elif fid == 3:
4658 mandeep.dh 10659 
        if ftype == TType.STRING:
10660 
          self.serialNumber = iprot.readString();
3064 chandransh 10661 
        else:
10662 
          iprot.skip(ftype)
10663 
      elif fid == 4:
10664 
        if ftype == TType.STRING:
10665 
          self.itemNumber = iprot.readString();
10666 
        else:
10667 
          iprot.skip(ftype)
10668 
      elif fid == 5:
10669 
        if ftype == TType.STRING:
4283 anupam.sin 10670 
          self.billed_by = iprot.readString();
3064 chandransh 10671 
        else:
10672 
          iprot.skip(ftype)
10673 
      elif fid == 6:
10674 
        if ftype == TType.I64:
4283 anupam.sin 10675 
          self.jacketNumber = iprot.readI64();
10676 
        else:
10677 
          iprot.skip(ftype)
10678 
      elif fid == 7:
10679 
        if ftype == TType.I64:
3064 chandransh 10680 
          self.billingType = iprot.readI64();
10681 
        else:
10682 
          iprot.skip(ftype)
4283 anupam.sin 10683 
      elif fid == 8:
10684 
        if ftype == TType.I64:
10685 
          self.vendorId = iprot.readI64();
10686 
        else:
10687 
          iprot.skip(ftype)
4763 rajveer 10688 
      elif fid == 9:
10689 
        if ftype == TType.BOOL:
10690 
          self.authorize = iprot.readBool();
10691 
        else:
10692 
          iprot.skip(ftype)
1246 chandransh 10693 
      else:
10694 
        iprot.skip(ftype)
10695 
      iprot.readFieldEnd()
10696 
    iprot.readStructEnd()
10697 
 
10698 
  def write(self, oprot):
10699 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10700 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10701 
      return
4283 anupam.sin 10702 
    oprot.writeStructBegin('addBillingDetails_args')
3431 rajveer 10703 
    if self.orderId is not None:
3064 chandransh 10704 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
10705 
      oprot.writeI64(self.orderId)
1246 chandransh 10706 
      oprot.writeFieldEnd()
4283 anupam.sin 10707 
    if self.invoice_number is not None:
10708 
      oprot.writeFieldBegin('invoice_number', TType.STRING, 2)
10709 
      oprot.writeString(self.invoice_number)
1246 chandransh 10710 
      oprot.writeFieldEnd()
4658 mandeep.dh 10711 
    if self.serialNumber is not None:
10712 
      oprot.writeFieldBegin('serialNumber', TType.STRING, 3)
10713 
      oprot.writeString(self.serialNumber)
3064 chandransh 10714 
      oprot.writeFieldEnd()
3431 rajveer 10715 
    if self.itemNumber is not None:
3064 chandransh 10716 
      oprot.writeFieldBegin('itemNumber', TType.STRING, 4)
10717 
      oprot.writeString(self.itemNumber)
10718 
      oprot.writeFieldEnd()
4283 anupam.sin 10719 
    if self.billed_by is not None:
10720 
      oprot.writeFieldBegin('billed_by', TType.STRING, 5)
10721 
      oprot.writeString(self.billed_by)
3064 chandransh 10722 
      oprot.writeFieldEnd()
4283 anupam.sin 10723 
    if self.jacketNumber is not None:
10724 
      oprot.writeFieldBegin('jacketNumber', TType.I64, 6)
10725 
      oprot.writeI64(self.jacketNumber)
10726 
      oprot.writeFieldEnd()
3431 rajveer 10727 
    if self.billingType is not None:
4283 anupam.sin 10728 
      oprot.writeFieldBegin('billingType', TType.I64, 7)
3064 chandransh 10729 
      oprot.writeI64(self.billingType)
10730 
      oprot.writeFieldEnd()
4283 anupam.sin 10731 
    if self.vendorId is not None:
10732 
      oprot.writeFieldBegin('vendorId', TType.I64, 8)
10733 
      oprot.writeI64(self.vendorId)
10734 
      oprot.writeFieldEnd()
4763 rajveer 10735 
    if self.authorize is not None:
10736 
      oprot.writeFieldBegin('authorize', TType.BOOL, 9)
10737 
      oprot.writeBool(self.authorize)
10738 
      oprot.writeFieldEnd()
1246 chandransh 10739 
    oprot.writeFieldStop()
10740 
    oprot.writeStructEnd()
10741 
 
3431 rajveer 10742 
  def validate(self):
10743 
    return
10744 
 
10745 
 
1246 chandransh 10746 
  def __repr__(self):
10747 
    L = ['%s=%r' % (key, value)
10748 
      for key, value in self.__dict__.iteritems()]
10749 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10750 
 
10751 
  def __eq__(self, other):
10752 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10753 
 
10754 
  def __ne__(self, other):
10755 
    return not (self == other)
10756 
 
4283 anupam.sin 10757 
class addBillingDetails_result:
1246 chandransh 10758 
  """
10759 
  Attributes:
3064 chandransh 10760 
   - success
1246 chandransh 10761 
   - ex
10762 
  """
10763 
 
10764 
  thrift_spec = (
3064 chandransh 10765 
    (0, TType.BOOL, 'success', None, None, ), # 0
1246 chandransh 10766 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
10767 
  )
10768 
 
3064 chandransh 10769 
  def __init__(self, success=None, ex=None,):
10770 
    self.success = success
1246 chandransh 10771 
    self.ex = ex
10772 
 
10773 
  def read(self, iprot):
10774 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10775 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10776 
      return
10777 
    iprot.readStructBegin()
10778 
    while True:
10779 
      (fname, ftype, fid) = iprot.readFieldBegin()
10780 
      if ftype == TType.STOP:
10781 
        break
3064 chandransh 10782 
      if fid == 0:
10783 
        if ftype == TType.BOOL:
10784 
          self.success = iprot.readBool();
10785 
        else:
10786 
          iprot.skip(ftype)
10787 
      elif fid == 1:
1246 chandransh 10788 
        if ftype == TType.STRUCT:
10789 
          self.ex = TransactionServiceException()
10790 
          self.ex.read(iprot)
10791 
        else:
10792 
          iprot.skip(ftype)
10793 
      else:
10794 
        iprot.skip(ftype)
10795 
      iprot.readFieldEnd()
10796 
    iprot.readStructEnd()
10797 
 
10798 
  def write(self, oprot):
10799 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10800 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10801 
      return
4283 anupam.sin 10802 
    oprot.writeStructBegin('addBillingDetails_result')
3431 rajveer 10803 
    if self.success is not None:
3064 chandransh 10804 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
10805 
      oprot.writeBool(self.success)
10806 
      oprot.writeFieldEnd()
3431 rajveer 10807 
    if self.ex is not None:
1246 chandransh 10808 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
10809 
      self.ex.write(oprot)
10810 
      oprot.writeFieldEnd()
10811 
    oprot.writeFieldStop()
10812 
    oprot.writeStructEnd()
10813 
 
3431 rajveer 10814 
  def validate(self):
10815 
    return
10816 
 
10817 
 
1246 chandransh 10818 
  def __repr__(self):
10819 
    L = ['%s=%r' % (key, value)
10820 
      for key, value in self.__dict__.iteritems()]
10821 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10822 
 
10823 
  def __eq__(self, other):
10824 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10825 
 
10826 
  def __ne__(self, other):
10827 
    return not (self == other)
10828 
 
4579 rajveer 10829 
class addInvoiceNumber_args:
10830 
  """
10831 
  Attributes:
10832 
   - orderId
10833 
   - invoiceNumber
4763 rajveer 10834 
   - color
4579 rajveer 10835 
  """
10836 
 
10837 
  thrift_spec = (
10838 
    None, # 0
10839 
    (1, TType.I64, 'orderId', None, None, ), # 1
10840 
    (2, TType.STRING, 'invoiceNumber', None, None, ), # 2
4763 rajveer 10841 
    (3, TType.STRING, 'color', None, None, ), # 3
4579 rajveer 10842 
  )
10843 
 
4763 rajveer 10844 
  def __init__(self, orderId=None, invoiceNumber=None, color=None,):
4579 rajveer 10845 
    self.orderId = orderId
10846 
    self.invoiceNumber = invoiceNumber
4763 rajveer 10847 
    self.color = color
4579 rajveer 10848 
 
10849 
  def read(self, iprot):
10850 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10851 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10852 
      return
10853 
    iprot.readStructBegin()
10854 
    while True:
10855 
      (fname, ftype, fid) = iprot.readFieldBegin()
10856 
      if ftype == TType.STOP:
10857 
        break
10858 
      if fid == 1:
10859 
        if ftype == TType.I64:
10860 
          self.orderId = iprot.readI64();
10861 
        else:
10862 
          iprot.skip(ftype)
10863 
      elif fid == 2:
10864 
        if ftype == TType.STRING:
10865 
          self.invoiceNumber = iprot.readString();
10866 
        else:
10867 
          iprot.skip(ftype)
4763 rajveer 10868 
      elif fid == 3:
10869 
        if ftype == TType.STRING:
10870 
          self.color = iprot.readString();
10871 
        else:
10872 
          iprot.skip(ftype)
4579 rajveer 10873 
      else:
10874 
        iprot.skip(ftype)
10875 
      iprot.readFieldEnd()
10876 
    iprot.readStructEnd()
10877 
 
10878 
  def write(self, oprot):
10879 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10880 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10881 
      return
10882 
    oprot.writeStructBegin('addInvoiceNumber_args')
10883 
    if self.orderId is not None:
10884 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
10885 
      oprot.writeI64(self.orderId)
10886 
      oprot.writeFieldEnd()
10887 
    if self.invoiceNumber is not None:
10888 
      oprot.writeFieldBegin('invoiceNumber', TType.STRING, 2)
10889 
      oprot.writeString(self.invoiceNumber)
10890 
      oprot.writeFieldEnd()
4763 rajveer 10891 
    if self.color is not None:
10892 
      oprot.writeFieldBegin('color', TType.STRING, 3)
10893 
      oprot.writeString(self.color)
10894 
      oprot.writeFieldEnd()
4579 rajveer 10895 
    oprot.writeFieldStop()
10896 
    oprot.writeStructEnd()
10897 
 
10898 
  def validate(self):
10899 
    return
10900 
 
10901 
 
10902 
  def __repr__(self):
10903 
    L = ['%s=%r' % (key, value)
10904 
      for key, value in self.__dict__.iteritems()]
10905 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10906 
 
10907 
  def __eq__(self, other):
10908 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10909 
 
10910 
  def __ne__(self, other):
10911 
    return not (self == other)
10912 
 
10913 
class addInvoiceNumber_result:
10914 
  """
10915 
  Attributes:
10916 
   - ex
10917 
  """
10918 
 
10919 
  thrift_spec = (
10920 
    None, # 0
10921 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
10922 
  )
10923 
 
10924 
  def __init__(self, ex=None,):
10925 
    self.ex = ex
10926 
 
10927 
  def read(self, iprot):
10928 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10929 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10930 
      return
10931 
    iprot.readStructBegin()
10932 
    while True:
10933 
      (fname, ftype, fid) = iprot.readFieldBegin()
10934 
      if ftype == TType.STOP:
10935 
        break
10936 
      if fid == 1:
10937 
        if ftype == TType.STRUCT:
10938 
          self.ex = TransactionServiceException()
10939 
          self.ex.read(iprot)
10940 
        else:
10941 
          iprot.skip(ftype)
10942 
      else:
10943 
        iprot.skip(ftype)
10944 
      iprot.readFieldEnd()
10945 
    iprot.readStructEnd()
10946 
 
10947 
  def write(self, oprot):
10948 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10949 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10950 
      return
10951 
    oprot.writeStructBegin('addInvoiceNumber_result')
10952 
    if self.ex is not None:
10953 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
10954 
      self.ex.write(oprot)
10955 
      oprot.writeFieldEnd()
10956 
    oprot.writeFieldStop()
10957 
    oprot.writeStructEnd()
10958 
 
10959 
  def validate(self):
10960 
    return
10961 
 
10962 
 
10963 
  def __repr__(self):
10964 
    L = ['%s=%r' % (key, value)
10965 
      for key, value in self.__dict__.iteritems()]
10966 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10967 
 
10968 
  def __eq__(self, other):
10969 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10970 
 
10971 
  def __ne__(self, other):
10972 
    return not (self == other)
10973 
 
3064 chandransh 10974 
class markOrdersAsManifested_args:
1408 ankur.sing 10975 
  """
10976 
  Attributes:
3064 chandransh 10977 
   - warehouseId
1408 ankur.sing 10978 
   - providerId
3064 chandransh 10979 
   - cod
1408 ankur.sing 10980 
  """
10981 
 
10982 
  thrift_spec = (
10983 
    None, # 0
3064 chandransh 10984 
    (1, TType.I64, 'warehouseId', None, None, ), # 1
10985 
    (2, TType.I64, 'providerId', None, None, ), # 2
10986 
    (3, TType.BOOL, 'cod', None, None, ), # 3
1408 ankur.sing 10987 
  )
10988 
 
3064 chandransh 10989 
  def __init__(self, warehouseId=None, providerId=None, cod=None,):
10990 
    self.warehouseId = warehouseId
1408 ankur.sing 10991 
    self.providerId = providerId
3064 chandransh 10992 
    self.cod = cod
1408 ankur.sing 10993 
 
10994 
  def read(self, iprot):
10995 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10996 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10997 
      return
10998 
    iprot.readStructBegin()
10999 
    while True:
11000 
      (fname, ftype, fid) = iprot.readFieldBegin()
11001 
      if ftype == TType.STOP:
11002 
        break
11003 
      if fid == 1:
11004 
        if ftype == TType.I64:
3064 chandransh 11005 
          self.warehouseId = iprot.readI64();
1408 ankur.sing 11006 
        else:
11007 
          iprot.skip(ftype)
11008 
      elif fid == 2:
11009 
        if ftype == TType.I64:
3064 chandransh 11010 
          self.providerId = iprot.readI64();
1408 ankur.sing 11011 
        else:
11012 
          iprot.skip(ftype)
3064 chandransh 11013 
      elif fid == 3:
11014 
        if ftype == TType.BOOL:
11015 
          self.cod = iprot.readBool();
11016 
        else:
11017 
          iprot.skip(ftype)
1408 ankur.sing 11018 
      else:
11019 
        iprot.skip(ftype)
11020 
      iprot.readFieldEnd()
11021 
    iprot.readStructEnd()
11022 
 
11023 
  def write(self, oprot):
11024 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11025 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11026 
      return
3064 chandransh 11027 
    oprot.writeStructBegin('markOrdersAsManifested_args')
3431 rajveer 11028 
    if self.warehouseId is not None:
3064 chandransh 11029 
      oprot.writeFieldBegin('warehouseId', TType.I64, 1)
11030 
      oprot.writeI64(self.warehouseId)
11031 
      oprot.writeFieldEnd()
3431 rajveer 11032 
    if self.providerId is not None:
3064 chandransh 11033 
      oprot.writeFieldBegin('providerId', TType.I64, 2)
1408 ankur.sing 11034 
      oprot.writeI64(self.providerId)
11035 
      oprot.writeFieldEnd()
3431 rajveer 11036 
    if self.cod is not None:
3064 chandransh 11037 
      oprot.writeFieldBegin('cod', TType.BOOL, 3)
11038 
      oprot.writeBool(self.cod)
1408 ankur.sing 11039 
      oprot.writeFieldEnd()
11040 
    oprot.writeFieldStop()
11041 
    oprot.writeStructEnd()
11042 
 
3431 rajveer 11043 
  def validate(self):
11044 
    return
11045 
 
11046 
 
1408 ankur.sing 11047 
  def __repr__(self):
11048 
    L = ['%s=%r' % (key, value)
11049 
      for key, value in self.__dict__.iteritems()]
11050 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11051 
 
11052 
  def __eq__(self, other):
11053 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11054 
 
11055 
  def __ne__(self, other):
11056 
    return not (self == other)
11057 
 
3064 chandransh 11058 
class markOrdersAsManifested_result:
1408 ankur.sing 11059 
  """
11060 
  Attributes:
11061 
   - success
3064 chandransh 11062 
   - ex
1408 ankur.sing 11063 
  """
11064 
 
11065 
  thrift_spec = (
3064 chandransh 11066 
    (0, TType.BOOL, 'success', None, None, ), # 0
11067 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
1408 ankur.sing 11068 
  )
11069 
 
3064 chandransh 11070 
  def __init__(self, success=None, ex=None,):
1408 ankur.sing 11071 
    self.success = success
3064 chandransh 11072 
    self.ex = ex
1408 ankur.sing 11073 
 
11074 
  def read(self, iprot):
11075 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11076 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11077 
      return
11078 
    iprot.readStructBegin()
11079 
    while True:
11080 
      (fname, ftype, fid) = iprot.readFieldBegin()
11081 
      if ftype == TType.STOP:
11082 
        break
11083 
      if fid == 0:
3064 chandransh 11084 
        if ftype == TType.BOOL:
11085 
          self.success = iprot.readBool();
1408 ankur.sing 11086 
        else:
11087 
          iprot.skip(ftype)
3064 chandransh 11088 
      elif fid == 1:
11089 
        if ftype == TType.STRUCT:
11090 
          self.ex = TransactionServiceException()
11091 
          self.ex.read(iprot)
11092 
        else:
11093 
          iprot.skip(ftype)
1408 ankur.sing 11094 
      else:
11095 
        iprot.skip(ftype)
11096 
      iprot.readFieldEnd()
11097 
    iprot.readStructEnd()
11098 
 
11099 
  def write(self, oprot):
11100 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11101 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11102 
      return
3064 chandransh 11103 
    oprot.writeStructBegin('markOrdersAsManifested_result')
3431 rajveer 11104 
    if self.success is not None:
3064 chandransh 11105 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
11106 
      oprot.writeBool(self.success)
1408 ankur.sing 11107 
      oprot.writeFieldEnd()
3431 rajveer 11108 
    if self.ex is not None:
3064 chandransh 11109 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
11110 
      self.ex.write(oprot)
11111 
      oprot.writeFieldEnd()
1408 ankur.sing 11112 
    oprot.writeFieldStop()
11113 
    oprot.writeStructEnd()
11114 
 
3431 rajveer 11115 
  def validate(self):
11116 
    return
11117 
 
11118 
 
1408 ankur.sing 11119 
  def __repr__(self):
11120 
    L = ['%s=%r' % (key, value)
11121 
      for key, value in self.__dict__.iteritems()]
11122 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11123 
 
11124 
  def __eq__(self, other):
11125 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11126 
 
11127 
  def __ne__(self, other):
11128 
    return not (self == other)
11129 
 
4410 rajveer 11130 
class markOrdersAsShippedFromWarehouse_args:
11131 
  """
11132 
  Attributes:
11133 
   - warehouseId
11134 
   - providerId
11135 
   - cod
4789 rajveer 11136 
   - orderIds
4410 rajveer 11137 
  """
11138 
 
11139 
  thrift_spec = (
11140 
    None, # 0
11141 
    (1, TType.I64, 'warehouseId', None, None, ), # 1
11142 
    (2, TType.I64, 'providerId', None, None, ), # 2
11143 
    (3, TType.BOOL, 'cod', None, None, ), # 3
4789 rajveer 11144 
    (4, TType.LIST, 'orderIds', (TType.I64,None), None, ), # 4
4410 rajveer 11145 
  )
11146 
 
4789 rajveer 11147 
  def __init__(self, warehouseId=None, providerId=None, cod=None, orderIds=None,):
4410 rajveer 11148 
    self.warehouseId = warehouseId
11149 
    self.providerId = providerId
11150 
    self.cod = cod
4789 rajveer 11151 
    self.orderIds = orderIds
4410 rajveer 11152 
 
11153 
  def read(self, iprot):
11154 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11155 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11156 
      return
11157 
    iprot.readStructBegin()
11158 
    while True:
11159 
      (fname, ftype, fid) = iprot.readFieldBegin()
11160 
      if ftype == TType.STOP:
11161 
        break
11162 
      if fid == 1:
11163 
        if ftype == TType.I64:
11164 
          self.warehouseId = iprot.readI64();
11165 
        else:
11166 
          iprot.skip(ftype)
11167 
      elif fid == 2:
11168 
        if ftype == TType.I64:
11169 
          self.providerId = iprot.readI64();
11170 
        else:
11171 
          iprot.skip(ftype)
11172 
      elif fid == 3:
11173 
        if ftype == TType.BOOL:
11174 
          self.cod = iprot.readBool();
11175 
        else:
11176 
          iprot.skip(ftype)
4789 rajveer 11177 
      elif fid == 4:
11178 
        if ftype == TType.LIST:
11179 
          self.orderIds = []
4837 varun.gupt 11180 
          (_etype178, _size175) = iprot.readListBegin()
11181 
          for _i179 in xrange(_size175):
11182 
            _elem180 = iprot.readI64();
11183 
            self.orderIds.append(_elem180)
4789 rajveer 11184 
          iprot.readListEnd()
11185 
        else:
11186 
          iprot.skip(ftype)
4410 rajveer 11187 
      else:
11188 
        iprot.skip(ftype)
11189 
      iprot.readFieldEnd()
11190 
    iprot.readStructEnd()
11191 
 
11192 
  def write(self, oprot):
11193 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11194 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11195 
      return
11196 
    oprot.writeStructBegin('markOrdersAsShippedFromWarehouse_args')
11197 
    if self.warehouseId is not None:
11198 
      oprot.writeFieldBegin('warehouseId', TType.I64, 1)
11199 
      oprot.writeI64(self.warehouseId)
11200 
      oprot.writeFieldEnd()
11201 
    if self.providerId is not None:
11202 
      oprot.writeFieldBegin('providerId', TType.I64, 2)
11203 
      oprot.writeI64(self.providerId)
11204 
      oprot.writeFieldEnd()
11205 
    if self.cod is not None:
11206 
      oprot.writeFieldBegin('cod', TType.BOOL, 3)
11207 
      oprot.writeBool(self.cod)
11208 
      oprot.writeFieldEnd()
4789 rajveer 11209 
    if self.orderIds is not None:
11210 
      oprot.writeFieldBegin('orderIds', TType.LIST, 4)
11211 
      oprot.writeListBegin(TType.I64, len(self.orderIds))
4837 varun.gupt 11212 
      for iter181 in self.orderIds:
11213 
        oprot.writeI64(iter181)
4789 rajveer 11214 
      oprot.writeListEnd()
11215 
      oprot.writeFieldEnd()
4410 rajveer 11216 
    oprot.writeFieldStop()
11217 
    oprot.writeStructEnd()
11218 
 
11219 
  def validate(self):
11220 
    return
11221 
 
11222 
 
11223 
  def __repr__(self):
11224 
    L = ['%s=%r' % (key, value)
11225 
      for key, value in self.__dict__.iteritems()]
11226 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11227 
 
11228 
  def __eq__(self, other):
11229 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11230 
 
11231 
  def __ne__(self, other):
11232 
    return not (self == other)
11233 
 
11234 
class markOrdersAsShippedFromWarehouse_result:
11235 
  """
11236 
  Attributes:
11237 
   - success
11238 
   - ex
11239 
  """
11240 
 
11241 
  thrift_spec = (
11242 
    (0, TType.BOOL, 'success', None, None, ), # 0
11243 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
11244 
  )
11245 
 
11246 
  def __init__(self, success=None, ex=None,):
11247 
    self.success = success
11248 
    self.ex = ex
11249 
 
11250 
  def read(self, iprot):
11251 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11252 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11253 
      return
11254 
    iprot.readStructBegin()
11255 
    while True:
11256 
      (fname, ftype, fid) = iprot.readFieldBegin()
11257 
      if ftype == TType.STOP:
11258 
        break
11259 
      if fid == 0:
11260 
        if ftype == TType.BOOL:
11261 
          self.success = iprot.readBool();
11262 
        else:
11263 
          iprot.skip(ftype)
11264 
      elif fid == 1:
11265 
        if ftype == TType.STRUCT:
11266 
          self.ex = TransactionServiceException()
11267 
          self.ex.read(iprot)
11268 
        else:
11269 
          iprot.skip(ftype)
11270 
      else:
11271 
        iprot.skip(ftype)
11272 
      iprot.readFieldEnd()
11273 
    iprot.readStructEnd()
11274 
 
11275 
  def write(self, oprot):
11276 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11277 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11278 
      return
11279 
    oprot.writeStructBegin('markOrdersAsShippedFromWarehouse_result')
11280 
    if self.success is not None:
11281 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
11282 
      oprot.writeBool(self.success)
11283 
      oprot.writeFieldEnd()
11284 
    if self.ex is not None:
11285 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
11286 
      self.ex.write(oprot)
11287 
      oprot.writeFieldEnd()
11288 
    oprot.writeFieldStop()
11289 
    oprot.writeStructEnd()
11290 
 
11291 
  def validate(self):
11292 
    return
11293 
 
11294 
 
11295 
  def __repr__(self):
11296 
    L = ['%s=%r' % (key, value)
11297 
      for key, value in self.__dict__.iteritems()]
11298 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11299 
 
11300 
  def __eq__(self, other):
11301 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11302 
 
11303 
  def __ne__(self, other):
11304 
    return not (self == other)
11305 
 
3064 chandransh 11306 
class markOrdersAsPickedUp_args:
304 ashish 11307 
  """
11308 
  Attributes:
3064 chandransh 11309 
   - providerId
11310 
   - pickupDetails
304 ashish 11311 
  """
94 ashish 11312 
 
304 ashish 11313 
  thrift_spec = (
11314 
    None, # 0
3064 chandransh 11315 
    (1, TType.I64, 'providerId', None, None, ), # 1
11316 
    (2, TType.MAP, 'pickupDetails', (TType.STRING,None,TType.STRING,None), None, ), # 2
304 ashish 11317 
  )
11318 
 
3064 chandransh 11319 
  def __init__(self, providerId=None, pickupDetails=None,):
11320 
    self.providerId = providerId
11321 
    self.pickupDetails = pickupDetails
304 ashish 11322 
 
11323 
  def read(self, iprot):
11324 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11325 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11326 
      return
11327 
    iprot.readStructBegin()
11328 
    while True:
11329 
      (fname, ftype, fid) = iprot.readFieldBegin()
11330 
      if ftype == TType.STOP:
11331 
        break
11332 
      if fid == 1:
11333 
        if ftype == TType.I64:
3064 chandransh 11334 
          self.providerId = iprot.readI64();
304 ashish 11335 
        else:
11336 
          iprot.skip(ftype)
11337 
      elif fid == 2:
3064 chandransh 11338 
        if ftype == TType.MAP:
11339 
          self.pickupDetails = {}
4837 varun.gupt 11340 
          (_ktype183, _vtype184, _size182 ) = iprot.readMapBegin()
11341 
          for _i186 in xrange(_size182):
11342 
            _key187 = iprot.readString();
11343 
            _val188 = iprot.readString();
11344 
            self.pickupDetails[_key187] = _val188
3064 chandransh 11345 
          iprot.readMapEnd()
304 ashish 11346 
        else:
11347 
          iprot.skip(ftype)
11348 
      else:
11349 
        iprot.skip(ftype)
11350 
      iprot.readFieldEnd()
11351 
    iprot.readStructEnd()
11352 
 
11353 
  def write(self, oprot):
11354 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11355 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11356 
      return
3064 chandransh 11357 
    oprot.writeStructBegin('markOrdersAsPickedUp_args')
3431 rajveer 11358 
    if self.providerId is not None:
3064 chandransh 11359 
      oprot.writeFieldBegin('providerId', TType.I64, 1)
11360 
      oprot.writeI64(self.providerId)
304 ashish 11361 
      oprot.writeFieldEnd()
3431 rajveer 11362 
    if self.pickupDetails is not None:
3064 chandransh 11363 
      oprot.writeFieldBegin('pickupDetails', TType.MAP, 2)
11364 
      oprot.writeMapBegin(TType.STRING, TType.STRING, len(self.pickupDetails))
4837 varun.gupt 11365 
      for kiter189,viter190 in self.pickupDetails.items():
11366 
        oprot.writeString(kiter189)
11367 
        oprot.writeString(viter190)
3064 chandransh 11368 
      oprot.writeMapEnd()
304 ashish 11369 
      oprot.writeFieldEnd()
11370 
    oprot.writeFieldStop()
11371 
    oprot.writeStructEnd()
11372 
 
3431 rajveer 11373 
  def validate(self):
11374 
    return
11375 
 
11376 
 
304 ashish 11377 
  def __repr__(self):
11378 
    L = ['%s=%r' % (key, value)
11379 
      for key, value in self.__dict__.iteritems()]
11380 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11381 
 
11382 
  def __eq__(self, other):
11383 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11384 
 
11385 
  def __ne__(self, other):
11386 
    return not (self == other)
11387 
 
3064 chandransh 11388 
class markOrdersAsPickedUp_result:
304 ashish 11389 
  """
11390 
  Attributes:
11391 
   - success
3064 chandransh 11392 
   - ex
304 ashish 11393 
  """
11394 
 
11395 
  thrift_spec = (
3064 chandransh 11396 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
11397 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
304 ashish 11398 
  )
11399 
 
3064 chandransh 11400 
  def __init__(self, success=None, ex=None,):
304 ashish 11401 
    self.success = success
3064 chandransh 11402 
    self.ex = ex
304 ashish 11403 
 
11404 
  def read(self, iprot):
11405 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11406 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11407 
      return
11408 
    iprot.readStructBegin()
11409 
    while True:
11410 
      (fname, ftype, fid) = iprot.readFieldBegin()
11411 
      if ftype == TType.STOP:
11412 
        break
11413 
      if fid == 0:
11414 
        if ftype == TType.LIST:
11415 
          self.success = []
4837 varun.gupt 11416 
          (_etype194, _size191) = iprot.readListBegin()
11417 
          for _i195 in xrange(_size191):
11418 
            _elem196 = Order()
11419 
            _elem196.read(iprot)
11420 
            self.success.append(_elem196)
304 ashish 11421 
          iprot.readListEnd()
11422 
        else:
11423 
          iprot.skip(ftype)
3064 chandransh 11424 
      elif fid == 1:
11425 
        if ftype == TType.STRUCT:
11426 
          self.ex = TransactionServiceException()
11427 
          self.ex.read(iprot)
11428 
        else:
11429 
          iprot.skip(ftype)
304 ashish 11430 
      else:
11431 
        iprot.skip(ftype)
11432 
      iprot.readFieldEnd()
11433 
    iprot.readStructEnd()
11434 
 
11435 
  def write(self, oprot):
11436 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11437 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11438 
      return
3064 chandransh 11439 
    oprot.writeStructBegin('markOrdersAsPickedUp_result')
3431 rajveer 11440 
    if self.success is not None:
304 ashish 11441 
      oprot.writeFieldBegin('success', TType.LIST, 0)
11442 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
4837 varun.gupt 11443 
      for iter197 in self.success:
11444 
        iter197.write(oprot)
304 ashish 11445 
      oprot.writeListEnd()
11446 
      oprot.writeFieldEnd()
3431 rajveer 11447 
    if self.ex is not None:
3064 chandransh 11448 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
11449 
      self.ex.write(oprot)
11450 
      oprot.writeFieldEnd()
304 ashish 11451 
    oprot.writeFieldStop()
11452 
    oprot.writeStructEnd()
11453 
 
3431 rajveer 11454 
  def validate(self):
11455 
    return
11456 
 
11457 
 
304 ashish 11458 
  def __repr__(self):
11459 
    L = ['%s=%r' % (key, value)
11460 
      for key, value in self.__dict__.iteritems()]
11461 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11462 
 
11463 
  def __eq__(self, other):
11464 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11465 
 
11466 
  def __ne__(self, other):
11467 
    return not (self == other)
11468 
 
3064 chandransh 11469 
class markOrdersAsDelivered_args:
304 ashish 11470 
  """
11471 
  Attributes:
3064 chandransh 11472 
   - providerId
11473 
   - deliveredOrders
304 ashish 11474 
  """
11475 
 
11476 
  thrift_spec = (
11477 
    None, # 0
3064 chandransh 11478 
    (1, TType.I64, 'providerId', None, None, ), # 1
11479 
    (2, TType.MAP, 'deliveredOrders', (TType.STRING,None,TType.STRING,None), None, ), # 2
304 ashish 11480 
  )
11481 
 
3064 chandransh 11482 
  def __init__(self, providerId=None, deliveredOrders=None,):
11483 
    self.providerId = providerId
11484 
    self.deliveredOrders = deliveredOrders
304 ashish 11485 
 
11486 
  def read(self, iprot):
11487 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11488 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11489 
      return
11490 
    iprot.readStructBegin()
11491 
    while True:
11492 
      (fname, ftype, fid) = iprot.readFieldBegin()
11493 
      if ftype == TType.STOP:
11494 
        break
11495 
      if fid == 1:
11496 
        if ftype == TType.I64:
3064 chandransh 11497 
          self.providerId = iprot.readI64();
304 ashish 11498 
        else:
11499 
          iprot.skip(ftype)
11500 
      elif fid == 2:
3064 chandransh 11501 
        if ftype == TType.MAP:
11502 
          self.deliveredOrders = {}
4837 varun.gupt 11503 
          (_ktype199, _vtype200, _size198 ) = iprot.readMapBegin()
11504 
          for _i202 in xrange(_size198):
11505 
            _key203 = iprot.readString();
11506 
            _val204 = iprot.readString();
11507 
            self.deliveredOrders[_key203] = _val204
3064 chandransh 11508 
          iprot.readMapEnd()
304 ashish 11509 
        else:
11510 
          iprot.skip(ftype)
11511 
      else:
11512 
        iprot.skip(ftype)
11513 
      iprot.readFieldEnd()
11514 
    iprot.readStructEnd()
11515 
 
11516 
  def write(self, oprot):
11517 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11518 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11519 
      return
3064 chandransh 11520 
    oprot.writeStructBegin('markOrdersAsDelivered_args')
3431 rajveer 11521 
    if self.providerId is not None:
3064 chandransh 11522 
      oprot.writeFieldBegin('providerId', TType.I64, 1)
11523 
      oprot.writeI64(self.providerId)
304 ashish 11524 
      oprot.writeFieldEnd()
3431 rajveer 11525 
    if self.deliveredOrders is not None:
3064 chandransh 11526 
      oprot.writeFieldBegin('deliveredOrders', TType.MAP, 2)
11527 
      oprot.writeMapBegin(TType.STRING, TType.STRING, len(self.deliveredOrders))
4837 varun.gupt 11528 
      for kiter205,viter206 in self.deliveredOrders.items():
11529 
        oprot.writeString(kiter205)
11530 
        oprot.writeString(viter206)
3064 chandransh 11531 
      oprot.writeMapEnd()
304 ashish 11532 
      oprot.writeFieldEnd()
11533 
    oprot.writeFieldStop()
11534 
    oprot.writeStructEnd()
11535 
 
3431 rajveer 11536 
  def validate(self):
11537 
    return
11538 
 
11539 
 
304 ashish 11540 
  def __repr__(self):
11541 
    L = ['%s=%r' % (key, value)
11542 
      for key, value in self.__dict__.iteritems()]
11543 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11544 
 
11545 
  def __eq__(self, other):
11546 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11547 
 
11548 
  def __ne__(self, other):
11549 
    return not (self == other)
11550 
 
3064 chandransh 11551 
class markOrdersAsDelivered_result:
11552 
  """
11553 
  Attributes:
11554 
   - ex
11555 
  """
304 ashish 11556 
 
11557 
  thrift_spec = (
3064 chandransh 11558 
    None, # 0
11559 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
304 ashish 11560 
  )
11561 
 
3064 chandransh 11562 
  def __init__(self, ex=None,):
11563 
    self.ex = ex
304 ashish 11564 
 
1596 ankur.sing 11565 
  def read(self, iprot):
11566 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11567 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11568 
      return
11569 
    iprot.readStructBegin()
11570 
    while True:
11571 
      (fname, ftype, fid) = iprot.readFieldBegin()
11572 
      if ftype == TType.STOP:
11573 
        break
3064 chandransh 11574 
      if fid == 1:
11575 
        if ftype == TType.STRUCT:
11576 
          self.ex = TransactionServiceException()
11577 
          self.ex.read(iprot)
11578 
        else:
11579 
          iprot.skip(ftype)
1596 ankur.sing 11580 
      else:
11581 
        iprot.skip(ftype)
11582 
      iprot.readFieldEnd()
11583 
    iprot.readStructEnd()
11584 
 
11585 
  def write(self, oprot):
11586 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11587 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11588 
      return
3064 chandransh 11589 
    oprot.writeStructBegin('markOrdersAsDelivered_result')
3431 rajveer 11590 
    if self.ex is not None:
3064 chandransh 11591 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
11592 
      self.ex.write(oprot)
11593 
      oprot.writeFieldEnd()
1596 ankur.sing 11594 
    oprot.writeFieldStop()
11595 
    oprot.writeStructEnd()
11596 
 
3431 rajveer 11597 
  def validate(self):
11598 
    return
11599 
 
11600 
 
1596 ankur.sing 11601 
  def __repr__(self):
11602 
    L = ['%s=%r' % (key, value)
11603 
      for key, value in self.__dict__.iteritems()]
11604 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11605 
 
11606 
  def __eq__(self, other):
11607 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11608 
 
11609 
  def __ne__(self, other):
11610 
    return not (self == other)
11611 
 
3064 chandransh 11612 
class markOrdersAsFailed_args:
1596 ankur.sing 11613 
  """
11614 
  Attributes:
3064 chandransh 11615 
   - providerId
11616 
   - returnedOrders
1596 ankur.sing 11617 
  """
11618 
 
11619 
  thrift_spec = (
3064 chandransh 11620 
    None, # 0
11621 
    (1, TType.I64, 'providerId', None, None, ), # 1
11622 
    (2, TType.MAP, 'returnedOrders', (TType.STRING,None,TType.STRING,None), None, ), # 2
1596 ankur.sing 11623 
  )
11624 
 
3064 chandransh 11625 
  def __init__(self, providerId=None, returnedOrders=None,):
11626 
    self.providerId = providerId
11627 
    self.returnedOrders = returnedOrders
1596 ankur.sing 11628 
 
11629 
  def read(self, iprot):
11630 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11631 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11632 
      return
11633 
    iprot.readStructBegin()
11634 
    while True:
11635 
      (fname, ftype, fid) = iprot.readFieldBegin()
11636 
      if ftype == TType.STOP:
11637 
        break
3064 chandransh 11638 
      if fid == 1:
1596 ankur.sing 11639 
        if ftype == TType.I64:
3064 chandransh 11640 
          self.providerId = iprot.readI64();
1596 ankur.sing 11641 
        else:
11642 
          iprot.skip(ftype)
3064 chandransh 11643 
      elif fid == 2:
11644 
        if ftype == TType.MAP:
11645 
          self.returnedOrders = {}
4837 varun.gupt 11646 
          (_ktype208, _vtype209, _size207 ) = iprot.readMapBegin()
11647 
          for _i211 in xrange(_size207):
11648 
            _key212 = iprot.readString();
11649 
            _val213 = iprot.readString();
11650 
            self.returnedOrders[_key212] = _val213
3064 chandransh 11651 
          iprot.readMapEnd()
11652 
        else:
11653 
          iprot.skip(ftype)
1596 ankur.sing 11654 
      else:
11655 
        iprot.skip(ftype)
11656 
      iprot.readFieldEnd()
11657 
    iprot.readStructEnd()
11658 
 
11659 
  def write(self, oprot):
11660 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11661 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11662 
      return
3064 chandransh 11663 
    oprot.writeStructBegin('markOrdersAsFailed_args')
3431 rajveer 11664 
    if self.providerId is not None:
3064 chandransh 11665 
      oprot.writeFieldBegin('providerId', TType.I64, 1)
11666 
      oprot.writeI64(self.providerId)
1596 ankur.sing 11667 
      oprot.writeFieldEnd()
3431 rajveer 11668 
    if self.returnedOrders is not None:
3064 chandransh 11669 
      oprot.writeFieldBegin('returnedOrders', TType.MAP, 2)
11670 
      oprot.writeMapBegin(TType.STRING, TType.STRING, len(self.returnedOrders))
4837 varun.gupt 11671 
      for kiter214,viter215 in self.returnedOrders.items():
11672 
        oprot.writeString(kiter214)
11673 
        oprot.writeString(viter215)
3064 chandransh 11674 
      oprot.writeMapEnd()
11675 
      oprot.writeFieldEnd()
1596 ankur.sing 11676 
    oprot.writeFieldStop()
11677 
    oprot.writeStructEnd()
11678 
 
3431 rajveer 11679 
  def validate(self):
11680 
    return
11681 
 
11682 
 
1596 ankur.sing 11683 
  def __repr__(self):
11684 
    L = ['%s=%r' % (key, value)
11685 
      for key, value in self.__dict__.iteritems()]
11686 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11687 
 
11688 
  def __eq__(self, other):
11689 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11690 
 
11691 
  def __ne__(self, other):
11692 
    return not (self == other)
11693 
 
3064 chandransh 11694 
class markOrdersAsFailed_result:
11695 
  """
11696 
  Attributes:
11697 
   - ex
11698 
  """
1596 ankur.sing 11699 
 
1627 ankur.sing 11700 
  thrift_spec = (
3064 chandransh 11701 
    None, # 0
11702 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
1627 ankur.sing 11703 
  )
11704 
 
3064 chandransh 11705 
  def __init__(self, ex=None,):
11706 
    self.ex = ex
11707 
 
1627 ankur.sing 11708 
  def read(self, iprot):
11709 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11710 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11711 
      return
11712 
    iprot.readStructBegin()
11713 
    while True:
11714 
      (fname, ftype, fid) = iprot.readFieldBegin()
11715 
      if ftype == TType.STOP:
11716 
        break
3064 chandransh 11717 
      if fid == 1:
11718 
        if ftype == TType.STRUCT:
11719 
          self.ex = TransactionServiceException()
11720 
          self.ex.read(iprot)
11721 
        else:
11722 
          iprot.skip(ftype)
1627 ankur.sing 11723 
      else:
11724 
        iprot.skip(ftype)
11725 
      iprot.readFieldEnd()
11726 
    iprot.readStructEnd()
11727 
 
11728 
  def write(self, oprot):
11729 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11730 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11731 
      return
3064 chandransh 11732 
    oprot.writeStructBegin('markOrdersAsFailed_result')
3431 rajveer 11733 
    if self.ex is not None:
3064 chandransh 11734 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
11735 
      self.ex.write(oprot)
11736 
      oprot.writeFieldEnd()
1627 ankur.sing 11737 
    oprot.writeFieldStop()
11738 
    oprot.writeStructEnd()
11739 
 
3431 rajveer 11740 
  def validate(self):
11741 
    return
11742 
 
11743 
 
1627 ankur.sing 11744 
  def __repr__(self):
11745 
    L = ['%s=%r' % (key, value)
11746 
      for key, value in self.__dict__.iteritems()]
11747 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11748 
 
11749 
  def __eq__(self, other):
11750 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11751 
 
11752 
  def __ne__(self, other):
11753 
    return not (self == other)
11754 
 
3064 chandransh 11755 
class updateNonDeliveryReason_args:
1627 ankur.sing 11756 
  """
11757 
  Attributes:
3064 chandransh 11758 
   - providerId
11759 
   - undeliveredOrders
1627 ankur.sing 11760 
  """
11761 
 
11762 
  thrift_spec = (
3064 chandransh 11763 
    None, # 0
11764 
    (1, TType.I64, 'providerId', None, None, ), # 1
11765 
    (2, TType.MAP, 'undeliveredOrders', (TType.STRING,None,TType.STRING,None), None, ), # 2
1627 ankur.sing 11766 
  )
11767 
 
3064 chandransh 11768 
  def __init__(self, providerId=None, undeliveredOrders=None,):
11769 
    self.providerId = providerId
11770 
    self.undeliveredOrders = undeliveredOrders
1627 ankur.sing 11771 
 
11772 
  def read(self, iprot):
11773 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11774 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11775 
      return
11776 
    iprot.readStructBegin()
11777 
    while True:
11778 
      (fname, ftype, fid) = iprot.readFieldBegin()
11779 
      if ftype == TType.STOP:
11780 
        break
3064 chandransh 11781 
      if fid == 1:
1627 ankur.sing 11782 
        if ftype == TType.I64:
3064 chandransh 11783 
          self.providerId = iprot.readI64();
1627 ankur.sing 11784 
        else:
11785 
          iprot.skip(ftype)
3064 chandransh 11786 
      elif fid == 2:
11787 
        if ftype == TType.MAP:
11788 
          self.undeliveredOrders = {}
4837 varun.gupt 11789 
          (_ktype217, _vtype218, _size216 ) = iprot.readMapBegin()
11790 
          for _i220 in xrange(_size216):
11791 
            _key221 = iprot.readString();
11792 
            _val222 = iprot.readString();
11793 
            self.undeliveredOrders[_key221] = _val222
3064 chandransh 11794 
          iprot.readMapEnd()
11795 
        else:
11796 
          iprot.skip(ftype)
1627 ankur.sing 11797 
      else:
11798 
        iprot.skip(ftype)
11799 
      iprot.readFieldEnd()
11800 
    iprot.readStructEnd()
11801 
 
11802 
  def write(self, oprot):
11803 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11804 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11805 
      return
3064 chandransh 11806 
    oprot.writeStructBegin('updateNonDeliveryReason_args')
3431 rajveer 11807 
    if self.providerId is not None:
3064 chandransh 11808 
      oprot.writeFieldBegin('providerId', TType.I64, 1)
11809 
      oprot.writeI64(self.providerId)
1627 ankur.sing 11810 
      oprot.writeFieldEnd()
3431 rajveer 11811 
    if self.undeliveredOrders is not None:
3064 chandransh 11812 
      oprot.writeFieldBegin('undeliveredOrders', TType.MAP, 2)
11813 
      oprot.writeMapBegin(TType.STRING, TType.STRING, len(self.undeliveredOrders))
4837 varun.gupt 11814 
      for kiter223,viter224 in self.undeliveredOrders.items():
11815 
        oprot.writeString(kiter223)
11816 
        oprot.writeString(viter224)
3064 chandransh 11817 
      oprot.writeMapEnd()
11818 
      oprot.writeFieldEnd()
1627 ankur.sing 11819 
    oprot.writeFieldStop()
11820 
    oprot.writeStructEnd()
11821 
 
3431 rajveer 11822 
  def validate(self):
11823 
    return
11824 
 
11825 
 
1627 ankur.sing 11826 
  def __repr__(self):
11827 
    L = ['%s=%r' % (key, value)
11828 
      for key, value in self.__dict__.iteritems()]
11829 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11830 
 
11831 
  def __eq__(self, other):
11832 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11833 
 
11834 
  def __ne__(self, other):
11835 
    return not (self == other)
11836 
 
3064 chandransh 11837 
class updateNonDeliveryReason_result:
1627 ankur.sing 11838 
  """
11839 
  Attributes:
4581 phani.kuma 11840 
   - success
3064 chandransh 11841 
   - ex
1627 ankur.sing 11842 
  """
11843 
 
11844 
  thrift_spec = (
4581 phani.kuma 11845 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
3064 chandransh 11846 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
1627 ankur.sing 11847 
  )
11848 
 
4581 phani.kuma 11849 
  def __init__(self, success=None, ex=None,):
11850 
    self.success = success
3064 chandransh 11851 
    self.ex = ex
1627 ankur.sing 11852 
 
11853 
  def read(self, iprot):
11854 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11855 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11856 
      return
11857 
    iprot.readStructBegin()
11858 
    while True:
11859 
      (fname, ftype, fid) = iprot.readFieldBegin()
11860 
      if ftype == TType.STOP:
11861 
        break
4581 phani.kuma 11862 
      if fid == 0:
11863 
        if ftype == TType.LIST:
11864 
          self.success = []
4837 varun.gupt 11865 
          (_etype228, _size225) = iprot.readListBegin()
11866 
          for _i229 in xrange(_size225):
11867 
            _elem230 = Order()
11868 
            _elem230.read(iprot)
11869 
            self.success.append(_elem230)
4581 phani.kuma 11870 
          iprot.readListEnd()
11871 
        else:
11872 
          iprot.skip(ftype)
11873 
      elif fid == 1:
3064 chandransh 11874 
        if ftype == TType.STRUCT:
11875 
          self.ex = TransactionServiceException()
11876 
          self.ex.read(iprot)
1627 ankur.sing 11877 
        else:
11878 
          iprot.skip(ftype)
11879 
      else:
11880 
        iprot.skip(ftype)
11881 
      iprot.readFieldEnd()
11882 
    iprot.readStructEnd()
11883 
 
11884 
  def write(self, oprot):
11885 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11886 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11887 
      return
3064 chandransh 11888 
    oprot.writeStructBegin('updateNonDeliveryReason_result')
4581 phani.kuma 11889 
    if self.success is not None:
11890 
      oprot.writeFieldBegin('success', TType.LIST, 0)
11891 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
4837 varun.gupt 11892 
      for iter231 in self.success:
11893 
        iter231.write(oprot)
4581 phani.kuma 11894 
      oprot.writeListEnd()
11895 
      oprot.writeFieldEnd()
3431 rajveer 11896 
    if self.ex is not None:
3064 chandransh 11897 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
11898 
      self.ex.write(oprot)
1627 ankur.sing 11899 
      oprot.writeFieldEnd()
11900 
    oprot.writeFieldStop()
11901 
    oprot.writeStructEnd()
11902 
 
3431 rajveer 11903 
  def validate(self):
11904 
    return
11905 
 
11906 
 
1627 ankur.sing 11907 
  def __repr__(self):
11908 
    L = ['%s=%r' % (key, value)
11909 
      for key, value in self.__dict__.iteritems()]
11910 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11911 
 
11912 
  def __eq__(self, other):
11913 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11914 
 
11915 
  def __ne__(self, other):
11916 
    return not (self == other)
11917 
 
3064 chandransh 11918 
class getUndeliveredOrders_args:
1886 ankur.sing 11919 
  """
11920 
  Attributes:
3064 chandransh 11921 
   - providerId
11922 
   - warehouseId
1886 ankur.sing 11923 
  """
1627 ankur.sing 11924 
 
1886 ankur.sing 11925 
  thrift_spec = (
11926 
    None, # 0
3064 chandransh 11927 
    (1, TType.I64, 'providerId', None, None, ), # 1
11928 
    (2, TType.I64, 'warehouseId', None, None, ), # 2
1886 ankur.sing 11929 
  )
11930 
 
3064 chandransh 11931 
  def __init__(self, providerId=None, warehouseId=None,):
11932 
    self.providerId = providerId
11933 
    self.warehouseId = warehouseId
1886 ankur.sing 11934 
 
11935 
  def read(self, iprot):
11936 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11937 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11938 
      return
11939 
    iprot.readStructBegin()
11940 
    while True:
11941 
      (fname, ftype, fid) = iprot.readFieldBegin()
11942 
      if ftype == TType.STOP:
11943 
        break
11944 
      if fid == 1:
11945 
        if ftype == TType.I64:
3064 chandransh 11946 
          self.providerId = iprot.readI64();
1886 ankur.sing 11947 
        else:
11948 
          iprot.skip(ftype)
3064 chandransh 11949 
      elif fid == 2:
11950 
        if ftype == TType.I64:
11951 
          self.warehouseId = iprot.readI64();
11952 
        else:
11953 
          iprot.skip(ftype)
1886 ankur.sing 11954 
      else:
11955 
        iprot.skip(ftype)
11956 
      iprot.readFieldEnd()
11957 
    iprot.readStructEnd()
11958 
 
11959 
  def write(self, oprot):
11960 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11961 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11962 
      return
3064 chandransh 11963 
    oprot.writeStructBegin('getUndeliveredOrders_args')
3431 rajveer 11964 
    if self.providerId is not None:
3064 chandransh 11965 
      oprot.writeFieldBegin('providerId', TType.I64, 1)
11966 
      oprot.writeI64(self.providerId)
1886 ankur.sing 11967 
      oprot.writeFieldEnd()
3431 rajveer 11968 
    if self.warehouseId is not None:
3064 chandransh 11969 
      oprot.writeFieldBegin('warehouseId', TType.I64, 2)
11970 
      oprot.writeI64(self.warehouseId)
11971 
      oprot.writeFieldEnd()
1886 ankur.sing 11972 
    oprot.writeFieldStop()
11973 
    oprot.writeStructEnd()
11974 
 
3431 rajveer 11975 
  def validate(self):
11976 
    return
11977 
 
11978 
 
1886 ankur.sing 11979 
  def __repr__(self):
11980 
    L = ['%s=%r' % (key, value)
11981 
      for key, value in self.__dict__.iteritems()]
11982 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11983 
 
11984 
  def __eq__(self, other):
11985 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11986 
 
11987 
  def __ne__(self, other):
11988 
    return not (self == other)
11989 
 
3064 chandransh 11990 
class getUndeliveredOrders_result:
1886 ankur.sing 11991 
  """
11992 
  Attributes:
11993 
   - success
11994 
  """
11995 
 
11996 
  thrift_spec = (
11997 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
11998 
  )
11999 
 
12000 
  def __init__(self, success=None,):
12001 
    self.success = success
12002 
 
12003 
  def read(self, iprot):
12004 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12005 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12006 
      return
12007 
    iprot.readStructBegin()
12008 
    while True:
12009 
      (fname, ftype, fid) = iprot.readFieldBegin()
12010 
      if ftype == TType.STOP:
12011 
        break
12012 
      if fid == 0:
12013 
        if ftype == TType.LIST:
12014 
          self.success = []
4837 varun.gupt 12015 
          (_etype235, _size232) = iprot.readListBegin()
12016 
          for _i236 in xrange(_size232):
12017 
            _elem237 = Order()
12018 
            _elem237.read(iprot)
12019 
            self.success.append(_elem237)
1886 ankur.sing 12020 
          iprot.readListEnd()
12021 
        else:
12022 
          iprot.skip(ftype)
12023 
      else:
12024 
        iprot.skip(ftype)
12025 
      iprot.readFieldEnd()
12026 
    iprot.readStructEnd()
12027 
 
12028 
  def write(self, oprot):
12029 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12030 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12031 
      return
3064 chandransh 12032 
    oprot.writeStructBegin('getUndeliveredOrders_result')
3431 rajveer 12033 
    if self.success is not None:
1886 ankur.sing 12034 
      oprot.writeFieldBegin('success', TType.LIST, 0)
12035 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
4837 varun.gupt 12036 
      for iter238 in self.success:
12037 
        iter238.write(oprot)
1886 ankur.sing 12038 
      oprot.writeListEnd()
12039 
      oprot.writeFieldEnd()
12040 
    oprot.writeFieldStop()
12041 
    oprot.writeStructEnd()
12042 
 
3431 rajveer 12043 
  def validate(self):
12044 
    return
12045 
 
12046 
 
1886 ankur.sing 12047 
  def __repr__(self):
12048 
    L = ['%s=%r' % (key, value)
12049 
      for key, value in self.__dict__.iteritems()]
12050 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12051 
 
12052 
  def __eq__(self, other):
12053 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12054 
 
12055 
  def __ne__(self, other):
12056 
    return not (self == other)
12057 
 
4783 phani.kuma 12058 
class getUndeliveredOrdersExpectedDeliveryDateNotMet_args:
12059 
 
12060 
  thrift_spec = (
12061 
  )
12062 
 
12063 
  def read(self, iprot):
12064 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12065 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12066 
      return
12067 
    iprot.readStructBegin()
12068 
    while True:
12069 
      (fname, ftype, fid) = iprot.readFieldBegin()
12070 
      if ftype == TType.STOP:
12071 
        break
12072 
      else:
12073 
        iprot.skip(ftype)
12074 
      iprot.readFieldEnd()
12075 
    iprot.readStructEnd()
12076 
 
12077 
  def write(self, oprot):
12078 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12079 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12080 
      return
12081 
    oprot.writeStructBegin('getUndeliveredOrdersExpectedDeliveryDateNotMet_args')
12082 
    oprot.writeFieldStop()
12083 
    oprot.writeStructEnd()
12084 
 
12085 
  def validate(self):
12086 
    return
12087 
 
12088 
 
12089 
  def __repr__(self):
12090 
    L = ['%s=%r' % (key, value)
12091 
      for key, value in self.__dict__.iteritems()]
12092 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12093 
 
12094 
  def __eq__(self, other):
12095 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12096 
 
12097 
  def __ne__(self, other):
12098 
    return not (self == other)
12099 
 
12100 
class getUndeliveredOrdersExpectedDeliveryDateNotMet_result:
12101 
  """
12102 
  Attributes:
12103 
   - success
12104 
  """
12105 
 
12106 
  thrift_spec = (
12107 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
12108 
  )
12109 
 
12110 
  def __init__(self, success=None,):
12111 
    self.success = success
12112 
 
12113 
  def read(self, iprot):
12114 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12115 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12116 
      return
12117 
    iprot.readStructBegin()
12118 
    while True:
12119 
      (fname, ftype, fid) = iprot.readFieldBegin()
12120 
      if ftype == TType.STOP:
12121 
        break
12122 
      if fid == 0:
12123 
        if ftype == TType.LIST:
12124 
          self.success = []
4837 varun.gupt 12125 
          (_etype242, _size239) = iprot.readListBegin()
12126 
          for _i243 in xrange(_size239):
12127 
            _elem244 = Order()
12128 
            _elem244.read(iprot)
12129 
            self.success.append(_elem244)
4783 phani.kuma 12130 
          iprot.readListEnd()
12131 
        else:
12132 
          iprot.skip(ftype)
12133 
      else:
12134 
        iprot.skip(ftype)
12135 
      iprot.readFieldEnd()
12136 
    iprot.readStructEnd()
12137 
 
12138 
  def write(self, oprot):
12139 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12140 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12141 
      return
12142 
    oprot.writeStructBegin('getUndeliveredOrdersExpectedDeliveryDateNotMet_result')
12143 
    if self.success is not None:
12144 
      oprot.writeFieldBegin('success', TType.LIST, 0)
12145 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
4837 varun.gupt 12146 
      for iter245 in self.success:
12147 
        iter245.write(oprot)
4783 phani.kuma 12148 
      oprot.writeListEnd()
12149 
      oprot.writeFieldEnd()
12150 
    oprot.writeFieldStop()
12151 
    oprot.writeStructEnd()
12152 
 
12153 
  def validate(self):
12154 
    return
12155 
 
12156 
 
12157 
  def __repr__(self):
12158 
    L = ['%s=%r' % (key, value)
12159 
      for key, value in self.__dict__.iteritems()]
12160 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12161 
 
12162 
  def __eq__(self, other):
12163 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12164 
 
12165 
  def __ne__(self, other):
12166 
    return not (self == other)
12167 
 
2536 chandransh 12168 
class toggleDOAFlag_args:
12169 
  """
12170 
  Attributes:
12171 
   - orderId
12172 
  """
1886 ankur.sing 12173 
 
2536 chandransh 12174 
  thrift_spec = (
12175 
    None, # 0
12176 
    (1, TType.I64, 'orderId', None, None, ), # 1
12177 
  )
12178 
 
12179 
  def __init__(self, orderId=None,):
12180 
    self.orderId = orderId
12181 
 
12182 
  def read(self, iprot):
12183 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12184 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12185 
      return
12186 
    iprot.readStructBegin()
12187 
    while True:
12188 
      (fname, ftype, fid) = iprot.readFieldBegin()
12189 
      if ftype == TType.STOP:
12190 
        break
12191 
      if fid == 1:
12192 
        if ftype == TType.I64:
12193 
          self.orderId = iprot.readI64();
12194 
        else:
12195 
          iprot.skip(ftype)
12196 
      else:
12197 
        iprot.skip(ftype)
12198 
      iprot.readFieldEnd()
12199 
    iprot.readStructEnd()
12200 
 
12201 
  def write(self, oprot):
12202 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12203 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12204 
      return
12205 
    oprot.writeStructBegin('toggleDOAFlag_args')
3431 rajveer 12206 
    if self.orderId is not None:
2536 chandransh 12207 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
12208 
      oprot.writeI64(self.orderId)
12209 
      oprot.writeFieldEnd()
12210 
    oprot.writeFieldStop()
12211 
    oprot.writeStructEnd()
12212 
 
3431 rajveer 12213 
  def validate(self):
12214 
    return
12215 
 
12216 
 
2536 chandransh 12217 
  def __repr__(self):
12218 
    L = ['%s=%r' % (key, value)
12219 
      for key, value in self.__dict__.iteritems()]
12220 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12221 
 
12222 
  def __eq__(self, other):
12223 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12224 
 
12225 
  def __ne__(self, other):
12226 
    return not (self == other)
12227 
 
12228 
class toggleDOAFlag_result:
12229 
  """
12230 
  Attributes:
12231 
   - success
12232 
   - ex
12233 
  """
12234 
 
12235 
  thrift_spec = (
12236 
    (0, TType.BOOL, 'success', None, None, ), # 0
12237 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
12238 
  )
12239 
 
12240 
  def __init__(self, success=None, ex=None,):
12241 
    self.success = success
12242 
    self.ex = ex
12243 
 
12244 
  def read(self, iprot):
12245 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12246 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12247 
      return
12248 
    iprot.readStructBegin()
12249 
    while True:
12250 
      (fname, ftype, fid) = iprot.readFieldBegin()
12251 
      if ftype == TType.STOP:
12252 
        break
12253 
      if fid == 0:
12254 
        if ftype == TType.BOOL:
12255 
          self.success = iprot.readBool();
12256 
        else:
12257 
          iprot.skip(ftype)
12258 
      elif fid == 1:
12259 
        if ftype == TType.STRUCT:
12260 
          self.ex = TransactionServiceException()
12261 
          self.ex.read(iprot)
12262 
        else:
12263 
          iprot.skip(ftype)
12264 
      else:
12265 
        iprot.skip(ftype)
12266 
      iprot.readFieldEnd()
12267 
    iprot.readStructEnd()
12268 
 
12269 
  def write(self, oprot):
12270 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12271 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12272 
      return
12273 
    oprot.writeStructBegin('toggleDOAFlag_result')
3431 rajveer 12274 
    if self.success is not None:
2536 chandransh 12275 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
12276 
      oprot.writeBool(self.success)
12277 
      oprot.writeFieldEnd()
3431 rajveer 12278 
    if self.ex is not None:
2536 chandransh 12279 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
12280 
      self.ex.write(oprot)
12281 
      oprot.writeFieldEnd()
12282 
    oprot.writeFieldStop()
12283 
    oprot.writeStructEnd()
12284 
 
3431 rajveer 12285 
  def validate(self):
12286 
    return
12287 
 
12288 
 
2536 chandransh 12289 
  def __repr__(self):
12290 
    L = ['%s=%r' % (key, value)
12291 
      for key, value in self.__dict__.iteritems()]
12292 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12293 
 
12294 
  def __eq__(self, other):
12295 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12296 
 
12297 
  def __ne__(self, other):
12298 
    return not (self == other)
12299 
 
4712 rajveer 12300 
class markOrderAsDelivered_args:
12301 
  """
12302 
  Attributes:
12303 
   - orderId
12304 
   - deliveryTimestamp
12305 
   - receiver
12306 
  """
12307 
 
12308 
  thrift_spec = None
12309 
  def __init__(self, orderId=None, deliveryTimestamp=None, receiver=None,):
12310 
    self.orderId = orderId
12311 
    self.deliveryTimestamp = deliveryTimestamp
12312 
    self.receiver = receiver
12313 
 
12314 
  def read(self, iprot):
12315 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12316 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12317 
      return
12318 
    iprot.readStructBegin()
12319 
    while True:
12320 
      (fname, ftype, fid) = iprot.readFieldBegin()
12321 
      if ftype == TType.STOP:
12322 
        break
12323 
      if fid == 1:
12324 
        if ftype == TType.I64:
12325 
          self.orderId = iprot.readI64();
12326 
        else:
12327 
          iprot.skip(ftype)
12328 
      elif fid == 2:
12329 
        if ftype == TType.I64:
12330 
          self.deliveryTimestamp = iprot.readI64();
12331 
        else:
12332 
          iprot.skip(ftype)
12333 
      elif fid == -1:
12334 
        if ftype == TType.STRING:
12335 
          self.receiver = iprot.readString();
12336 
        else:
12337 
          iprot.skip(ftype)
12338 
      else:
12339 
        iprot.skip(ftype)
12340 
      iprot.readFieldEnd()
12341 
    iprot.readStructEnd()
12342 
 
12343 
  def write(self, oprot):
12344 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12345 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12346 
      return
12347 
    oprot.writeStructBegin('markOrderAsDelivered_args')
12348 
    if self.receiver is not None:
12349 
      oprot.writeFieldBegin('receiver', TType.STRING, -1)
12350 
      oprot.writeString(self.receiver)
12351 
      oprot.writeFieldEnd()
12352 
    if self.orderId is not None:
12353 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
12354 
      oprot.writeI64(self.orderId)
12355 
      oprot.writeFieldEnd()
12356 
    if self.deliveryTimestamp is not None:
12357 
      oprot.writeFieldBegin('deliveryTimestamp', TType.I64, 2)
12358 
      oprot.writeI64(self.deliveryTimestamp)
12359 
      oprot.writeFieldEnd()
12360 
    oprot.writeFieldStop()
12361 
    oprot.writeStructEnd()
12362 
 
12363 
  def validate(self):
12364 
    return
12365 
 
12366 
 
12367 
  def __repr__(self):
12368 
    L = ['%s=%r' % (key, value)
12369 
      for key, value in self.__dict__.iteritems()]
12370 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12371 
 
12372 
  def __eq__(self, other):
12373 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12374 
 
12375 
  def __ne__(self, other):
12376 
    return not (self == other)
12377 
 
12378 
class markOrderAsDelivered_result:
12379 
  """
12380 
  Attributes:
12381 
   - ex
12382 
  """
12383 
 
12384 
  thrift_spec = (
12385 
    None, # 0
12386 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
12387 
  )
12388 
 
12389 
  def __init__(self, ex=None,):
12390 
    self.ex = ex
12391 
 
12392 
  def read(self, iprot):
12393 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12394 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12395 
      return
12396 
    iprot.readStructBegin()
12397 
    while True:
12398 
      (fname, ftype, fid) = iprot.readFieldBegin()
12399 
      if ftype == TType.STOP:
12400 
        break
12401 
      if fid == 1:
12402 
        if ftype == TType.STRUCT:
12403 
          self.ex = TransactionServiceException()
12404 
          self.ex.read(iprot)
12405 
        else:
12406 
          iprot.skip(ftype)
12407 
      else:
12408 
        iprot.skip(ftype)
12409 
      iprot.readFieldEnd()
12410 
    iprot.readStructEnd()
12411 
 
12412 
  def write(self, oprot):
12413 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12414 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12415 
      return
12416 
    oprot.writeStructBegin('markOrderAsDelivered_result')
12417 
    if self.ex is not None:
12418 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
12419 
      self.ex.write(oprot)
12420 
      oprot.writeFieldEnd()
12421 
    oprot.writeFieldStop()
12422 
    oprot.writeStructEnd()
12423 
 
12424 
  def validate(self):
12425 
    return
12426 
 
12427 
 
12428 
  def __repr__(self):
12429 
    L = ['%s=%r' % (key, value)
12430 
      for key, value in self.__dict__.iteritems()]
12431 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12432 
 
12433 
  def __eq__(self, other):
12434 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12435 
 
12436 
  def __ne__(self, other):
12437 
    return not (self == other)
12438 
 
4454 rajveer 12439 
class markOrderDoaRequestReceived_args:
12440 
  """
12441 
  Attributes:
12442 
   - orderId
12443 
  """
12444 
 
12445 
  thrift_spec = (
12446 
    None, # 0
12447 
    (1, TType.I64, 'orderId', None, None, ), # 1
12448 
  )
12449 
 
12450 
  def __init__(self, orderId=None,):
12451 
    self.orderId = orderId
12452 
 
12453 
  def read(self, iprot):
12454 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12455 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12456 
      return
12457 
    iprot.readStructBegin()
12458 
    while True:
12459 
      (fname, ftype, fid) = iprot.readFieldBegin()
12460 
      if ftype == TType.STOP:
12461 
        break
12462 
      if fid == 1:
12463 
        if ftype == TType.I64:
12464 
          self.orderId = iprot.readI64();
12465 
        else:
12466 
          iprot.skip(ftype)
12467 
      else:
12468 
        iprot.skip(ftype)
12469 
      iprot.readFieldEnd()
12470 
    iprot.readStructEnd()
12471 
 
12472 
  def write(self, oprot):
12473 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12474 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12475 
      return
12476 
    oprot.writeStructBegin('markOrderDoaRequestReceived_args')
12477 
    if self.orderId is not None:
12478 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
12479 
      oprot.writeI64(self.orderId)
12480 
      oprot.writeFieldEnd()
12481 
    oprot.writeFieldStop()
12482 
    oprot.writeStructEnd()
12483 
 
12484 
  def validate(self):
12485 
    return
12486 
 
12487 
 
12488 
  def __repr__(self):
12489 
    L = ['%s=%r' % (key, value)
12490 
      for key, value in self.__dict__.iteritems()]
12491 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12492 
 
12493 
  def __eq__(self, other):
12494 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12495 
 
12496 
  def __ne__(self, other):
12497 
    return not (self == other)
12498 
 
12499 
class markOrderDoaRequestReceived_result:
12500 
  """
12501 
  Attributes:
12502 
   - success
12503 
   - ex
12504 
  """
12505 
 
12506 
  thrift_spec = (
12507 
    (0, TType.BOOL, 'success', None, None, ), # 0
12508 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
12509 
  )
12510 
 
12511 
  def __init__(self, success=None, ex=None,):
12512 
    self.success = success
12513 
    self.ex = ex
12514 
 
12515 
  def read(self, iprot):
12516 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12517 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12518 
      return
12519 
    iprot.readStructBegin()
12520 
    while True:
12521 
      (fname, ftype, fid) = iprot.readFieldBegin()
12522 
      if ftype == TType.STOP:
12523 
        break
12524 
      if fid == 0:
12525 
        if ftype == TType.BOOL:
12526 
          self.success = iprot.readBool();
12527 
        else:
12528 
          iprot.skip(ftype)
12529 
      elif fid == 1:
12530 
        if ftype == TType.STRUCT:
12531 
          self.ex = TransactionServiceException()
12532 
          self.ex.read(iprot)
12533 
        else:
12534 
          iprot.skip(ftype)
12535 
      else:
12536 
        iprot.skip(ftype)
12537 
      iprot.readFieldEnd()
12538 
    iprot.readStructEnd()
12539 
 
12540 
  def write(self, oprot):
12541 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12542 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12543 
      return
12544 
    oprot.writeStructBegin('markOrderDoaRequestReceived_result')
12545 
    if self.success is not None:
12546 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
12547 
      oprot.writeBool(self.success)
12548 
      oprot.writeFieldEnd()
12549 
    if self.ex is not None:
12550 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
12551 
      self.ex.write(oprot)
12552 
      oprot.writeFieldEnd()
12553 
    oprot.writeFieldStop()
12554 
    oprot.writeStructEnd()
12555 
 
12556 
  def validate(self):
12557 
    return
12558 
 
12559 
 
12560 
  def __repr__(self):
12561 
    L = ['%s=%r' % (key, value)
12562 
      for key, value in self.__dict__.iteritems()]
12563 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12564 
 
12565 
  def __eq__(self, other):
12566 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12567 
 
12568 
  def __ne__(self, other):
12569 
    return not (self == other)
12570 
 
12571 
class markOrderDoaRequestAuthorized_args:
12572 
  """
12573 
  Attributes:
12574 
   - orderId
12575 
   - isAuthorized
12576 
  """
12577 
 
12578 
  thrift_spec = (
12579 
    None, # 0
12580 
    (1, TType.I64, 'orderId', None, None, ), # 1
12581 
    (2, TType.BOOL, 'isAuthorized', None, None, ), # 2
12582 
  )
12583 
 
12584 
  def __init__(self, orderId=None, isAuthorized=None,):
12585 
    self.orderId = orderId
12586 
    self.isAuthorized = isAuthorized
12587 
 
12588 
  def read(self, iprot):
12589 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12590 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12591 
      return
12592 
    iprot.readStructBegin()
12593 
    while True:
12594 
      (fname, ftype, fid) = iprot.readFieldBegin()
12595 
      if ftype == TType.STOP:
12596 
        break
12597 
      if fid == 1:
12598 
        if ftype == TType.I64:
12599 
          self.orderId = iprot.readI64();
12600 
        else:
12601 
          iprot.skip(ftype)
12602 
      elif fid == 2:
12603 
        if ftype == TType.BOOL:
12604 
          self.isAuthorized = iprot.readBool();
12605 
        else:
12606 
          iprot.skip(ftype)
12607 
      else:
12608 
        iprot.skip(ftype)
12609 
      iprot.readFieldEnd()
12610 
    iprot.readStructEnd()
12611 
 
12612 
  def write(self, oprot):
12613 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12614 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12615 
      return
12616 
    oprot.writeStructBegin('markOrderDoaRequestAuthorized_args')
12617 
    if self.orderId is not None:
12618 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
12619 
      oprot.writeI64(self.orderId)
12620 
      oprot.writeFieldEnd()
12621 
    if self.isAuthorized is not None:
12622 
      oprot.writeFieldBegin('isAuthorized', TType.BOOL, 2)
12623 
      oprot.writeBool(self.isAuthorized)
12624 
      oprot.writeFieldEnd()
12625 
    oprot.writeFieldStop()
12626 
    oprot.writeStructEnd()
12627 
 
12628 
  def validate(self):
12629 
    return
12630 
 
12631 
 
12632 
  def __repr__(self):
12633 
    L = ['%s=%r' % (key, value)
12634 
      for key, value in self.__dict__.iteritems()]
12635 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12636 
 
12637 
  def __eq__(self, other):
12638 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12639 
 
12640 
  def __ne__(self, other):
12641 
    return not (self == other)
12642 
 
12643 
class markOrderDoaRequestAuthorized_result:
12644 
  """
12645 
  Attributes:
12646 
   - success
12647 
   - ex
12648 
  """
12649 
 
12650 
  thrift_spec = (
12651 
    (0, TType.BOOL, 'success', None, None, ), # 0
12652 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
12653 
  )
12654 
 
12655 
  def __init__(self, success=None, ex=None,):
12656 
    self.success = success
12657 
    self.ex = ex
12658 
 
12659 
  def read(self, iprot):
12660 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12661 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12662 
      return
12663 
    iprot.readStructBegin()
12664 
    while True:
12665 
      (fname, ftype, fid) = iprot.readFieldBegin()
12666 
      if ftype == TType.STOP:
12667 
        break
12668 
      if fid == 0:
12669 
        if ftype == TType.BOOL:
12670 
          self.success = iprot.readBool();
12671 
        else:
12672 
          iprot.skip(ftype)
12673 
      elif fid == 1:
12674 
        if ftype == TType.STRUCT:
12675 
          self.ex = TransactionServiceException()
12676 
          self.ex.read(iprot)
12677 
        else:
12678 
          iprot.skip(ftype)
12679 
      else:
12680 
        iprot.skip(ftype)
12681 
      iprot.readFieldEnd()
12682 
    iprot.readStructEnd()
12683 
 
12684 
  def write(self, oprot):
12685 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12686 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12687 
      return
12688 
    oprot.writeStructBegin('markOrderDoaRequestAuthorized_result')
12689 
    if self.success is not None:
12690 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
12691 
      oprot.writeBool(self.success)
12692 
      oprot.writeFieldEnd()
12693 
    if self.ex is not None:
12694 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
12695 
      self.ex.write(oprot)
12696 
      oprot.writeFieldEnd()
12697 
    oprot.writeFieldStop()
12698 
    oprot.writeStructEnd()
12699 
 
12700 
  def validate(self):
12701 
    return
12702 
 
12703 
 
12704 
  def __repr__(self):
12705 
    L = ['%s=%r' % (key, value)
12706 
      for key, value in self.__dict__.iteritems()]
12707 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12708 
 
12709 
  def __eq__(self, other):
12710 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12711 
 
12712 
  def __ne__(self, other):
12713 
    return not (self == other)
12714 
 
4488 rajveer 12715 
class markOrderReturnRequestReceived_args:
12716 
  """
12717 
  Attributes:
12718 
   - orderId
12719 
  """
12720 
 
12721 
  thrift_spec = (
12722 
    None, # 0
12723 
    (1, TType.I64, 'orderId', None, None, ), # 1
12724 
  )
12725 
 
12726 
  def __init__(self, orderId=None,):
12727 
    self.orderId = orderId
12728 
 
12729 
  def read(self, iprot):
12730 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12731 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12732 
      return
12733 
    iprot.readStructBegin()
12734 
    while True:
12735 
      (fname, ftype, fid) = iprot.readFieldBegin()
12736 
      if ftype == TType.STOP:
12737 
        break
12738 
      if fid == 1:
12739 
        if ftype == TType.I64:
12740 
          self.orderId = iprot.readI64();
12741 
        else:
12742 
          iprot.skip(ftype)
12743 
      else:
12744 
        iprot.skip(ftype)
12745 
      iprot.readFieldEnd()
12746 
    iprot.readStructEnd()
12747 
 
12748 
  def write(self, oprot):
12749 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12750 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12751 
      return
12752 
    oprot.writeStructBegin('markOrderReturnRequestReceived_args')
12753 
    if self.orderId is not None:
12754 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
12755 
      oprot.writeI64(self.orderId)
12756 
      oprot.writeFieldEnd()
12757 
    oprot.writeFieldStop()
12758 
    oprot.writeStructEnd()
12759 
 
12760 
  def validate(self):
12761 
    return
12762 
 
12763 
 
12764 
  def __repr__(self):
12765 
    L = ['%s=%r' % (key, value)
12766 
      for key, value in self.__dict__.iteritems()]
12767 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12768 
 
12769 
  def __eq__(self, other):
12770 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12771 
 
12772 
  def __ne__(self, other):
12773 
    return not (self == other)
12774 
 
12775 
class markOrderReturnRequestReceived_result:
12776 
  """
12777 
  Attributes:
12778 
   - success
12779 
   - ex
12780 
  """
12781 
 
12782 
  thrift_spec = (
12783 
    (0, TType.BOOL, 'success', None, None, ), # 0
12784 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
12785 
  )
12786 
 
12787 
  def __init__(self, success=None, ex=None,):
12788 
    self.success = success
12789 
    self.ex = ex
12790 
 
12791 
  def read(self, iprot):
12792 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12793 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12794 
      return
12795 
    iprot.readStructBegin()
12796 
    while True:
12797 
      (fname, ftype, fid) = iprot.readFieldBegin()
12798 
      if ftype == TType.STOP:
12799 
        break
12800 
      if fid == 0:
12801 
        if ftype == TType.BOOL:
12802 
          self.success = iprot.readBool();
12803 
        else:
12804 
          iprot.skip(ftype)
12805 
      elif fid == 1:
12806 
        if ftype == TType.STRUCT:
12807 
          self.ex = TransactionServiceException()
12808 
          self.ex.read(iprot)
12809 
        else:
12810 
          iprot.skip(ftype)
12811 
      else:
12812 
        iprot.skip(ftype)
12813 
      iprot.readFieldEnd()
12814 
    iprot.readStructEnd()
12815 
 
12816 
  def write(self, oprot):
12817 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12818 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12819 
      return
12820 
    oprot.writeStructBegin('markOrderReturnRequestReceived_result')
12821 
    if self.success is not None:
12822 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
12823 
      oprot.writeBool(self.success)
12824 
      oprot.writeFieldEnd()
12825 
    if self.ex is not None:
12826 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
12827 
      self.ex.write(oprot)
12828 
      oprot.writeFieldEnd()
12829 
    oprot.writeFieldStop()
12830 
    oprot.writeStructEnd()
12831 
 
12832 
  def validate(self):
12833 
    return
12834 
 
12835 
 
12836 
  def __repr__(self):
12837 
    L = ['%s=%r' % (key, value)
12838 
      for key, value in self.__dict__.iteritems()]
12839 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12840 
 
12841 
  def __eq__(self, other):
12842 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12843 
 
12844 
  def __ne__(self, other):
12845 
    return not (self == other)
12846 
 
12847 
class markOrderReturnRequestAuthorized_args:
12848 
  """
12849 
  Attributes:
12850 
   - orderId
12851 
   - isAuthorized
12852 
  """
12853 
 
12854 
  thrift_spec = (
12855 
    None, # 0
12856 
    (1, TType.I64, 'orderId', None, None, ), # 1
12857 
    (2, TType.BOOL, 'isAuthorized', None, None, ), # 2
12858 
  )
12859 
 
12860 
  def __init__(self, orderId=None, isAuthorized=None,):
12861 
    self.orderId = orderId
12862 
    self.isAuthorized = isAuthorized
12863 
 
12864 
  def read(self, iprot):
12865 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12866 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12867 
      return
12868 
    iprot.readStructBegin()
12869 
    while True:
12870 
      (fname, ftype, fid) = iprot.readFieldBegin()
12871 
      if ftype == TType.STOP:
12872 
        break
12873 
      if fid == 1:
12874 
        if ftype == TType.I64:
12875 
          self.orderId = iprot.readI64();
12876 
        else:
12877 
          iprot.skip(ftype)
12878 
      elif fid == 2:
12879 
        if ftype == TType.BOOL:
12880 
          self.isAuthorized = iprot.readBool();
12881 
        else:
12882 
          iprot.skip(ftype)
12883 
      else:
12884 
        iprot.skip(ftype)
12885 
      iprot.readFieldEnd()
12886 
    iprot.readStructEnd()
12887 
 
12888 
  def write(self, oprot):
12889 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12890 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12891 
      return
12892 
    oprot.writeStructBegin('markOrderReturnRequestAuthorized_args')
12893 
    if self.orderId is not None:
12894 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
12895 
      oprot.writeI64(self.orderId)
12896 
      oprot.writeFieldEnd()
12897 
    if self.isAuthorized is not None:
12898 
      oprot.writeFieldBegin('isAuthorized', TType.BOOL, 2)
12899 
      oprot.writeBool(self.isAuthorized)
12900 
      oprot.writeFieldEnd()
12901 
    oprot.writeFieldStop()
12902 
    oprot.writeStructEnd()
12903 
 
12904 
  def validate(self):
12905 
    return
12906 
 
12907 
 
12908 
  def __repr__(self):
12909 
    L = ['%s=%r' % (key, value)
12910 
      for key, value in self.__dict__.iteritems()]
12911 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12912 
 
12913 
  def __eq__(self, other):
12914 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12915 
 
12916 
  def __ne__(self, other):
12917 
    return not (self == other)
12918 
 
12919 
class markOrderReturnRequestAuthorized_result:
12920 
  """
12921 
  Attributes:
12922 
   - success
12923 
   - ex
12924 
  """
12925 
 
12926 
  thrift_spec = (
12927 
    (0, TType.BOOL, 'success', None, None, ), # 0
12928 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
12929 
  )
12930 
 
12931 
  def __init__(self, success=None, ex=None,):
12932 
    self.success = success
12933 
    self.ex = ex
12934 
 
12935 
  def read(self, iprot):
12936 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12937 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12938 
      return
12939 
    iprot.readStructBegin()
12940 
    while True:
12941 
      (fname, ftype, fid) = iprot.readFieldBegin()
12942 
      if ftype == TType.STOP:
12943 
        break
12944 
      if fid == 0:
12945 
        if ftype == TType.BOOL:
12946 
          self.success = iprot.readBool();
12947 
        else:
12948 
          iprot.skip(ftype)
12949 
      elif fid == 1:
12950 
        if ftype == TType.STRUCT:
12951 
          self.ex = TransactionServiceException()
12952 
          self.ex.read(iprot)
12953 
        else:
12954 
          iprot.skip(ftype)
12955 
      else:
12956 
        iprot.skip(ftype)
12957 
      iprot.readFieldEnd()
12958 
    iprot.readStructEnd()
12959 
 
12960 
  def write(self, oprot):
12961 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12962 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12963 
      return
12964 
    oprot.writeStructBegin('markOrderReturnRequestAuthorized_result')
12965 
    if self.success is not None:
12966 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
12967 
      oprot.writeBool(self.success)
12968 
      oprot.writeFieldEnd()
12969 
    if self.ex is not None:
12970 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
12971 
      self.ex.write(oprot)
12972 
      oprot.writeFieldEnd()
12973 
    oprot.writeFieldStop()
12974 
    oprot.writeStructEnd()
12975 
 
12976 
  def validate(self):
12977 
    return
12978 
 
12979 
 
12980 
  def __repr__(self):
12981 
    L = ['%s=%r' % (key, value)
12982 
      for key, value in self.__dict__.iteritems()]
12983 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12984 
 
12985 
  def __eq__(self, other):
12986 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12987 
 
12988 
  def __ne__(self, other):
12989 
    return not (self == other)
12990 
 
2536 chandransh 12991 
class requestPickupNumber_args:
12992 
  """
12993 
  Attributes:
12994 
   - orderId
4579 rajveer 12995 
   - providerId
2536 chandransh 12996 
  """
12997 
 
12998 
  thrift_spec = (
12999 
    None, # 0
13000 
    (1, TType.I64, 'orderId', None, None, ), # 1
4579 rajveer 13001 
    (2, TType.I64, 'providerId', None, None, ), # 2
2536 chandransh 13002 
  )
13003 
 
4579 rajveer 13004 
  def __init__(self, orderId=None, providerId=None,):
2536 chandransh 13005 
    self.orderId = orderId
4579 rajveer 13006 
    self.providerId = providerId
2536 chandransh 13007 
 
13008 
  def read(self, iprot):
13009 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13010 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13011 
      return
13012 
    iprot.readStructBegin()
13013 
    while True:
13014 
      (fname, ftype, fid) = iprot.readFieldBegin()
13015 
      if ftype == TType.STOP:
13016 
        break
13017 
      if fid == 1:
13018 
        if ftype == TType.I64:
13019 
          self.orderId = iprot.readI64();
13020 
        else:
13021 
          iprot.skip(ftype)
4579 rajveer 13022 
      elif fid == 2:
13023 
        if ftype == TType.I64:
13024 
          self.providerId = iprot.readI64();
13025 
        else:
13026 
          iprot.skip(ftype)
2536 chandransh 13027 
      else:
13028 
        iprot.skip(ftype)
13029 
      iprot.readFieldEnd()
13030 
    iprot.readStructEnd()
13031 
 
13032 
  def write(self, oprot):
13033 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13034 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13035 
      return
13036 
    oprot.writeStructBegin('requestPickupNumber_args')
3431 rajveer 13037 
    if self.orderId is not None:
2536 chandransh 13038 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
13039 
      oprot.writeI64(self.orderId)
13040 
      oprot.writeFieldEnd()
4579 rajveer 13041 
    if self.providerId is not None:
13042 
      oprot.writeFieldBegin('providerId', TType.I64, 2)
13043 
      oprot.writeI64(self.providerId)
13044 
      oprot.writeFieldEnd()
2536 chandransh 13045 
    oprot.writeFieldStop()
13046 
    oprot.writeStructEnd()
13047 
 
3431 rajveer 13048 
  def validate(self):
13049 
    return
13050 
 
13051 
 
2536 chandransh 13052 
  def __repr__(self):
13053 
    L = ['%s=%r' % (key, value)
13054 
      for key, value in self.__dict__.iteritems()]
13055 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13056 
 
13057 
  def __eq__(self, other):
13058 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13059 
 
13060 
  def __ne__(self, other):
13061 
    return not (self == other)
13062 
 
13063 
class requestPickupNumber_result:
13064 
  """
13065 
  Attributes:
13066 
   - success
13067 
   - ex
13068 
  """
13069 
 
13070 
  thrift_spec = (
13071 
    (0, TType.BOOL, 'success', None, None, ), # 0
13072 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
13073 
  )
13074 
 
13075 
  def __init__(self, success=None, ex=None,):
13076 
    self.success = success
13077 
    self.ex = ex
13078 
 
13079 
  def read(self, iprot):
13080 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13081 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13082 
      return
13083 
    iprot.readStructBegin()
13084 
    while True:
13085 
      (fname, ftype, fid) = iprot.readFieldBegin()
13086 
      if ftype == TType.STOP:
13087 
        break
13088 
      if fid == 0:
13089 
        if ftype == TType.BOOL:
13090 
          self.success = iprot.readBool();
13091 
        else:
13092 
          iprot.skip(ftype)
13093 
      elif fid == 1:
13094 
        if ftype == TType.STRUCT:
13095 
          self.ex = TransactionServiceException()
13096 
          self.ex.read(iprot)
13097 
        else:
13098 
          iprot.skip(ftype)
13099 
      else:
13100 
        iprot.skip(ftype)
13101 
      iprot.readFieldEnd()
13102 
    iprot.readStructEnd()
13103 
 
13104 
  def write(self, oprot):
13105 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13106 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13107 
      return
13108 
    oprot.writeStructBegin('requestPickupNumber_result')
3431 rajveer 13109 
    if self.success is not None:
2536 chandransh 13110 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
13111 
      oprot.writeBool(self.success)
13112 
      oprot.writeFieldEnd()
3431 rajveer 13113 
    if self.ex is not None:
2536 chandransh 13114 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
13115 
      self.ex.write(oprot)
13116 
      oprot.writeFieldEnd()
13117 
    oprot.writeFieldStop()
13118 
    oprot.writeStructEnd()
13119 
 
3431 rajveer 13120 
  def validate(self):
13121 
    return
13122 
 
13123 
 
2536 chandransh 13124 
  def __repr__(self):
13125 
    L = ['%s=%r' % (key, value)
13126 
      for key, value in self.__dict__.iteritems()]
13127 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13128 
 
13129 
  def __eq__(self, other):
13130 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13131 
 
13132 
  def __ne__(self, other):
13133 
    return not (self == other)
13134 
 
13135 
class authorizePickup_args:
13136 
  """
13137 
  Attributes:
13138 
   - orderId
13139 
   - pickupNumber
4602 rajveer 13140 
   - providerId
2536 chandransh 13141 
  """
13142 
 
13143 
  thrift_spec = (
13144 
    None, # 0
13145 
    (1, TType.I64, 'orderId', None, None, ), # 1
13146 
    (2, TType.STRING, 'pickupNumber', None, None, ), # 2
4602 rajveer 13147 
    (3, TType.I64, 'providerId', None, None, ), # 3
2536 chandransh 13148 
  )
13149 
 
4602 rajveer 13150 
  def __init__(self, orderId=None, pickupNumber=None, providerId=None,):
2536 chandransh 13151 
    self.orderId = orderId
13152 
    self.pickupNumber = pickupNumber
4602 rajveer 13153 
    self.providerId = providerId
2536 chandransh 13154 
 
13155 
  def read(self, iprot):
13156 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13157 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13158 
      return
13159 
    iprot.readStructBegin()
13160 
    while True:
13161 
      (fname, ftype, fid) = iprot.readFieldBegin()
13162 
      if ftype == TType.STOP:
13163 
        break
13164 
      if fid == 1:
13165 
        if ftype == TType.I64:
13166 
          self.orderId = iprot.readI64();
13167 
        else:
13168 
          iprot.skip(ftype)
13169 
      elif fid == 2:
13170 
        if ftype == TType.STRING:
13171 
          self.pickupNumber = iprot.readString();
13172 
        else:
13173 
          iprot.skip(ftype)
4602 rajveer 13174 
      elif fid == 3:
13175 
        if ftype == TType.I64:
13176 
          self.providerId = iprot.readI64();
13177 
        else:
13178 
          iprot.skip(ftype)
2536 chandransh 13179 
      else:
13180 
        iprot.skip(ftype)
13181 
      iprot.readFieldEnd()
13182 
    iprot.readStructEnd()
13183 
 
13184 
  def write(self, oprot):
13185 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13186 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13187 
      return
13188 
    oprot.writeStructBegin('authorizePickup_args')
3431 rajveer 13189 
    if self.orderId is not None:
2536 chandransh 13190 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
13191 
      oprot.writeI64(self.orderId)
13192 
      oprot.writeFieldEnd()
3431 rajveer 13193 
    if self.pickupNumber is not None:
2536 chandransh 13194 
      oprot.writeFieldBegin('pickupNumber', TType.STRING, 2)
13195 
      oprot.writeString(self.pickupNumber)
13196 
      oprot.writeFieldEnd()
4602 rajveer 13197 
    if self.providerId is not None:
13198 
      oprot.writeFieldBegin('providerId', TType.I64, 3)
13199 
      oprot.writeI64(self.providerId)
13200 
      oprot.writeFieldEnd()
2536 chandransh 13201 
    oprot.writeFieldStop()
13202 
    oprot.writeStructEnd()
13203 
 
3431 rajveer 13204 
  def validate(self):
13205 
    return
13206 
 
13207 
 
2536 chandransh 13208 
  def __repr__(self):
13209 
    L = ['%s=%r' % (key, value)
13210 
      for key, value in self.__dict__.iteritems()]
13211 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13212 
 
13213 
  def __eq__(self, other):
13214 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13215 
 
13216 
  def __ne__(self, other):
13217 
    return not (self == other)
13218 
 
13219 
class authorizePickup_result:
13220 
  """
13221 
  Attributes:
13222 
   - success
13223 
   - ex
13224 
  """
13225 
 
13226 
  thrift_spec = (
13227 
    (0, TType.BOOL, 'success', None, None, ), # 0
13228 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
13229 
  )
13230 
 
13231 
  def __init__(self, success=None, ex=None,):
13232 
    self.success = success
13233 
    self.ex = ex
13234 
 
13235 
  def read(self, iprot):
13236 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13237 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13238 
      return
13239 
    iprot.readStructBegin()
13240 
    while True:
13241 
      (fname, ftype, fid) = iprot.readFieldBegin()
13242 
      if ftype == TType.STOP:
13243 
        break
13244 
      if fid == 0:
13245 
        if ftype == TType.BOOL:
13246 
          self.success = iprot.readBool();
13247 
        else:
13248 
          iprot.skip(ftype)
13249 
      elif fid == 1:
13250 
        if ftype == TType.STRUCT:
13251 
          self.ex = TransactionServiceException()
13252 
          self.ex.read(iprot)
13253 
        else:
13254 
          iprot.skip(ftype)
13255 
      else:
13256 
        iprot.skip(ftype)
13257 
      iprot.readFieldEnd()
13258 
    iprot.readStructEnd()
13259 
 
13260 
  def write(self, oprot):
13261 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13262 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13263 
      return
13264 
    oprot.writeStructBegin('authorizePickup_result')
3431 rajveer 13265 
    if self.success is not None:
2536 chandransh 13266 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
13267 
      oprot.writeBool(self.success)
13268 
      oprot.writeFieldEnd()
3431 rajveer 13269 
    if self.ex is not None:
2536 chandransh 13270 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
13271 
      self.ex.write(oprot)
13272 
      oprot.writeFieldEnd()
13273 
    oprot.writeFieldStop()
13274 
    oprot.writeStructEnd()
13275 
 
3431 rajveer 13276 
  def validate(self):
13277 
    return
13278 
 
13279 
 
2536 chandransh 13280 
  def __repr__(self):
13281 
    L = ['%s=%r' % (key, value)
13282 
      for key, value in self.__dict__.iteritems()]
13283 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13284 
 
13285 
  def __eq__(self, other):
13286 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13287 
 
13288 
  def __ne__(self, other):
13289 
    return not (self == other)
13290 
 
2764 chandransh 13291 
class markDoasAsPickedUp_args:
13292 
  """
13293 
  Attributes:
13294 
   - providerId
13295 
   - pickupDetails
13296 
  """
13297 
 
13298 
  thrift_spec = (
13299 
    None, # 0
13300 
    (1, TType.I64, 'providerId', None, None, ), # 1
13301 
    (2, TType.MAP, 'pickupDetails', (TType.STRING,None,TType.STRING,None), None, ), # 2
13302 
  )
13303 
 
13304 
  def __init__(self, providerId=None, pickupDetails=None,):
13305 
    self.providerId = providerId
13306 
    self.pickupDetails = pickupDetails
13307 
 
13308 
  def read(self, iprot):
13309 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13310 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13311 
      return
13312 
    iprot.readStructBegin()
13313 
    while True:
13314 
      (fname, ftype, fid) = iprot.readFieldBegin()
13315 
      if ftype == TType.STOP:
13316 
        break
13317 
      if fid == 1:
13318 
        if ftype == TType.I64:
13319 
          self.providerId = iprot.readI64();
13320 
        else:
13321 
          iprot.skip(ftype)
13322 
      elif fid == 2:
13323 
        if ftype == TType.MAP:
13324 
          self.pickupDetails = {}
4837 varun.gupt 13325 
          (_ktype247, _vtype248, _size246 ) = iprot.readMapBegin()
13326 
          for _i250 in xrange(_size246):
13327 
            _key251 = iprot.readString();
13328 
            _val252 = iprot.readString();
13329 
            self.pickupDetails[_key251] = _val252
2764 chandransh 13330 
          iprot.readMapEnd()
13331 
        else:
13332 
          iprot.skip(ftype)
13333 
      else:
13334 
        iprot.skip(ftype)
13335 
      iprot.readFieldEnd()
13336 
    iprot.readStructEnd()
13337 
 
13338 
  def write(self, oprot):
13339 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13340 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13341 
      return
13342 
    oprot.writeStructBegin('markDoasAsPickedUp_args')
3431 rajveer 13343 
    if self.providerId is not None:
2764 chandransh 13344 
      oprot.writeFieldBegin('providerId', TType.I64, 1)
13345 
      oprot.writeI64(self.providerId)
13346 
      oprot.writeFieldEnd()
3431 rajveer 13347 
    if self.pickupDetails is not None:
2764 chandransh 13348 
      oprot.writeFieldBegin('pickupDetails', TType.MAP, 2)
13349 
      oprot.writeMapBegin(TType.STRING, TType.STRING, len(self.pickupDetails))
4837 varun.gupt 13350 
      for kiter253,viter254 in self.pickupDetails.items():
13351 
        oprot.writeString(kiter253)
13352 
        oprot.writeString(viter254)
2764 chandransh 13353 
      oprot.writeMapEnd()
13354 
      oprot.writeFieldEnd()
13355 
    oprot.writeFieldStop()
13356 
    oprot.writeStructEnd()
13357 
 
3431 rajveer 13358 
  def validate(self):
13359 
    return
13360 
 
13361 
 
2764 chandransh 13362 
  def __repr__(self):
13363 
    L = ['%s=%r' % (key, value)
13364 
      for key, value in self.__dict__.iteritems()]
13365 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13366 
 
13367 
  def __eq__(self, other):
13368 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13369 
 
13370 
  def __ne__(self, other):
13371 
    return not (self == other)
13372 
 
13373 
class markDoasAsPickedUp_result:
13374 
  """
13375 
  Attributes:
13376 
   - success
13377 
  """
13378 
 
13379 
  thrift_spec = (
13380 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
13381 
  )
13382 
 
13383 
  def __init__(self, success=None,):
13384 
    self.success = success
13385 
 
13386 
  def read(self, iprot):
13387 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13388 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13389 
      return
13390 
    iprot.readStructBegin()
13391 
    while True:
13392 
      (fname, ftype, fid) = iprot.readFieldBegin()
13393 
      if ftype == TType.STOP:
13394 
        break
13395 
      if fid == 0:
13396 
        if ftype == TType.LIST:
13397 
          self.success = []
4837 varun.gupt 13398 
          (_etype258, _size255) = iprot.readListBegin()
13399 
          for _i259 in xrange(_size255):
13400 
            _elem260 = Order()
13401 
            _elem260.read(iprot)
13402 
            self.success.append(_elem260)
2764 chandransh 13403 
          iprot.readListEnd()
13404 
        else:
13405 
          iprot.skip(ftype)
13406 
      else:
13407 
        iprot.skip(ftype)
13408 
      iprot.readFieldEnd()
13409 
    iprot.readStructEnd()
13410 
 
13411 
  def write(self, oprot):
13412 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13413 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13414 
      return
13415 
    oprot.writeStructBegin('markDoasAsPickedUp_result')
3431 rajveer 13416 
    if self.success is not None:
2764 chandransh 13417 
      oprot.writeFieldBegin('success', TType.LIST, 0)
13418 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
4837 varun.gupt 13419 
      for iter261 in self.success:
13420 
        iter261.write(oprot)
2764 chandransh 13421 
      oprot.writeListEnd()
13422 
      oprot.writeFieldEnd()
13423 
    oprot.writeFieldStop()
13424 
    oprot.writeStructEnd()
13425 
 
3431 rajveer 13426 
  def validate(self):
13427 
    return
13428 
 
13429 
 
2764 chandransh 13430 
  def __repr__(self):
13431 
    L = ['%s=%r' % (key, value)
13432 
      for key, value in self.__dict__.iteritems()]
13433 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13434 
 
13435 
  def __eq__(self, other):
13436 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13437 
 
13438 
  def __ne__(self, other):
13439 
    return not (self == other)
13440 
 
4741 phani.kuma 13441 
class markReturnOrdersAsPickedUp_args:
13442 
  """
13443 
  Attributes:
13444 
   - providerId
13445 
   - pickupDetails
13446 
  """
13447 
 
13448 
  thrift_spec = (
13449 
    None, # 0
13450 
    (1, TType.I64, 'providerId', None, None, ), # 1
13451 
    (2, TType.MAP, 'pickupDetails', (TType.STRING,None,TType.STRING,None), None, ), # 2
13452 
  )
13453 
 
13454 
  def __init__(self, providerId=None, pickupDetails=None,):
13455 
    self.providerId = providerId
13456 
    self.pickupDetails = pickupDetails
13457 
 
13458 
  def read(self, iprot):
13459 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13460 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13461 
      return
13462 
    iprot.readStructBegin()
13463 
    while True:
13464 
      (fname, ftype, fid) = iprot.readFieldBegin()
13465 
      if ftype == TType.STOP:
13466 
        break
13467 
      if fid == 1:
13468 
        if ftype == TType.I64:
13469 
          self.providerId = iprot.readI64();
13470 
        else:
13471 
          iprot.skip(ftype)
13472 
      elif fid == 2:
13473 
        if ftype == TType.MAP:
13474 
          self.pickupDetails = {}
4837 varun.gupt 13475 
          (_ktype263, _vtype264, _size262 ) = iprot.readMapBegin()
13476 
          for _i266 in xrange(_size262):
13477 
            _key267 = iprot.readString();
13478 
            _val268 = iprot.readString();
13479 
            self.pickupDetails[_key267] = _val268
4741 phani.kuma 13480 
          iprot.readMapEnd()
13481 
        else:
13482 
          iprot.skip(ftype)
13483 
      else:
13484 
        iprot.skip(ftype)
13485 
      iprot.readFieldEnd()
13486 
    iprot.readStructEnd()
13487 
 
13488 
  def write(self, oprot):
13489 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13490 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13491 
      return
13492 
    oprot.writeStructBegin('markReturnOrdersAsPickedUp_args')
13493 
    if self.providerId is not None:
13494 
      oprot.writeFieldBegin('providerId', TType.I64, 1)
13495 
      oprot.writeI64(self.providerId)
13496 
      oprot.writeFieldEnd()
13497 
    if self.pickupDetails is not None:
13498 
      oprot.writeFieldBegin('pickupDetails', TType.MAP, 2)
13499 
      oprot.writeMapBegin(TType.STRING, TType.STRING, len(self.pickupDetails))
4837 varun.gupt 13500 
      for kiter269,viter270 in self.pickupDetails.items():
13501 
        oprot.writeString(kiter269)
13502 
        oprot.writeString(viter270)
4741 phani.kuma 13503 
      oprot.writeMapEnd()
13504 
      oprot.writeFieldEnd()
13505 
    oprot.writeFieldStop()
13506 
    oprot.writeStructEnd()
13507 
 
13508 
  def validate(self):
13509 
    return
13510 
 
13511 
 
13512 
  def __repr__(self):
13513 
    L = ['%s=%r' % (key, value)
13514 
      for key, value in self.__dict__.iteritems()]
13515 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13516 
 
13517 
  def __eq__(self, other):
13518 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13519 
 
13520 
  def __ne__(self, other):
13521 
    return not (self == other)
13522 
 
13523 
class markReturnOrdersAsPickedUp_result:
13524 
  """
13525 
  Attributes:
13526 
   - success
13527 
  """
13528 
 
13529 
  thrift_spec = (
13530 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
13531 
  )
13532 
 
13533 
  def __init__(self, success=None,):
13534 
    self.success = success
13535 
 
13536 
  def read(self, iprot):
13537 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13538 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13539 
      return
13540 
    iprot.readStructBegin()
13541 
    while True:
13542 
      (fname, ftype, fid) = iprot.readFieldBegin()
13543 
      if ftype == TType.STOP:
13544 
        break
13545 
      if fid == 0:
13546 
        if ftype == TType.LIST:
13547 
          self.success = []
4837 varun.gupt 13548 
          (_etype274, _size271) = iprot.readListBegin()
13549 
          for _i275 in xrange(_size271):
13550 
            _elem276 = Order()
13551 
            _elem276.read(iprot)
13552 
            self.success.append(_elem276)
4741 phani.kuma 13553 
          iprot.readListEnd()
13554 
        else:
13555 
          iprot.skip(ftype)
13556 
      else:
13557 
        iprot.skip(ftype)
13558 
      iprot.readFieldEnd()
13559 
    iprot.readStructEnd()
13560 
 
13561 
  def write(self, oprot):
13562 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13563 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13564 
      return
13565 
    oprot.writeStructBegin('markReturnOrdersAsPickedUp_result')
13566 
    if self.success is not None:
13567 
      oprot.writeFieldBegin('success', TType.LIST, 0)
13568 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
4837 varun.gupt 13569 
      for iter277 in self.success:
13570 
        iter277.write(oprot)
4741 phani.kuma 13571 
      oprot.writeListEnd()
13572 
      oprot.writeFieldEnd()
13573 
    oprot.writeFieldStop()
13574 
    oprot.writeStructEnd()
13575 
 
13576 
  def validate(self):
13577 
    return
13578 
 
13579 
 
13580 
  def __repr__(self):
13581 
    L = ['%s=%r' % (key, value)
13582 
      for key, value in self.__dict__.iteritems()]
13583 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13584 
 
13585 
  def __eq__(self, other):
13586 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13587 
 
13588 
  def __ne__(self, other):
13589 
    return not (self == other)
13590 
 
2616 chandransh 13591 
class receiveReturn_args:
2591 chandransh 13592 
  """
13593 
  Attributes:
13594 
   - orderId
4479 rajveer 13595 
   - receiveCondition
2591 chandransh 13596 
  """
2536 chandransh 13597 
 
2591 chandransh 13598 
  thrift_spec = (
13599 
    None, # 0
13600 
    (1, TType.I64, 'orderId', None, None, ), # 1
4479 rajveer 13601 
    (2, TType.I64, 'receiveCondition', None, None, ), # 2
2591 chandransh 13602 
  )
13603 
 
4479 rajveer 13604 
  def __init__(self, orderId=None, receiveCondition=None,):
2591 chandransh 13605 
    self.orderId = orderId
4479 rajveer 13606 
    self.receiveCondition = receiveCondition
2591 chandransh 13607 
 
13608 
  def read(self, iprot):
13609 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13610 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13611 
      return
13612 
    iprot.readStructBegin()
13613 
    while True:
13614 
      (fname, ftype, fid) = iprot.readFieldBegin()
13615 
      if ftype == TType.STOP:
13616 
        break
13617 
      if fid == 1:
13618 
        if ftype == TType.I64:
13619 
          self.orderId = iprot.readI64();
13620 
        else:
13621 
          iprot.skip(ftype)
4479 rajveer 13622 
      elif fid == 2:
13623 
        if ftype == TType.I64:
13624 
          self.receiveCondition = iprot.readI64();
13625 
        else:
13626 
          iprot.skip(ftype)
2591 chandransh 13627 
      else:
13628 
        iprot.skip(ftype)
13629 
      iprot.readFieldEnd()
13630 
    iprot.readStructEnd()
13631 
 
13632 
  def write(self, oprot):
13633 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13634 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13635 
      return
2616 chandransh 13636 
    oprot.writeStructBegin('receiveReturn_args')
3431 rajveer 13637 
    if self.orderId is not None:
2591 chandransh 13638 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
13639 
      oprot.writeI64(self.orderId)
13640 
      oprot.writeFieldEnd()
4479 rajveer 13641 
    if self.receiveCondition is not None:
13642 
      oprot.writeFieldBegin('receiveCondition', TType.I64, 2)
13643 
      oprot.writeI64(self.receiveCondition)
13644 
      oprot.writeFieldEnd()
2591 chandransh 13645 
    oprot.writeFieldStop()
13646 
    oprot.writeStructEnd()
13647 
 
3431 rajveer 13648 
  def validate(self):
13649 
    return
13650 
 
13651 
 
2591 chandransh 13652 
  def __repr__(self):
13653 
    L = ['%s=%r' % (key, value)
13654 
      for key, value in self.__dict__.iteritems()]
13655 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13656 
 
13657 
  def __eq__(self, other):
13658 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13659 
 
13660 
  def __ne__(self, other):
13661 
    return not (self == other)
13662 
 
2616 chandransh 13663 
class receiveReturn_result:
2591 chandransh 13664 
  """
13665 
  Attributes:
13666 
   - success
13667 
   - ex
13668 
  """
13669 
 
13670 
  thrift_spec = (
13671 
    (0, TType.BOOL, 'success', None, None, ), # 0
13672 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
13673 
  )
13674 
 
13675 
  def __init__(self, success=None, ex=None,):
13676 
    self.success = success
13677 
    self.ex = ex
13678 
 
13679 
  def read(self, iprot):
13680 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13681 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13682 
      return
13683 
    iprot.readStructBegin()
13684 
    while True:
13685 
      (fname, ftype, fid) = iprot.readFieldBegin()
13686 
      if ftype == TType.STOP:
13687 
        break
13688 
      if fid == 0:
13689 
        if ftype == TType.BOOL:
13690 
          self.success = iprot.readBool();
13691 
        else:
13692 
          iprot.skip(ftype)
13693 
      elif fid == 1:
13694 
        if ftype == TType.STRUCT:
13695 
          self.ex = TransactionServiceException()
13696 
          self.ex.read(iprot)
13697 
        else:
13698 
          iprot.skip(ftype)
13699 
      else:
13700 
        iprot.skip(ftype)
13701 
      iprot.readFieldEnd()
13702 
    iprot.readStructEnd()
13703 
 
13704 
  def write(self, oprot):
13705 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13706 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13707 
      return
2616 chandransh 13708 
    oprot.writeStructBegin('receiveReturn_result')
3431 rajveer 13709 
    if self.success is not None:
2591 chandransh 13710 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
13711 
      oprot.writeBool(self.success)
13712 
      oprot.writeFieldEnd()
3431 rajveer 13713 
    if self.ex is not None:
2591 chandransh 13714 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
13715 
      self.ex.write(oprot)
13716 
      oprot.writeFieldEnd()
13717 
    oprot.writeFieldStop()
13718 
    oprot.writeStructEnd()
13719 
 
3431 rajveer 13720 
  def validate(self):
13721 
    return
13722 
 
13723 
 
2591 chandransh 13724 
  def __repr__(self):
13725 
    L = ['%s=%r' % (key, value)
13726 
      for key, value in self.__dict__.iteritems()]
13727 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13728 
 
13729 
  def __eq__(self, other):
13730 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13731 
 
13732 
  def __ne__(self, other):
13733 
    return not (self == other)
13734 
 
13735 
class validateDoa_args:
13736 
  """
13737 
  Attributes:
13738 
   - orderId
13739 
   - isValid
13740 
  """
13741 
 
13742 
  thrift_spec = (
13743 
    None, # 0
13744 
    (1, TType.I64, 'orderId', None, None, ), # 1
13745 
    (2, TType.BOOL, 'isValid', None, None, ), # 2
13746 
  )
13747 
 
13748 
  def __init__(self, orderId=None, isValid=None,):
13749 
    self.orderId = orderId
13750 
    self.isValid = isValid
13751 
 
13752 
  def read(self, iprot):
13753 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13754 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13755 
      return
13756 
    iprot.readStructBegin()
13757 
    while True:
13758 
      (fname, ftype, fid) = iprot.readFieldBegin()
13759 
      if ftype == TType.STOP:
13760 
        break
13761 
      if fid == 1:
13762 
        if ftype == TType.I64:
13763 
          self.orderId = iprot.readI64();
13764 
        else:
13765 
          iprot.skip(ftype)
13766 
      elif fid == 2:
13767 
        if ftype == TType.BOOL:
13768 
          self.isValid = iprot.readBool();
13769 
        else:
13770 
          iprot.skip(ftype)
13771 
      else:
13772 
        iprot.skip(ftype)
13773 
      iprot.readFieldEnd()
13774 
    iprot.readStructEnd()
13775 
 
13776 
  def write(self, oprot):
13777 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13778 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13779 
      return
13780 
    oprot.writeStructBegin('validateDoa_args')
3431 rajveer 13781 
    if self.orderId is not None:
2591 chandransh 13782 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
13783 
      oprot.writeI64(self.orderId)
13784 
      oprot.writeFieldEnd()
3431 rajveer 13785 
    if self.isValid is not None:
2591 chandransh 13786 
      oprot.writeFieldBegin('isValid', TType.BOOL, 2)
13787 
      oprot.writeBool(self.isValid)
13788 
      oprot.writeFieldEnd()
13789 
    oprot.writeFieldStop()
13790 
    oprot.writeStructEnd()
13791 
 
3431 rajveer 13792 
  def validate(self):
13793 
    return
13794 
 
13795 
 
2591 chandransh 13796 
  def __repr__(self):
13797 
    L = ['%s=%r' % (key, value)
13798 
      for key, value in self.__dict__.iteritems()]
13799 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13800 
 
13801 
  def __eq__(self, other):
13802 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13803 
 
13804 
  def __ne__(self, other):
13805 
    return not (self == other)
13806 
 
13807 
class validateDoa_result:
13808 
  """
13809 
  Attributes:
13810 
   - success
13811 
   - ex
13812 
  """
13813 
 
13814 
  thrift_spec = (
13815 
    (0, TType.BOOL, 'success', None, None, ), # 0
13816 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
13817 
  )
13818 
 
13819 
  def __init__(self, success=None, ex=None,):
13820 
    self.success = success
13821 
    self.ex = ex
13822 
 
13823 
  def read(self, iprot):
13824 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13825 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13826 
      return
13827 
    iprot.readStructBegin()
13828 
    while True:
13829 
      (fname, ftype, fid) = iprot.readFieldBegin()
13830 
      if ftype == TType.STOP:
13831 
        break
13832 
      if fid == 0:
13833 
        if ftype == TType.BOOL:
13834 
          self.success = iprot.readBool();
13835 
        else:
13836 
          iprot.skip(ftype)
13837 
      elif fid == 1:
13838 
        if ftype == TType.STRUCT:
13839 
          self.ex = TransactionServiceException()
13840 
          self.ex.read(iprot)
13841 
        else:
13842 
          iprot.skip(ftype)
13843 
      else:
13844 
        iprot.skip(ftype)
13845 
      iprot.readFieldEnd()
13846 
    iprot.readStructEnd()
13847 
 
13848 
  def write(self, oprot):
13849 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13850 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13851 
      return
13852 
    oprot.writeStructBegin('validateDoa_result')
3431 rajveer 13853 
    if self.success is not None:
2591 chandransh 13854 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
13855 
      oprot.writeBool(self.success)
13856 
      oprot.writeFieldEnd()
3431 rajveer 13857 
    if self.ex is not None:
2591 chandransh 13858 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
13859 
      self.ex.write(oprot)
13860 
      oprot.writeFieldEnd()
13861 
    oprot.writeFieldStop()
13862 
    oprot.writeStructEnd()
13863 
 
3431 rajveer 13864 
  def validate(self):
13865 
    return
13866 
 
13867 
 
2591 chandransh 13868 
  def __repr__(self):
13869 
    L = ['%s=%r' % (key, value)
13870 
      for key, value in self.__dict__.iteritems()]
13871 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13872 
 
13873 
  def __eq__(self, other):
13874 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13875 
 
13876 
  def __ne__(self, other):
13877 
    return not (self == other)
13878 
 
4495 rajveer 13879 
class validateReturnProduct_args:
13880 
  """
13881 
  Attributes:
13882 
   - orderId
13883 
   - isUsable
13884 
  """
13885 
 
13886 
  thrift_spec = (
13887 
    None, # 0
13888 
    (1, TType.I64, 'orderId', None, None, ), # 1
13889 
    (2, TType.BOOL, 'isUsable', None, None, ), # 2
13890 
  )
13891 
 
13892 
  def __init__(self, orderId=None, isUsable=None,):
13893 
    self.orderId = orderId
13894 
    self.isUsable = isUsable
13895 
 
13896 
  def read(self, iprot):
13897 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13898 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13899 
      return
13900 
    iprot.readStructBegin()
13901 
    while True:
13902 
      (fname, ftype, fid) = iprot.readFieldBegin()
13903 
      if ftype == TType.STOP:
13904 
        break
13905 
      if fid == 1:
13906 
        if ftype == TType.I64:
13907 
          self.orderId = iprot.readI64();
13908 
        else:
13909 
          iprot.skip(ftype)
13910 
      elif fid == 2:
13911 
        if ftype == TType.BOOL:
13912 
          self.isUsable = iprot.readBool();
13913 
        else:
13914 
          iprot.skip(ftype)
13915 
      else:
13916 
        iprot.skip(ftype)
13917 
      iprot.readFieldEnd()
13918 
    iprot.readStructEnd()
13919 
 
13920 
  def write(self, oprot):
13921 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13922 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13923 
      return
13924 
    oprot.writeStructBegin('validateReturnProduct_args')
13925 
    if self.orderId is not None:
13926 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
13927 
      oprot.writeI64(self.orderId)
13928 
      oprot.writeFieldEnd()
13929 
    if self.isUsable is not None:
13930 
      oprot.writeFieldBegin('isUsable', TType.BOOL, 2)
13931 
      oprot.writeBool(self.isUsable)
13932 
      oprot.writeFieldEnd()
13933 
    oprot.writeFieldStop()
13934 
    oprot.writeStructEnd()
13935 
 
13936 
  def validate(self):
13937 
    return
13938 
 
13939 
 
13940 
  def __repr__(self):
13941 
    L = ['%s=%r' % (key, value)
13942 
      for key, value in self.__dict__.iteritems()]
13943 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13944 
 
13945 
  def __eq__(self, other):
13946 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13947 
 
13948 
  def __ne__(self, other):
13949 
    return not (self == other)
13950 
 
13951 
class validateReturnProduct_result:
13952 
  """
13953 
  Attributes:
13954 
   - success
13955 
   - ex
13956 
  """
13957 
 
13958 
  thrift_spec = (
13959 
    (0, TType.BOOL, 'success', None, None, ), # 0
13960 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
13961 
  )
13962 
 
13963 
  def __init__(self, success=None, ex=None,):
13964 
    self.success = success
13965 
    self.ex = ex
13966 
 
13967 
  def read(self, iprot):
13968 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13969 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13970 
      return
13971 
    iprot.readStructBegin()
13972 
    while True:
13973 
      (fname, ftype, fid) = iprot.readFieldBegin()
13974 
      if ftype == TType.STOP:
13975 
        break
13976 
      if fid == 0:
13977 
        if ftype == TType.BOOL:
13978 
          self.success = iprot.readBool();
13979 
        else:
13980 
          iprot.skip(ftype)
13981 
      elif fid == 1:
13982 
        if ftype == TType.STRUCT:
13983 
          self.ex = TransactionServiceException()
13984 
          self.ex.read(iprot)
13985 
        else:
13986 
          iprot.skip(ftype)
13987 
      else:
13988 
        iprot.skip(ftype)
13989 
      iprot.readFieldEnd()
13990 
    iprot.readStructEnd()
13991 
 
13992 
  def write(self, oprot):
13993 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13994 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13995 
      return
13996 
    oprot.writeStructBegin('validateReturnProduct_result')
13997 
    if self.success is not None:
13998 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
13999 
      oprot.writeBool(self.success)
14000 
      oprot.writeFieldEnd()
14001 
    if self.ex is not None:
14002 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
14003 
      self.ex.write(oprot)
14004 
      oprot.writeFieldEnd()
14005 
    oprot.writeFieldStop()
14006 
    oprot.writeStructEnd()
14007 
 
14008 
  def validate(self):
14009 
    return
14010 
 
14011 
 
14012 
  def __repr__(self):
14013 
    L = ['%s=%r' % (key, value)
14014 
      for key, value in self.__dict__.iteritems()]
14015 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14016 
 
14017 
  def __eq__(self, other):
14018 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14019 
 
14020 
  def __ne__(self, other):
14021 
    return not (self == other)
14022 
 
2616 chandransh 14023 
class reshipOrder_args:
14024 
  """
14025 
  Attributes:
14026 
   - orderId
14027 
  """
2591 chandransh 14028 
 
2616 chandransh 14029 
  thrift_spec = (
14030 
    None, # 0
14031 
    (1, TType.I64, 'orderId', None, None, ), # 1
14032 
  )
14033 
 
14034 
  def __init__(self, orderId=None,):
14035 
    self.orderId = orderId
14036 
 
14037 
  def read(self, iprot):
14038 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14039 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14040 
      return
14041 
    iprot.readStructBegin()
14042 
    while True:
14043 
      (fname, ftype, fid) = iprot.readFieldBegin()
14044 
      if ftype == TType.STOP:
14045 
        break
14046 
      if fid == 1:
14047 
        if ftype == TType.I64:
14048 
          self.orderId = iprot.readI64();
14049 
        else:
14050 
          iprot.skip(ftype)
14051 
      else:
14052 
        iprot.skip(ftype)
14053 
      iprot.readFieldEnd()
14054 
    iprot.readStructEnd()
14055 
 
14056 
  def write(self, oprot):
14057 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14058 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14059 
      return
14060 
    oprot.writeStructBegin('reshipOrder_args')
3431 rajveer 14061 
    if self.orderId is not None:
2616 chandransh 14062 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
14063 
      oprot.writeI64(self.orderId)
14064 
      oprot.writeFieldEnd()
14065 
    oprot.writeFieldStop()
14066 
    oprot.writeStructEnd()
14067 
 
3431 rajveer 14068 
  def validate(self):
14069 
    return
14070 
 
14071 
 
2616 chandransh 14072 
  def __repr__(self):
14073 
    L = ['%s=%r' % (key, value)
14074 
      for key, value in self.__dict__.iteritems()]
14075 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14076 
 
14077 
  def __eq__(self, other):
14078 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14079 
 
14080 
  def __ne__(self, other):
14081 
    return not (self == other)
14082 
 
14083 
class reshipOrder_result:
14084 
  """
14085 
  Attributes:
14086 
   - success
14087 
   - ex
14088 
  """
14089 
 
14090 
  thrift_spec = (
14091 
    (0, TType.I64, 'success', None, None, ), # 0
14092 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
14093 
  )
14094 
 
14095 
  def __init__(self, success=None, ex=None,):
14096 
    self.success = success
14097 
    self.ex = ex
14098 
 
14099 
  def read(self, iprot):
14100 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14101 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14102 
      return
14103 
    iprot.readStructBegin()
14104 
    while True:
14105 
      (fname, ftype, fid) = iprot.readFieldBegin()
14106 
      if ftype == TType.STOP:
14107 
        break
14108 
      if fid == 0:
14109 
        if ftype == TType.I64:
14110 
          self.success = iprot.readI64();
14111 
        else:
14112 
          iprot.skip(ftype)
14113 
      elif fid == 1:
14114 
        if ftype == TType.STRUCT:
14115 
          self.ex = TransactionServiceException()
14116 
          self.ex.read(iprot)
14117 
        else:
14118 
          iprot.skip(ftype)
14119 
      else:
14120 
        iprot.skip(ftype)
14121 
      iprot.readFieldEnd()
14122 
    iprot.readStructEnd()
14123 
 
14124 
  def write(self, oprot):
14125 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14126 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14127 
      return
14128 
    oprot.writeStructBegin('reshipOrder_result')
3431 rajveer 14129 
    if self.success is not None:
2616 chandransh 14130 
      oprot.writeFieldBegin('success', TType.I64, 0)
14131 
      oprot.writeI64(self.success)
14132 
      oprot.writeFieldEnd()
3431 rajveer 14133 
    if self.ex is not None:
2616 chandransh 14134 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
14135 
      self.ex.write(oprot)
14136 
      oprot.writeFieldEnd()
14137 
    oprot.writeFieldStop()
14138 
    oprot.writeStructEnd()
14139 
 
3431 rajveer 14140 
  def validate(self):
14141 
    return
14142 
 
14143 
 
2616 chandransh 14144 
  def __repr__(self):
14145 
    L = ['%s=%r' % (key, value)
14146 
      for key, value in self.__dict__.iteritems()]
14147 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14148 
 
14149 
  def __eq__(self, other):
14150 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14151 
 
14152 
  def __ne__(self, other):
14153 
    return not (self == other)
14154 
 
14155 
class refundOrder_args:
14156 
  """
14157 
  Attributes:
14158 
   - orderId
3226 chandransh 14159 
   - refundedBy
14160 
   - reason
2616 chandransh 14161 
  """
14162 
 
14163 
  thrift_spec = (
14164 
    None, # 0
14165 
    (1, TType.I64, 'orderId', None, None, ), # 1
3226 chandransh 14166 
    (2, TType.STRING, 'refundedBy', None, None, ), # 2
14167 
    (3, TType.STRING, 'reason', None, None, ), # 3
2616 chandransh 14168 
  )
14169 
 
3226 chandransh 14170 
  def __init__(self, orderId=None, refundedBy=None, reason=None,):
2616 chandransh 14171 
    self.orderId = orderId
3226 chandransh 14172 
    self.refundedBy = refundedBy
14173 
    self.reason = reason
2616 chandransh 14174 
 
14175 
  def read(self, iprot):
14176 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14177 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14178 
      return
14179 
    iprot.readStructBegin()
14180 
    while True:
14181 
      (fname, ftype, fid) = iprot.readFieldBegin()
14182 
      if ftype == TType.STOP:
14183 
        break
14184 
      if fid == 1:
14185 
        if ftype == TType.I64:
14186 
          self.orderId = iprot.readI64();
14187 
        else:
14188 
          iprot.skip(ftype)
3226 chandransh 14189 
      elif fid == 2:
14190 
        if ftype == TType.STRING:
14191 
          self.refundedBy = iprot.readString();
14192 
        else:
14193 
          iprot.skip(ftype)
14194 
      elif fid == 3:
14195 
        if ftype == TType.STRING:
14196 
          self.reason = iprot.readString();
14197 
        else:
14198 
          iprot.skip(ftype)
2616 chandransh 14199 
      else:
14200 
        iprot.skip(ftype)
14201 
      iprot.readFieldEnd()
14202 
    iprot.readStructEnd()
14203 
 
14204 
  def write(self, oprot):
14205 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14206 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14207 
      return
14208 
    oprot.writeStructBegin('refundOrder_args')
3431 rajveer 14209 
    if self.orderId is not None:
2616 chandransh 14210 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
14211 
      oprot.writeI64(self.orderId)
14212 
      oprot.writeFieldEnd()
3431 rajveer 14213 
    if self.refundedBy is not None:
3226 chandransh 14214 
      oprot.writeFieldBegin('refundedBy', TType.STRING, 2)
14215 
      oprot.writeString(self.refundedBy)
14216 
      oprot.writeFieldEnd()
3431 rajveer 14217 
    if self.reason is not None:
3226 chandransh 14218 
      oprot.writeFieldBegin('reason', TType.STRING, 3)
14219 
      oprot.writeString(self.reason)
14220 
      oprot.writeFieldEnd()
2616 chandransh 14221 
    oprot.writeFieldStop()
14222 
    oprot.writeStructEnd()
14223 
 
3431 rajveer 14224 
  def validate(self):
14225 
    return
14226 
 
14227 
 
2616 chandransh 14228 
  def __repr__(self):
14229 
    L = ['%s=%r' % (key, value)
14230 
      for key, value in self.__dict__.iteritems()]
14231 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14232 
 
14233 
  def __eq__(self, other):
14234 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14235 
 
14236 
  def __ne__(self, other):
14237 
    return not (self == other)
14238 
 
14239 
class refundOrder_result:
14240 
  """
14241 
  Attributes:
14242 
   - success
14243 
   - ex
14244 
  """
14245 
 
14246 
  thrift_spec = (
14247 
    (0, TType.BOOL, 'success', None, None, ), # 0
14248 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
14249 
  )
14250 
 
14251 
  def __init__(self, success=None, ex=None,):
14252 
    self.success = success
14253 
    self.ex = ex
14254 
 
14255 
  def read(self, iprot):
14256 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14257 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14258 
      return
14259 
    iprot.readStructBegin()
14260 
    while True:
14261 
      (fname, ftype, fid) = iprot.readFieldBegin()
14262 
      if ftype == TType.STOP:
14263 
        break
14264 
      if fid == 0:
14265 
        if ftype == TType.BOOL:
14266 
          self.success = iprot.readBool();
14267 
        else:
14268 
          iprot.skip(ftype)
14269 
      elif fid == 1:
14270 
        if ftype == TType.STRUCT:
14271 
          self.ex = TransactionServiceException()
14272 
          self.ex.read(iprot)
14273 
        else:
14274 
          iprot.skip(ftype)
14275 
      else:
14276 
        iprot.skip(ftype)
14277 
      iprot.readFieldEnd()
14278 
    iprot.readStructEnd()
14279 
 
14280 
  def write(self, oprot):
14281 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14282 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14283 
      return
14284 
    oprot.writeStructBegin('refundOrder_result')
3431 rajveer 14285 
    if self.success is not None:
2616 chandransh 14286 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
14287 
      oprot.writeBool(self.success)
14288 
      oprot.writeFieldEnd()
3431 rajveer 14289 
    if self.ex is not None:
2616 chandransh 14290 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
14291 
      self.ex.write(oprot)
14292 
      oprot.writeFieldEnd()
14293 
    oprot.writeFieldStop()
14294 
    oprot.writeStructEnd()
14295 
 
3431 rajveer 14296 
  def validate(self):
14297 
    return
14298 
 
14299 
 
2616 chandransh 14300 
  def __repr__(self):
14301 
    L = ['%s=%r' % (key, value)
14302 
      for key, value in self.__dict__.iteritems()]
14303 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14304 
 
14305 
  def __eq__(self, other):
14306 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14307 
 
14308 
  def __ne__(self, other):
14309 
    return not (self == other)
14310 
 
2690 chandransh 14311 
class getReturnOrders_args:
14312 
  """
14313 
  Attributes:
14314 
   - warehouseId
14315 
   - fromDate
14316 
   - toDate
14317 
  """
2616 chandransh 14318 
 
2690 chandransh 14319 
  thrift_spec = (
14320 
    None, # 0
14321 
    (1, TType.I64, 'warehouseId', None, None, ), # 1
14322 
    (2, TType.I64, 'fromDate', None, None, ), # 2
14323 
    (3, TType.I64, 'toDate', None, None, ), # 3
14324 
  )
14325 
 
14326 
  def __init__(self, warehouseId=None, fromDate=None, toDate=None,):
14327 
    self.warehouseId = warehouseId
14328 
    self.fromDate = fromDate
14329 
    self.toDate = toDate
14330 
 
14331 
  def read(self, iprot):
14332 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14333 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14334 
      return
14335 
    iprot.readStructBegin()
14336 
    while True:
14337 
      (fname, ftype, fid) = iprot.readFieldBegin()
14338 
      if ftype == TType.STOP:
14339 
        break
14340 
      if fid == 1:
14341 
        if ftype == TType.I64:
14342 
          self.warehouseId = iprot.readI64();
14343 
        else:
14344 
          iprot.skip(ftype)
14345 
      elif fid == 2:
14346 
        if ftype == TType.I64:
14347 
          self.fromDate = iprot.readI64();
14348 
        else:
14349 
          iprot.skip(ftype)
14350 
      elif fid == 3:
14351 
        if ftype == TType.I64:
14352 
          self.toDate = iprot.readI64();
14353 
        else:
14354 
          iprot.skip(ftype)
14355 
      else:
14356 
        iprot.skip(ftype)
14357 
      iprot.readFieldEnd()
14358 
    iprot.readStructEnd()
14359 
 
14360 
  def write(self, oprot):
14361 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14362 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14363 
      return
14364 
    oprot.writeStructBegin('getReturnOrders_args')
3431 rajveer 14365 
    if self.warehouseId is not None:
2690 chandransh 14366 
      oprot.writeFieldBegin('warehouseId', TType.I64, 1)
14367 
      oprot.writeI64(self.warehouseId)
14368 
      oprot.writeFieldEnd()
3431 rajveer 14369 
    if self.fromDate is not None:
2690 chandransh 14370 
      oprot.writeFieldBegin('fromDate', TType.I64, 2)
14371 
      oprot.writeI64(self.fromDate)
14372 
      oprot.writeFieldEnd()
3431 rajveer 14373 
    if self.toDate is not None:
2690 chandransh 14374 
      oprot.writeFieldBegin('toDate', TType.I64, 3)
14375 
      oprot.writeI64(self.toDate)
14376 
      oprot.writeFieldEnd()
14377 
    oprot.writeFieldStop()
14378 
    oprot.writeStructEnd()
14379 
 
3431 rajveer 14380 
  def validate(self):
14381 
    return
14382 
 
14383 
 
2690 chandransh 14384 
  def __repr__(self):
14385 
    L = ['%s=%r' % (key, value)
14386 
      for key, value in self.__dict__.iteritems()]
14387 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14388 
 
14389 
  def __eq__(self, other):
14390 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14391 
 
14392 
  def __ne__(self, other):
14393 
    return not (self == other)
14394 
 
14395 
class getReturnOrders_result:
14396 
  """
14397 
  Attributes:
14398 
   - success
14399 
  """
14400 
 
14401 
  thrift_spec = (
14402 
    (0, TType.LIST, 'success', (TType.STRUCT,(ReturnOrder, ReturnOrder.thrift_spec)), None, ), # 0
14403 
  )
14404 
 
14405 
  def __init__(self, success=None,):
14406 
    self.success = success
14407 
 
14408 
  def read(self, iprot):
14409 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14410 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14411 
      return
14412 
    iprot.readStructBegin()
14413 
    while True:
14414 
      (fname, ftype, fid) = iprot.readFieldBegin()
14415 
      if ftype == TType.STOP:
14416 
        break
14417 
      if fid == 0:
14418 
        if ftype == TType.LIST:
14419 
          self.success = []
4837 varun.gupt 14420 
          (_etype281, _size278) = iprot.readListBegin()
14421 
          for _i282 in xrange(_size278):
14422 
            _elem283 = ReturnOrder()
14423 
            _elem283.read(iprot)
14424 
            self.success.append(_elem283)
2690 chandransh 14425 
          iprot.readListEnd()
14426 
        else:
14427 
          iprot.skip(ftype)
14428 
      else:
14429 
        iprot.skip(ftype)
14430 
      iprot.readFieldEnd()
14431 
    iprot.readStructEnd()
14432 
 
14433 
  def write(self, oprot):
14434 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14435 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14436 
      return
14437 
    oprot.writeStructBegin('getReturnOrders_result')
3431 rajveer 14438 
    if self.success is not None:
2690 chandransh 14439 
      oprot.writeFieldBegin('success', TType.LIST, 0)
14440 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
4837 varun.gupt 14441 
      for iter284 in self.success:
14442 
        iter284.write(oprot)
2690 chandransh 14443 
      oprot.writeListEnd()
14444 
      oprot.writeFieldEnd()
14445 
    oprot.writeFieldStop()
14446 
    oprot.writeStructEnd()
14447 
 
3431 rajveer 14448 
  def validate(self):
14449 
    return
14450 
 
14451 
 
2690 chandransh 14452 
  def __repr__(self):
14453 
    L = ['%s=%r' % (key, value)
14454 
      for key, value in self.__dict__.iteritems()]
14455 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14456 
 
14457 
  def __eq__(self, other):
14458 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14459 
 
14460 
  def __ne__(self, other):
14461 
    return not (self == other)
14462 
 
2700 chandransh 14463 
class getReturnOrder_args:
14464 
  """
14465 
  Attributes:
14466 
   - id
14467 
  """
14468 
 
14469 
  thrift_spec = (
14470 
    None, # 0
14471 
    (1, TType.I64, 'id', None, None, ), # 1
14472 
  )
14473 
 
14474 
  def __init__(self, id=None,):
14475 
    self.id = id
14476 
 
14477 
  def read(self, iprot):
14478 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14479 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14480 
      return
14481 
    iprot.readStructBegin()
14482 
    while True:
14483 
      (fname, ftype, fid) = iprot.readFieldBegin()
14484 
      if ftype == TType.STOP:
14485 
        break
14486 
      if fid == 1:
14487 
        if ftype == TType.I64:
14488 
          self.id = iprot.readI64();
14489 
        else:
14490 
          iprot.skip(ftype)
14491 
      else:
14492 
        iprot.skip(ftype)
14493 
      iprot.readFieldEnd()
14494 
    iprot.readStructEnd()
14495 
 
14496 
  def write(self, oprot):
14497 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14498 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14499 
      return
14500 
    oprot.writeStructBegin('getReturnOrder_args')
3431 rajveer 14501 
    if self.id is not None:
2700 chandransh 14502 
      oprot.writeFieldBegin('id', TType.I64, 1)
14503 
      oprot.writeI64(self.id)
14504 
      oprot.writeFieldEnd()
14505 
    oprot.writeFieldStop()
14506 
    oprot.writeStructEnd()
14507 
 
3431 rajveer 14508 
  def validate(self):
14509 
    return
14510 
 
14511 
 
2700 chandransh 14512 
  def __repr__(self):
14513 
    L = ['%s=%r' % (key, value)
14514 
      for key, value in self.__dict__.iteritems()]
14515 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14516 
 
14517 
  def __eq__(self, other):
14518 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14519 
 
14520 
  def __ne__(self, other):
14521 
    return not (self == other)
14522 
 
14523 
class getReturnOrder_result:
14524 
  """
14525 
  Attributes:
14526 
   - success
14527 
   - ex
14528 
  """
14529 
 
14530 
  thrift_spec = (
14531 
    (0, TType.STRUCT, 'success', (ReturnOrder, ReturnOrder.thrift_spec), None, ), # 0
14532 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
14533 
  )
14534 
 
14535 
  def __init__(self, success=None, ex=None,):
14536 
    self.success = success
14537 
    self.ex = ex
14538 
 
14539 
  def read(self, iprot):
14540 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14541 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14542 
      return
14543 
    iprot.readStructBegin()
14544 
    while True:
14545 
      (fname, ftype, fid) = iprot.readFieldBegin()
14546 
      if ftype == TType.STOP:
14547 
        break
14548 
      if fid == 0:
14549 
        if ftype == TType.STRUCT:
14550 
          self.success = ReturnOrder()
14551 
          self.success.read(iprot)
14552 
        else:
14553 
          iprot.skip(ftype)
14554 
      elif fid == 1:
14555 
        if ftype == TType.STRUCT:
14556 
          self.ex = TransactionServiceException()
14557 
          self.ex.read(iprot)
14558 
        else:
14559 
          iprot.skip(ftype)
14560 
      else:
14561 
        iprot.skip(ftype)
14562 
      iprot.readFieldEnd()
14563 
    iprot.readStructEnd()
14564 
 
14565 
  def write(self, oprot):
14566 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14567 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14568 
      return
14569 
    oprot.writeStructBegin('getReturnOrder_result')
3431 rajveer 14570 
    if self.success is not None:
2700 chandransh 14571 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
14572 
      self.success.write(oprot)
14573 
      oprot.writeFieldEnd()
3431 rajveer 14574 
    if self.ex is not None:
2700 chandransh 14575 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
14576 
      self.ex.write(oprot)
14577 
      oprot.writeFieldEnd()
14578 
    oprot.writeFieldStop()
14579 
    oprot.writeStructEnd()
14580 
 
3431 rajveer 14581 
  def validate(self):
14582 
    return
14583 
 
14584 
 
2700 chandransh 14585 
  def __repr__(self):
14586 
    L = ['%s=%r' % (key, value)
14587 
      for key, value in self.__dict__.iteritems()]
14588 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14589 
 
14590 
  def __eq__(self, other):
14591 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14592 
 
14593 
  def __ne__(self, other):
14594 
    return not (self == other)
14595 
 
2690 chandransh 14596 
class processReturn_args:
14597 
  """
14598 
  Attributes:
14599 
   - returnOrderId
14600 
  """
14601 
 
14602 
  thrift_spec = (
14603 
    None, # 0
14604 
    (1, TType.I64, 'returnOrderId', None, None, ), # 1
14605 
  )
14606 
 
14607 
  def __init__(self, returnOrderId=None,):
14608 
    self.returnOrderId = returnOrderId
14609 
 
14610 
  def read(self, iprot):
14611 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14612 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14613 
      return
14614 
    iprot.readStructBegin()
14615 
    while True:
14616 
      (fname, ftype, fid) = iprot.readFieldBegin()
14617 
      if ftype == TType.STOP:
14618 
        break
14619 
      if fid == 1:
14620 
        if ftype == TType.I64:
14621 
          self.returnOrderId = iprot.readI64();
14622 
        else:
14623 
          iprot.skip(ftype)
14624 
      else:
14625 
        iprot.skip(ftype)
14626 
      iprot.readFieldEnd()
14627 
    iprot.readStructEnd()
14628 
 
14629 
  def write(self, oprot):
14630 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14631 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14632 
      return
14633 
    oprot.writeStructBegin('processReturn_args')
3431 rajveer 14634 
    if self.returnOrderId is not None:
2690 chandransh 14635 
      oprot.writeFieldBegin('returnOrderId', TType.I64, 1)
14636 
      oprot.writeI64(self.returnOrderId)
14637 
      oprot.writeFieldEnd()
14638 
    oprot.writeFieldStop()
14639 
    oprot.writeStructEnd()
14640 
 
3431 rajveer 14641 
  def validate(self):
14642 
    return
14643 
 
14644 
 
2690 chandransh 14645 
  def __repr__(self):
14646 
    L = ['%s=%r' % (key, value)
14647 
      for key, value in self.__dict__.iteritems()]
14648 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14649 
 
14650 
  def __eq__(self, other):
14651 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14652 
 
14653 
  def __ne__(self, other):
14654 
    return not (self == other)
14655 
 
14656 
class processReturn_result:
14657 
  """
14658 
  Attributes:
14659 
   - ex
14660 
  """
14661 
 
14662 
  thrift_spec = (
14663 
    None, # 0
14664 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
14665 
  )
14666 
 
14667 
  def __init__(self, ex=None,):
14668 
    self.ex = ex
14669 
 
14670 
  def read(self, iprot):
14671 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14672 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14673 
      return
14674 
    iprot.readStructBegin()
14675 
    while True:
14676 
      (fname, ftype, fid) = iprot.readFieldBegin()
14677 
      if ftype == TType.STOP:
14678 
        break
14679 
      if fid == 1:
14680 
        if ftype == TType.STRUCT:
14681 
          self.ex = TransactionServiceException()
14682 
          self.ex.read(iprot)
14683 
        else:
14684 
          iprot.skip(ftype)
14685 
      else:
14686 
        iprot.skip(ftype)
14687 
      iprot.readFieldEnd()
14688 
    iprot.readStructEnd()
14689 
 
14690 
  def write(self, oprot):
14691 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14692 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14693 
      return
14694 
    oprot.writeStructBegin('processReturn_result')
3431 rajveer 14695 
    if self.ex is not None:
2690 chandransh 14696 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
14697 
      self.ex.write(oprot)
14698 
      oprot.writeFieldEnd()
14699 
    oprot.writeFieldStop()
14700 
    oprot.writeStructEnd()
14701 
 
3431 rajveer 14702 
  def validate(self):
14703 
    return
14704 
 
14705 
 
2690 chandransh 14706 
  def __repr__(self):
14707 
    L = ['%s=%r' % (key, value)
14708 
      for key, value in self.__dict__.iteritems()]
14709 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14710 
 
14711 
  def __eq__(self, other):
14712 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14713 
 
14714 
  def __ne__(self, other):
14715 
    return not (self == other)
14716 
 
3451 chandransh 14717 
class updateWeight_args:
14718 
  """
14719 
  Attributes:
14720 
   - orderId
14721 
   - weight
14722 
  """
14723 
 
14724 
  thrift_spec = (
14725 
    None, # 0
14726 
    (1, TType.I64, 'orderId', None, None, ), # 1
14727 
    (2, TType.DOUBLE, 'weight', None, None, ), # 2
14728 
  )
14729 
 
14730 
  def __init__(self, orderId=None, weight=None,):
14731 
    self.orderId = orderId
14732 
    self.weight = weight
14733 
 
14734 
  def read(self, iprot):
14735 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14736 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14737 
      return
14738 
    iprot.readStructBegin()
14739 
    while True:
14740 
      (fname, ftype, fid) = iprot.readFieldBegin()
14741 
      if ftype == TType.STOP:
14742 
        break
14743 
      if fid == 1:
14744 
        if ftype == TType.I64:
14745 
          self.orderId = iprot.readI64();
14746 
        else:
14747 
          iprot.skip(ftype)
14748 
      elif fid == 2:
14749 
        if ftype == TType.DOUBLE:
14750 
          self.weight = iprot.readDouble();
14751 
        else:
14752 
          iprot.skip(ftype)
14753 
      else:
14754 
        iprot.skip(ftype)
14755 
      iprot.readFieldEnd()
14756 
    iprot.readStructEnd()
14757 
 
14758 
  def write(self, oprot):
14759 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14760 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14761 
      return
14762 
    oprot.writeStructBegin('updateWeight_args')
14763 
    if self.orderId is not None:
14764 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
14765 
      oprot.writeI64(self.orderId)
14766 
      oprot.writeFieldEnd()
14767 
    if self.weight is not None:
14768 
      oprot.writeFieldBegin('weight', TType.DOUBLE, 2)
14769 
      oprot.writeDouble(self.weight)
14770 
      oprot.writeFieldEnd()
14771 
    oprot.writeFieldStop()
14772 
    oprot.writeStructEnd()
14773 
 
14774 
  def validate(self):
14775 
    return
14776 
 
14777 
 
14778 
  def __repr__(self):
14779 
    L = ['%s=%r' % (key, value)
14780 
      for key, value in self.__dict__.iteritems()]
14781 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14782 
 
14783 
  def __eq__(self, other):
14784 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14785 
 
14786 
  def __ne__(self, other):
14787 
    return not (self == other)
14788 
 
14789 
class updateWeight_result:
14790 
  """
14791 
  Attributes:
14792 
   - success
14793 
   - ex
14794 
  """
14795 
 
14796 
  thrift_spec = (
14797 
    (0, TType.STRUCT, 'success', (Order, Order.thrift_spec), None, ), # 0
14798 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
14799 
  )
14800 
 
14801 
  def __init__(self, success=None, ex=None,):
14802 
    self.success = success
14803 
    self.ex = ex
14804 
 
14805 
  def read(self, iprot):
14806 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14807 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14808 
      return
14809 
    iprot.readStructBegin()
14810 
    while True:
14811 
      (fname, ftype, fid) = iprot.readFieldBegin()
14812 
      if ftype == TType.STOP:
14813 
        break
14814 
      if fid == 0:
14815 
        if ftype == TType.STRUCT:
14816 
          self.success = Order()
14817 
          self.success.read(iprot)
14818 
        else:
14819 
          iprot.skip(ftype)
14820 
      elif fid == 1:
14821 
        if ftype == TType.STRUCT:
14822 
          self.ex = TransactionServiceException()
14823 
          self.ex.read(iprot)
14824 
        else:
14825 
          iprot.skip(ftype)
14826 
      else:
14827 
        iprot.skip(ftype)
14828 
      iprot.readFieldEnd()
14829 
    iprot.readStructEnd()
14830 
 
14831 
  def write(self, oprot):
14832 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14833 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14834 
      return
14835 
    oprot.writeStructBegin('updateWeight_result')
14836 
    if self.success is not None:
14837 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
14838 
      self.success.write(oprot)
14839 
      oprot.writeFieldEnd()
14840 
    if self.ex is not None:
14841 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
14842 
      self.ex.write(oprot)
14843 
      oprot.writeFieldEnd()
14844 
    oprot.writeFieldStop()
14845 
    oprot.writeStructEnd()
14846 
 
14847 
  def validate(self):
14848 
    return
14849 
 
14850 
 
14851 
  def __repr__(self):
14852 
    L = ['%s=%r' % (key, value)
14853 
      for key, value in self.__dict__.iteritems()]
14854 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14855 
 
14856 
  def __eq__(self, other):
14857 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14858 
 
14859 
  def __ne__(self, other):
14860 
    return not (self == other)
3469 chandransh 14861 
 
14862 
class changeItem_args:
14863 
  """
14864 
  Attributes:
14865 
   - orderId
14866 
   - itemId
14867 
  """
14868 
 
14869 
  thrift_spec = (
14870 
    None, # 0
14871 
    (1, TType.I64, 'orderId', None, None, ), # 1
14872 
    (2, TType.I64, 'itemId', None, None, ), # 2
14873 
  )
14874 
 
14875 
  def __init__(self, orderId=None, itemId=None,):
14876 
    self.orderId = orderId
14877 
    self.itemId = itemId
14878 
 
14879 
  def read(self, iprot):
14880 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14881 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14882 
      return
14883 
    iprot.readStructBegin()
14884 
    while True:
14885 
      (fname, ftype, fid) = iprot.readFieldBegin()
14886 
      if ftype == TType.STOP:
14887 
        break
14888 
      if fid == 1:
14889 
        if ftype == TType.I64:
14890 
          self.orderId = iprot.readI64();
14891 
        else:
14892 
          iprot.skip(ftype)
14893 
      elif fid == 2:
14894 
        if ftype == TType.I64:
14895 
          self.itemId = iprot.readI64();
14896 
        else:
14897 
          iprot.skip(ftype)
14898 
      else:
14899 
        iprot.skip(ftype)
14900 
      iprot.readFieldEnd()
14901 
    iprot.readStructEnd()
14902 
 
14903 
  def write(self, oprot):
14904 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14905 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14906 
      return
14907 
    oprot.writeStructBegin('changeItem_args')
14908 
    if self.orderId is not None:
14909 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
14910 
      oprot.writeI64(self.orderId)
14911 
      oprot.writeFieldEnd()
14912 
    if self.itemId is not None:
14913 
      oprot.writeFieldBegin('itemId', TType.I64, 2)
14914 
      oprot.writeI64(self.itemId)
14915 
      oprot.writeFieldEnd()
14916 
    oprot.writeFieldStop()
14917 
    oprot.writeStructEnd()
14918 
 
14919 
  def validate(self):
14920 
    return
14921 
 
14922 
 
14923 
  def __repr__(self):
14924 
    L = ['%s=%r' % (key, value)
14925 
      for key, value in self.__dict__.iteritems()]
14926 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14927 
 
14928 
  def __eq__(self, other):
14929 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14930 
 
14931 
  def __ne__(self, other):
14932 
    return not (self == other)
14933 
 
14934 
class changeItem_result:
14935 
  """
14936 
  Attributes:
14937 
   - success
14938 
   - ex
14939 
  """
14940 
 
14941 
  thrift_spec = (
14942 
    (0, TType.STRUCT, 'success', (Order, Order.thrift_spec), None, ), # 0
14943 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
14944 
  )
14945 
 
14946 
  def __init__(self, success=None, ex=None,):
14947 
    self.success = success
14948 
    self.ex = ex
14949 
 
14950 
  def read(self, iprot):
14951 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14952 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14953 
      return
14954 
    iprot.readStructBegin()
14955 
    while True:
14956 
      (fname, ftype, fid) = iprot.readFieldBegin()
14957 
      if ftype == TType.STOP:
14958 
        break
14959 
      if fid == 0:
14960 
        if ftype == TType.STRUCT:
14961 
          self.success = Order()
14962 
          self.success.read(iprot)
14963 
        else:
14964 
          iprot.skip(ftype)
14965 
      elif fid == 1:
14966 
        if ftype == TType.STRUCT:
14967 
          self.ex = TransactionServiceException()
14968 
          self.ex.read(iprot)
14969 
        else:
14970 
          iprot.skip(ftype)
14971 
      else:
14972 
        iprot.skip(ftype)
14973 
      iprot.readFieldEnd()
14974 
    iprot.readStructEnd()
14975 
 
14976 
  def write(self, oprot):
14977 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14978 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14979 
      return
14980 
    oprot.writeStructBegin('changeItem_result')
14981 
    if self.success is not None:
14982 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
14983 
      self.success.write(oprot)
14984 
      oprot.writeFieldEnd()
14985 
    if self.ex is not None:
14986 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
14987 
      self.ex.write(oprot)
14988 
      oprot.writeFieldEnd()
14989 
    oprot.writeFieldStop()
14990 
    oprot.writeStructEnd()
14991 
 
14992 
  def validate(self):
14993 
    return
14994 
 
14995 
 
14996 
  def __repr__(self):
14997 
    L = ['%s=%r' % (key, value)
14998 
      for key, value in self.__dict__.iteritems()]
14999 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15000 
 
15001 
  def __eq__(self, other):
15002 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15003 
 
15004 
  def __ne__(self, other):
15005 
    return not (self == other)
15006 
 
15007 
class shiftToWarehouse_args:
15008 
  """
15009 
  Attributes:
15010 
   - orderId
15011 
   - warehouseId
15012 
  """
15013 
 
15014 
  thrift_spec = (
15015 
    None, # 0
15016 
    (1, TType.I64, 'orderId', None, None, ), # 1
15017 
    (2, TType.I64, 'warehouseId', None, None, ), # 2
15018 
  )
15019 
 
15020 
  def __init__(self, orderId=None, warehouseId=None,):
15021 
    self.orderId = orderId
15022 
    self.warehouseId = warehouseId
15023 
 
15024 
  def read(self, iprot):
15025 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15026 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15027 
      return
15028 
    iprot.readStructBegin()
15029 
    while True:
15030 
      (fname, ftype, fid) = iprot.readFieldBegin()
15031 
      if ftype == TType.STOP:
15032 
        break
15033 
      if fid == 1:
15034 
        if ftype == TType.I64:
15035 
          self.orderId = iprot.readI64();
15036 
        else:
15037 
          iprot.skip(ftype)
15038 
      elif fid == 2:
15039 
        if ftype == TType.I64:
15040 
          self.warehouseId = iprot.readI64();
15041 
        else:
15042 
          iprot.skip(ftype)
15043 
      else:
15044 
        iprot.skip(ftype)
15045 
      iprot.readFieldEnd()
15046 
    iprot.readStructEnd()
15047 
 
15048 
  def write(self, oprot):
15049 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15050 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15051 
      return
15052 
    oprot.writeStructBegin('shiftToWarehouse_args')
15053 
    if self.orderId is not None:
15054 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
15055 
      oprot.writeI64(self.orderId)
15056 
      oprot.writeFieldEnd()
15057 
    if self.warehouseId is not None:
15058 
      oprot.writeFieldBegin('warehouseId', TType.I64, 2)
15059 
      oprot.writeI64(self.warehouseId)
15060 
      oprot.writeFieldEnd()
15061 
    oprot.writeFieldStop()
15062 
    oprot.writeStructEnd()
15063 
 
15064 
  def validate(self):
15065 
    return
15066 
 
15067 
 
15068 
  def __repr__(self):
15069 
    L = ['%s=%r' % (key, value)
15070 
      for key, value in self.__dict__.iteritems()]
15071 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15072 
 
15073 
  def __eq__(self, other):
15074 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15075 
 
15076 
  def __ne__(self, other):
15077 
    return not (self == other)
15078 
 
15079 
class shiftToWarehouse_result:
15080 
  """
15081 
  Attributes:
15082 
   - success
15083 
   - ex
15084 
  """
15085 
 
15086 
  thrift_spec = (
15087 
    (0, TType.STRUCT, 'success', (Order, Order.thrift_spec), None, ), # 0
15088 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
15089 
  )
15090 
 
15091 
  def __init__(self, success=None, ex=None,):
15092 
    self.success = success
15093 
    self.ex = ex
15094 
 
15095 
  def read(self, iprot):
15096 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15097 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15098 
      return
15099 
    iprot.readStructBegin()
15100 
    while True:
15101 
      (fname, ftype, fid) = iprot.readFieldBegin()
15102 
      if ftype == TType.STOP:
15103 
        break
15104 
      if fid == 0:
15105 
        if ftype == TType.STRUCT:
15106 
          self.success = Order()
15107 
          self.success.read(iprot)
15108 
        else:
15109 
          iprot.skip(ftype)
15110 
      elif fid == 1:
15111 
        if ftype == TType.STRUCT:
15112 
          self.ex = TransactionServiceException()
15113 
          self.ex.read(iprot)
15114 
        else:
15115 
          iprot.skip(ftype)
15116 
      else:
15117 
        iprot.skip(ftype)
15118 
      iprot.readFieldEnd()
15119 
    iprot.readStructEnd()
15120 
 
15121 
  def write(self, oprot):
15122 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15123 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15124 
      return
15125 
    oprot.writeStructBegin('shiftToWarehouse_result')
15126 
    if self.success is not None:
15127 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
15128 
      self.success.write(oprot)
15129 
      oprot.writeFieldEnd()
15130 
    if self.ex is not None:
15131 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
15132 
      self.ex.write(oprot)
15133 
      oprot.writeFieldEnd()
15134 
    oprot.writeFieldStop()
15135 
    oprot.writeStructEnd()
15136 
 
15137 
  def validate(self):
15138 
    return
15139 
 
15140 
 
15141 
  def __repr__(self):
15142 
    L = ['%s=%r' % (key, value)
15143 
      for key, value in self.__dict__.iteritems()]
15144 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15145 
 
15146 
  def __eq__(self, other):
15147 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15148 
 
15149 
  def __ne__(self, other):
15150 
    return not (self == other)
3553 chandransh 15151 
 
15152 
class addDelayReason_args:
15153 
  """
15154 
  Attributes:
15155 
   - orderId
15156 
   - delayReason
3986 chandransh 15157 
   - furtherDelay
4647 rajveer 15158 
   - delayReasonText
3553 chandransh 15159 
  """
15160 
 
15161 
  thrift_spec = (
15162 
    None, # 0
15163 
    (1, TType.I64, 'orderId', None, None, ), # 1
15164 
    (2, TType.I32, 'delayReason', None, None, ), # 2
3986 chandransh 15165 
    (3, TType.I64, 'furtherDelay', None, None, ), # 3
4647 rajveer 15166 
    (4, TType.STRING, 'delayReasonText', None, None, ), # 4
3553 chandransh 15167 
  )
15168 
 
4647 rajveer 15169 
  def __init__(self, orderId=None, delayReason=None, furtherDelay=None, delayReasonText=None,):
3553 chandransh 15170 
    self.orderId = orderId
15171 
    self.delayReason = delayReason
3986 chandransh 15172 
    self.furtherDelay = furtherDelay
4647 rajveer 15173 
    self.delayReasonText = delayReasonText
3553 chandransh 15174 
 
15175 
  def read(self, iprot):
15176 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15177 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15178 
      return
15179 
    iprot.readStructBegin()
15180 
    while True:
15181 
      (fname, ftype, fid) = iprot.readFieldBegin()
15182 
      if ftype == TType.STOP:
15183 
        break
15184 
      if fid == 1:
15185 
        if ftype == TType.I64:
15186 
          self.orderId = iprot.readI64();
15187 
        else:
15188 
          iprot.skip(ftype)
15189 
      elif fid == 2:
15190 
        if ftype == TType.I32:
15191 
          self.delayReason = iprot.readI32();
15192 
        else:
15193 
          iprot.skip(ftype)
3986 chandransh 15194 
      elif fid == 3:
15195 
        if ftype == TType.I64:
15196 
          self.furtherDelay = iprot.readI64();
15197 
        else:
15198 
          iprot.skip(ftype)
4647 rajveer 15199 
      elif fid == 4:
15200 
        if ftype == TType.STRING:
15201 
          self.delayReasonText = iprot.readString();
15202 
        else:
15203 
          iprot.skip(ftype)
3553 chandransh 15204 
      else:
15205 
        iprot.skip(ftype)
15206 
      iprot.readFieldEnd()
15207 
    iprot.readStructEnd()
15208 
 
15209 
  def write(self, oprot):
15210 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15211 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15212 
      return
15213 
    oprot.writeStructBegin('addDelayReason_args')
15214 
    if self.orderId is not None:
15215 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
15216 
      oprot.writeI64(self.orderId)
15217 
      oprot.writeFieldEnd()
15218 
    if self.delayReason is not None:
15219 
      oprot.writeFieldBegin('delayReason', TType.I32, 2)
15220 
      oprot.writeI32(self.delayReason)
15221 
      oprot.writeFieldEnd()
3986 chandransh 15222 
    if self.furtherDelay is not None:
15223 
      oprot.writeFieldBegin('furtherDelay', TType.I64, 3)
15224 
      oprot.writeI64(self.furtherDelay)
15225 
      oprot.writeFieldEnd()
4647 rajveer 15226 
    if self.delayReasonText is not None:
15227 
      oprot.writeFieldBegin('delayReasonText', TType.STRING, 4)
15228 
      oprot.writeString(self.delayReasonText)
15229 
      oprot.writeFieldEnd()
3553 chandransh 15230 
    oprot.writeFieldStop()
15231 
    oprot.writeStructEnd()
15232 
 
15233 
  def validate(self):
15234 
    return
15235 
 
15236 
 
15237 
  def __repr__(self):
15238 
    L = ['%s=%r' % (key, value)
15239 
      for key, value in self.__dict__.iteritems()]
15240 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15241 
 
15242 
  def __eq__(self, other):
15243 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15244 
 
15245 
  def __ne__(self, other):
15246 
    return not (self == other)
15247 
 
15248 
class addDelayReason_result:
15249 
  """
15250 
  Attributes:
15251 
   - success
15252 
   - ex
15253 
  """
15254 
 
15255 
  thrift_spec = (
15256 
    (0, TType.BOOL, 'success', None, None, ), # 0
15257 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
15258 
  )
15259 
 
15260 
  def __init__(self, success=None, ex=None,):
15261 
    self.success = success
15262 
    self.ex = ex
15263 
 
15264 
  def read(self, iprot):
15265 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15266 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15267 
      return
15268 
    iprot.readStructBegin()
15269 
    while True:
15270 
      (fname, ftype, fid) = iprot.readFieldBegin()
15271 
      if ftype == TType.STOP:
15272 
        break
15273 
      if fid == 0:
15274 
        if ftype == TType.BOOL:
15275 
          self.success = iprot.readBool();
15276 
        else:
15277 
          iprot.skip(ftype)
15278 
      elif fid == 1:
15279 
        if ftype == TType.STRUCT:
15280 
          self.ex = TransactionServiceException()
15281 
          self.ex.read(iprot)
15282 
        else:
15283 
          iprot.skip(ftype)
15284 
      else:
15285 
        iprot.skip(ftype)
15286 
      iprot.readFieldEnd()
15287 
    iprot.readStructEnd()
15288 
 
15289 
  def write(self, oprot):
15290 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15291 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15292 
      return
15293 
    oprot.writeStructBegin('addDelayReason_result')
15294 
    if self.success is not None:
15295 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
15296 
      oprot.writeBool(self.success)
15297 
      oprot.writeFieldEnd()
15298 
    if self.ex is not None:
15299 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
15300 
      self.ex.write(oprot)
15301 
      oprot.writeFieldEnd()
15302 
    oprot.writeFieldStop()
15303 
    oprot.writeStructEnd()
15304 
 
15305 
  def validate(self):
15306 
    return
15307 
 
15308 
 
15309 
  def __repr__(self):
15310 
    L = ['%s=%r' % (key, value)
15311 
      for key, value in self.__dict__.iteritems()]
15312 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15313 
 
15314 
  def __eq__(self, other):
15315 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15316 
 
15317 
  def __ne__(self, other):
15318 
    return not (self == other)
3956 chandransh 15319 
 
15320 
class reconcileCodCollection_args:
15321 
  """
15322 
  Attributes:
15323 
   - collectedAmountMap
15324 
   - xferBy
15325 
   - xferTxnId
15326 
   - xferDate
15327 
  """
15328 
 
15329 
  thrift_spec = (
15330 
    None, # 0
15331 
    (1, TType.MAP, 'collectedAmountMap', (TType.STRING,None,TType.DOUBLE,None), None, ), # 1
15332 
    (2, TType.STRING, 'xferBy', None, None, ), # 2
15333 
    (3, TType.STRING, 'xferTxnId', None, None, ), # 3
15334 
    (4, TType.I64, 'xferDate', None, None, ), # 4
15335 
  )
15336 
 
15337 
  def __init__(self, collectedAmountMap=None, xferBy=None, xferTxnId=None, xferDate=None,):
15338 
    self.collectedAmountMap = collectedAmountMap
15339 
    self.xferBy = xferBy
15340 
    self.xferTxnId = xferTxnId
15341 
    self.xferDate = xferDate
15342 
 
15343 
  def read(self, iprot):
15344 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15345 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15346 
      return
15347 
    iprot.readStructBegin()
15348 
    while True:
15349 
      (fname, ftype, fid) = iprot.readFieldBegin()
15350 
      if ftype == TType.STOP:
15351 
        break
15352 
      if fid == 1:
15353 
        if ftype == TType.MAP:
15354 
          self.collectedAmountMap = {}
4837 varun.gupt 15355 
          (_ktype286, _vtype287, _size285 ) = iprot.readMapBegin()
15356 
          for _i289 in xrange(_size285):
15357 
            _key290 = iprot.readString();
15358 
            _val291 = iprot.readDouble();
15359 
            self.collectedAmountMap[_key290] = _val291
3956 chandransh 15360 
          iprot.readMapEnd()
15361 
        else:
15362 
          iprot.skip(ftype)
15363 
      elif fid == 2:
15364 
        if ftype == TType.STRING:
15365 
          self.xferBy = iprot.readString();
15366 
        else:
15367 
          iprot.skip(ftype)
15368 
      elif fid == 3:
15369 
        if ftype == TType.STRING:
15370 
          self.xferTxnId = iprot.readString();
15371 
        else:
15372 
          iprot.skip(ftype)
15373 
      elif fid == 4:
15374 
        if ftype == TType.I64:
15375 
          self.xferDate = iprot.readI64();
15376 
        else:
15377 
          iprot.skip(ftype)
15378 
      else:
15379 
        iprot.skip(ftype)
15380 
      iprot.readFieldEnd()
15381 
    iprot.readStructEnd()
15382 
 
15383 
  def write(self, oprot):
15384 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15385 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15386 
      return
15387 
    oprot.writeStructBegin('reconcileCodCollection_args')
15388 
    if self.collectedAmountMap is not None:
15389 
      oprot.writeFieldBegin('collectedAmountMap', TType.MAP, 1)
15390 
      oprot.writeMapBegin(TType.STRING, TType.DOUBLE, len(self.collectedAmountMap))
4837 varun.gupt 15391 
      for kiter292,viter293 in self.collectedAmountMap.items():
15392 
        oprot.writeString(kiter292)
15393 
        oprot.writeDouble(viter293)
3956 chandransh 15394 
      oprot.writeMapEnd()
15395 
      oprot.writeFieldEnd()
15396 
    if self.xferBy is not None:
15397 
      oprot.writeFieldBegin('xferBy', TType.STRING, 2)
15398 
      oprot.writeString(self.xferBy)
15399 
      oprot.writeFieldEnd()
15400 
    if self.xferTxnId is not None:
15401 
      oprot.writeFieldBegin('xferTxnId', TType.STRING, 3)
15402 
      oprot.writeString(self.xferTxnId)
15403 
      oprot.writeFieldEnd()
15404 
    if self.xferDate is not None:
15405 
      oprot.writeFieldBegin('xferDate', TType.I64, 4)
15406 
      oprot.writeI64(self.xferDate)
15407 
      oprot.writeFieldEnd()
15408 
    oprot.writeFieldStop()
15409 
    oprot.writeStructEnd()
15410 
 
15411 
  def validate(self):
15412 
    return
15413 
 
15414 
 
15415 
  def __repr__(self):
15416 
    L = ['%s=%r' % (key, value)
15417 
      for key, value in self.__dict__.iteritems()]
15418 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15419 
 
15420 
  def __eq__(self, other):
15421 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15422 
 
15423 
  def __ne__(self, other):
15424 
    return not (self == other)
15425 
 
15426 
class reconcileCodCollection_result:
15427 
  """
15428 
  Attributes:
15429 
   - success
15430 
   - ex
15431 
  """
15432 
 
15433 
  thrift_spec = (
15434 
    (0, TType.MAP, 'success', (TType.STRING,None,TType.STRING,None), None, ), # 0
15435 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
15436 
  )
15437 
 
15438 
  def __init__(self, success=None, ex=None,):
15439 
    self.success = success
15440 
    self.ex = ex
15441 
 
15442 
  def read(self, iprot):
15443 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15444 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15445 
      return
15446 
    iprot.readStructBegin()
15447 
    while True:
15448 
      (fname, ftype, fid) = iprot.readFieldBegin()
15449 
      if ftype == TType.STOP:
15450 
        break
15451 
      if fid == 0:
15452 
        if ftype == TType.MAP:
15453 
          self.success = {}
4837 varun.gupt 15454 
          (_ktype295, _vtype296, _size294 ) = iprot.readMapBegin()
15455 
          for _i298 in xrange(_size294):
15456 
            _key299 = iprot.readString();
15457 
            _val300 = iprot.readString();
15458 
            self.success[_key299] = _val300
3956 chandransh 15459 
          iprot.readMapEnd()
15460 
        else:
15461 
          iprot.skip(ftype)
15462 
      elif fid == 1:
15463 
        if ftype == TType.STRUCT:
15464 
          self.ex = TransactionServiceException()
15465 
          self.ex.read(iprot)
15466 
        else:
15467 
          iprot.skip(ftype)
15468 
      else:
15469 
        iprot.skip(ftype)
15470 
      iprot.readFieldEnd()
15471 
    iprot.readStructEnd()
15472 
 
15473 
  def write(self, oprot):
15474 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15475 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15476 
      return
15477 
    oprot.writeStructBegin('reconcileCodCollection_result')
15478 
    if self.success is not None:
15479 
      oprot.writeFieldBegin('success', TType.MAP, 0)
15480 
      oprot.writeMapBegin(TType.STRING, TType.STRING, len(self.success))
4837 varun.gupt 15481 
      for kiter301,viter302 in self.success.items():
15482 
        oprot.writeString(kiter301)
15483 
        oprot.writeString(viter302)
3956 chandransh 15484 
      oprot.writeMapEnd()
15485 
      oprot.writeFieldEnd()
15486 
    if self.ex is not None:
15487 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
15488 
      self.ex.write(oprot)
15489 
      oprot.writeFieldEnd()
15490 
    oprot.writeFieldStop()
15491 
    oprot.writeStructEnd()
15492 
 
15493 
  def validate(self):
15494 
    return
15495 
 
15496 
 
15497 
  def __repr__(self):
15498 
    L = ['%s=%r' % (key, value)
15499 
      for key, value in self.__dict__.iteritems()]
15500 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15501 
 
15502 
  def __eq__(self, other):
15503 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15504 
 
15505 
  def __ne__(self, other):
15506 
    return not (self == other)
4008 mandeep.dh 15507 
 
15508 
class getTransactionsRequiringExtraProcessing_args:
15509 
  """
15510 
  Attributes:
15511 
   - category
15512 
  """
15513 
 
15514 
  thrift_spec = (
15515 
    None, # 0
15516 
    (1, TType.I32, 'category', None, None, ), # 1
15517 
  )
15518 
 
15519 
  def __init__(self, category=None,):
15520 
    self.category = category
15521 
 
15522 
  def read(self, iprot):
15523 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15524 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15525 
      return
15526 
    iprot.readStructBegin()
15527 
    while True:
15528 
      (fname, ftype, fid) = iprot.readFieldBegin()
15529 
      if ftype == TType.STOP:
15530 
        break
15531 
      if fid == 1:
15532 
        if ftype == TType.I32:
15533 
          self.category = iprot.readI32();
15534 
        else:
15535 
          iprot.skip(ftype)
15536 
      else:
15537 
        iprot.skip(ftype)
15538 
      iprot.readFieldEnd()
15539 
    iprot.readStructEnd()
15540 
 
15541 
  def write(self, oprot):
15542 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15543 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15544 
      return
15545 
    oprot.writeStructBegin('getTransactionsRequiringExtraProcessing_args')
15546 
    if self.category is not None:
15547 
      oprot.writeFieldBegin('category', TType.I32, 1)
15548 
      oprot.writeI32(self.category)
15549 
      oprot.writeFieldEnd()
15550 
    oprot.writeFieldStop()
15551 
    oprot.writeStructEnd()
15552 
 
15553 
  def validate(self):
15554 
    return
15555 
 
15556 
 
15557 
  def __repr__(self):
15558 
    L = ['%s=%r' % (key, value)
15559 
      for key, value in self.__dict__.iteritems()]
15560 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15561 
 
15562 
  def __eq__(self, other):
15563 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15564 
 
15565 
  def __ne__(self, other):
15566 
    return not (self == other)
15567 
 
15568 
class getTransactionsRequiringExtraProcessing_result:
15569 
  """
15570 
  Attributes:
15571 
   - success
15572 
  """
15573 
 
15574 
  thrift_spec = (
15575 
    (0, TType.LIST, 'success', (TType.I64,None), None, ), # 0
15576 
  )
15577 
 
15578 
  def __init__(self, success=None,):
15579 
    self.success = success
15580 
 
15581 
  def read(self, iprot):
15582 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15583 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15584 
      return
15585 
    iprot.readStructBegin()
15586 
    while True:
15587 
      (fname, ftype, fid) = iprot.readFieldBegin()
15588 
      if ftype == TType.STOP:
15589 
        break
15590 
      if fid == 0:
15591 
        if ftype == TType.LIST:
15592 
          self.success = []
4837 varun.gupt 15593 
          (_etype306, _size303) = iprot.readListBegin()
15594 
          for _i307 in xrange(_size303):
15595 
            _elem308 = iprot.readI64();
15596 
            self.success.append(_elem308)
4008 mandeep.dh 15597 
          iprot.readListEnd()
15598 
        else:
15599 
          iprot.skip(ftype)
15600 
      else:
15601 
        iprot.skip(ftype)
15602 
      iprot.readFieldEnd()
15603 
    iprot.readStructEnd()
15604 
 
15605 
  def write(self, oprot):
15606 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15607 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15608 
      return
15609 
    oprot.writeStructBegin('getTransactionsRequiringExtraProcessing_result')
15610 
    if self.success is not None:
15611 
      oprot.writeFieldBegin('success', TType.LIST, 0)
15612 
      oprot.writeListBegin(TType.I64, len(self.success))
4837 varun.gupt 15613 
      for iter309 in self.success:
15614 
        oprot.writeI64(iter309)
4008 mandeep.dh 15615 
      oprot.writeListEnd()
15616 
      oprot.writeFieldEnd()
15617 
    oprot.writeFieldStop()
15618 
    oprot.writeStructEnd()
15619 
 
15620 
  def validate(self):
15621 
    return
15622 
 
15623 
 
15624 
  def __repr__(self):
15625 
    L = ['%s=%r' % (key, value)
15626 
      for key, value in self.__dict__.iteritems()]
15627 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15628 
 
15629 
  def __eq__(self, other):
15630 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15631 
 
15632 
  def __ne__(self, other):
15633 
    return not (self == other)
15634 
 
15635 
class markTransactionAsProcessed_args:
15636 
  """
15637 
  Attributes:
15638 
   - transactionId
15639 
   - category
15640 
  """
15641 
 
15642 
  thrift_spec = (
15643 
    None, # 0
15644 
    (1, TType.I64, 'transactionId', None, None, ), # 1
15645 
    (2, TType.I32, 'category', None, None, ), # 2
15646 
  )
15647 
 
15648 
  def __init__(self, transactionId=None, category=None,):
15649 
    self.transactionId = transactionId
15650 
    self.category = category
15651 
 
15652 
  def read(self, iprot):
15653 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15654 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15655 
      return
15656 
    iprot.readStructBegin()
15657 
    while True:
15658 
      (fname, ftype, fid) = iprot.readFieldBegin()
15659 
      if ftype == TType.STOP:
15660 
        break
15661 
      if fid == 1:
15662 
        if ftype == TType.I64:
15663 
          self.transactionId = iprot.readI64();
15664 
        else:
15665 
          iprot.skip(ftype)
15666 
      elif fid == 2:
15667 
        if ftype == TType.I32:
15668 
          self.category = iprot.readI32();
15669 
        else:
15670 
          iprot.skip(ftype)
15671 
      else:
15672 
        iprot.skip(ftype)
15673 
      iprot.readFieldEnd()
15674 
    iprot.readStructEnd()
15675 
 
15676 
  def write(self, oprot):
15677 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15678 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15679 
      return
15680 
    oprot.writeStructBegin('markTransactionAsProcessed_args')
15681 
    if self.transactionId is not None:
15682 
      oprot.writeFieldBegin('transactionId', TType.I64, 1)
15683 
      oprot.writeI64(self.transactionId)
15684 
      oprot.writeFieldEnd()
15685 
    if self.category is not None:
15686 
      oprot.writeFieldBegin('category', TType.I32, 2)
15687 
      oprot.writeI32(self.category)
15688 
      oprot.writeFieldEnd()
15689 
    oprot.writeFieldStop()
15690 
    oprot.writeStructEnd()
15691 
 
15692 
  def validate(self):
15693 
    return
15694 
 
15695 
 
15696 
  def __repr__(self):
15697 
    L = ['%s=%r' % (key, value)
15698 
      for key, value in self.__dict__.iteritems()]
15699 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15700 
 
15701 
  def __eq__(self, other):
15702 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15703 
 
15704 
  def __ne__(self, other):
15705 
    return not (self == other)
15706 
 
15707 
class markTransactionAsProcessed_result:
15708 
 
15709 
  thrift_spec = (
15710 
  )
15711 
 
15712 
  def read(self, iprot):
15713 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15714 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15715 
      return
15716 
    iprot.readStructBegin()
15717 
    while True:
15718 
      (fname, ftype, fid) = iprot.readFieldBegin()
15719 
      if ftype == TType.STOP:
15720 
        break
15721 
      else:
15722 
        iprot.skip(ftype)
15723 
      iprot.readFieldEnd()
15724 
    iprot.readStructEnd()
15725 
 
15726 
  def write(self, oprot):
15727 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15728 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15729 
      return
15730 
    oprot.writeStructBegin('markTransactionAsProcessed_result')
15731 
    oprot.writeFieldStop()
15732 
    oprot.writeStructEnd()
15733 
 
15734 
  def validate(self):
15735 
    return
15736 
 
15737 
 
15738 
  def __repr__(self):
15739 
    L = ['%s=%r' % (key, value)
15740 
      for key, value in self.__dict__.iteritems()]
15741 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15742 
 
15743 
  def __eq__(self, other):
15744 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15745 
 
15746 
  def __ne__(self, other):
15747 
    return not (self == other)
4018 chandransh 15748 
 
15749 
class getItemWiseRiskyOrdersCount_args:
15750 
 
15751 
  thrift_spec = (
15752 
  )
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 
      else:
15764 
        iprot.skip(ftype)
15765 
      iprot.readFieldEnd()
15766 
    iprot.readStructEnd()
15767 
 
15768 
  def write(self, oprot):
15769 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15770 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15771 
      return
15772 
    oprot.writeStructBegin('getItemWiseRiskyOrdersCount_args')
15773 
    oprot.writeFieldStop()
15774 
    oprot.writeStructEnd()
15775 
 
15776 
  def validate(self):
15777 
    return
15778 
 
15779 
 
15780 
  def __repr__(self):
15781 
    L = ['%s=%r' % (key, value)
15782 
      for key, value in self.__dict__.iteritems()]
15783 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15784 
 
15785 
  def __eq__(self, other):
15786 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15787 
 
15788 
  def __ne__(self, other):
15789 
    return not (self == other)
15790 
 
15791 
class getItemWiseRiskyOrdersCount_result:
15792 
  """
15793 
  Attributes:
15794 
   - success
15795 
  """
15796 
 
15797 
  thrift_spec = (
15798 
    (0, TType.MAP, 'success', (TType.I64,None,TType.I64,None), None, ), # 0
15799 
  )
15800 
 
15801 
  def __init__(self, success=None,):
15802 
    self.success = success
15803 
 
15804 
  def read(self, iprot):
15805 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15806 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15807 
      return
15808 
    iprot.readStructBegin()
15809 
    while True:
15810 
      (fname, ftype, fid) = iprot.readFieldBegin()
15811 
      if ftype == TType.STOP:
15812 
        break
15813 
      if fid == 0:
15814 
        if ftype == TType.MAP:
15815 
          self.success = {}
4837 varun.gupt 15816 
          (_ktype311, _vtype312, _size310 ) = iprot.readMapBegin()
15817 
          for _i314 in xrange(_size310):
15818 
            _key315 = iprot.readI64();
15819 
            _val316 = iprot.readI64();
15820 
            self.success[_key315] = _val316
4018 chandransh 15821 
          iprot.readMapEnd()
15822 
        else:
15823 
          iprot.skip(ftype)
15824 
      else:
15825 
        iprot.skip(ftype)
15826 
      iprot.readFieldEnd()
15827 
    iprot.readStructEnd()
15828 
 
15829 
  def write(self, oprot):
15830 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15831 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15832 
      return
15833 
    oprot.writeStructBegin('getItemWiseRiskyOrdersCount_result')
15834 
    if self.success is not None:
15835 
      oprot.writeFieldBegin('success', TType.MAP, 0)
15836 
      oprot.writeMapBegin(TType.I64, TType.I64, len(self.success))
4837 varun.gupt 15837 
      for kiter317,viter318 in self.success.items():
15838 
        oprot.writeI64(kiter317)
15839 
        oprot.writeI64(viter318)
4018 chandransh 15840 
      oprot.writeMapEnd()
15841 
      oprot.writeFieldEnd()
15842 
    oprot.writeFieldStop()
15843 
    oprot.writeStructEnd()
15844 
 
15845 
  def validate(self):
15846 
    return
15847 
 
15848 
 
15849 
  def __repr__(self):
15850 
    L = ['%s=%r' % (key, value)
15851 
      for key, value in self.__dict__.iteritems()]
15852 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15853 
 
15854 
  def __eq__(self, other):
15855 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15856 
 
15857 
  def __ne__(self, other):
15858 
    return not (self == other)
4247 rajveer 15859 
 
4295 varun.gupt 15860 
class getOrdersForItemIds_args:
15861 
  """
15862 
  Attributes:
15863 
   - itemIds
15864 
  """
15865 
 
15866 
  thrift_spec = (
15867 
    None, # 0
15868 
    (1, TType.LIST, 'itemIds', (TType.I64,None), None, ), # 1
15869 
  )
15870 
 
15871 
  def __init__(self, itemIds=None,):
15872 
    self.itemIds = itemIds
15873 
 
15874 
  def read(self, iprot):
15875 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15876 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15877 
      return
15878 
    iprot.readStructBegin()
15879 
    while True:
15880 
      (fname, ftype, fid) = iprot.readFieldBegin()
15881 
      if ftype == TType.STOP:
15882 
        break
15883 
      if fid == 1:
15884 
        if ftype == TType.LIST:
15885 
          self.itemIds = []
4837 varun.gupt 15886 
          (_etype322, _size319) = iprot.readListBegin()
15887 
          for _i323 in xrange(_size319):
15888 
            _elem324 = iprot.readI64();
15889 
            self.itemIds.append(_elem324)
4295 varun.gupt 15890 
          iprot.readListEnd()
15891 
        else:
15892 
          iprot.skip(ftype)
15893 
      else:
15894 
        iprot.skip(ftype)
15895 
      iprot.readFieldEnd()
15896 
    iprot.readStructEnd()
15897 
 
15898 
  def write(self, oprot):
15899 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15900 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15901 
      return
15902 
    oprot.writeStructBegin('getOrdersForItemIds_args')
15903 
    if self.itemIds is not None:
15904 
      oprot.writeFieldBegin('itemIds', TType.LIST, 1)
15905 
      oprot.writeListBegin(TType.I64, len(self.itemIds))
4837 varun.gupt 15906 
      for iter325 in self.itemIds:
15907 
        oprot.writeI64(iter325)
4295 varun.gupt 15908 
      oprot.writeListEnd()
15909 
      oprot.writeFieldEnd()
15910 
    oprot.writeFieldStop()
15911 
    oprot.writeStructEnd()
15912 
 
15913 
  def validate(self):
15914 
    return
15915 
 
15916 
 
15917 
  def __repr__(self):
15918 
    L = ['%s=%r' % (key, value)
15919 
      for key, value in self.__dict__.iteritems()]
15920 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15921 
 
15922 
  def __eq__(self, other):
15923 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15924 
 
15925 
  def __ne__(self, other):
15926 
    return not (self == other)
15927 
 
15928 
class getOrdersForItemIds_result:
15929 
  """
15930 
  Attributes:
15931 
   - success
15932 
  """
15933 
 
15934 
  thrift_spec = (
15935 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
15936 
  )
15937 
 
15938 
  def __init__(self, success=None,):
15939 
    self.success = success
15940 
 
15941 
  def read(self, iprot):
15942 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15943 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15944 
      return
15945 
    iprot.readStructBegin()
15946 
    while True:
15947 
      (fname, ftype, fid) = iprot.readFieldBegin()
15948 
      if ftype == TType.STOP:
15949 
        break
15950 
      if fid == 0:
15951 
        if ftype == TType.LIST:
15952 
          self.success = []
4837 varun.gupt 15953 
          (_etype329, _size326) = iprot.readListBegin()
15954 
          for _i330 in xrange(_size326):
15955 
            _elem331 = Order()
15956 
            _elem331.read(iprot)
15957 
            self.success.append(_elem331)
4295 varun.gupt 15958 
          iprot.readListEnd()
15959 
        else:
15960 
          iprot.skip(ftype)
15961 
      else:
15962 
        iprot.skip(ftype)
15963 
      iprot.readFieldEnd()
15964 
    iprot.readStructEnd()
15965 
 
15966 
  def write(self, oprot):
15967 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15968 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15969 
      return
15970 
    oprot.writeStructBegin('getOrdersForItemIds_result')
15971 
    if self.success is not None:
15972 
      oprot.writeFieldBegin('success', TType.LIST, 0)
15973 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
4837 varun.gupt 15974 
      for iter332 in self.success:
15975 
        iter332.write(oprot)
4295 varun.gupt 15976 
      oprot.writeListEnd()
15977 
      oprot.writeFieldEnd()
15978 
    oprot.writeFieldStop()
15979 
    oprot.writeStructEnd()
15980 
 
15981 
  def validate(self):
15982 
    return
15983 
 
15984 
 
15985 
  def __repr__(self):
15986 
    L = ['%s=%r' % (key, value)
15987 
      for key, value in self.__dict__.iteritems()]
15988 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15989 
 
15990 
  def __eq__(self, other):
15991 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15992 
 
15993 
  def __ne__(self, other):
15994 
    return not (self == other)
15995 
 
4247 rajveer 15996 
class markOrderCancellationRequestReceived_args:
15997 
  """
15998 
  Attributes:
15999 
   - orderId
16000 
  """
16001 
 
16002 
  thrift_spec = (
16003 
    None, # 0
16004 
    (1, TType.I64, 'orderId', None, None, ), # 1
16005 
  )
16006 
 
16007 
  def __init__(self, orderId=None,):
16008 
    self.orderId = orderId
16009 
 
16010 
  def read(self, iprot):
16011 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16012 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16013 
      return
16014 
    iprot.readStructBegin()
16015 
    while True:
16016 
      (fname, ftype, fid) = iprot.readFieldBegin()
16017 
      if ftype == TType.STOP:
16018 
        break
16019 
      if fid == 1:
16020 
        if ftype == TType.I64:
16021 
          self.orderId = iprot.readI64();
16022 
        else:
16023 
          iprot.skip(ftype)
16024 
      else:
16025 
        iprot.skip(ftype)
16026 
      iprot.readFieldEnd()
16027 
    iprot.readStructEnd()
16028 
 
16029 
  def write(self, oprot):
16030 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16031 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16032 
      return
16033 
    oprot.writeStructBegin('markOrderCancellationRequestReceived_args')
16034 
    if self.orderId is not None:
16035 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
16036 
      oprot.writeI64(self.orderId)
16037 
      oprot.writeFieldEnd()
16038 
    oprot.writeFieldStop()
16039 
    oprot.writeStructEnd()
16040 
 
16041 
  def validate(self):
16042 
    return
16043 
 
16044 
 
16045 
  def __repr__(self):
16046 
    L = ['%s=%r' % (key, value)
16047 
      for key, value in self.__dict__.iteritems()]
16048 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16049 
 
16050 
  def __eq__(self, other):
16051 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16052 
 
16053 
  def __ne__(self, other):
16054 
    return not (self == other)
16055 
 
16056 
class markOrderCancellationRequestReceived_result:
16057 
  """
16058 
  Attributes:
16059 
   - ex
16060 
  """
16061 
 
16062 
  thrift_spec = (
16063 
    None, # 0
16064 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
16065 
  )
16066 
 
16067 
  def __init__(self, ex=None,):
16068 
    self.ex = ex
16069 
 
16070 
  def read(self, iprot):
16071 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16072 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16073 
      return
16074 
    iprot.readStructBegin()
16075 
    while True:
16076 
      (fname, ftype, fid) = iprot.readFieldBegin()
16077 
      if ftype == TType.STOP:
16078 
        break
16079 
      if fid == 1:
16080 
        if ftype == TType.STRUCT:
16081 
          self.ex = TransactionServiceException()
16082 
          self.ex.read(iprot)
16083 
        else:
16084 
          iprot.skip(ftype)
16085 
      else:
16086 
        iprot.skip(ftype)
16087 
      iprot.readFieldEnd()
16088 
    iprot.readStructEnd()
16089 
 
16090 
  def write(self, oprot):
16091 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16092 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16093 
      return
16094 
    oprot.writeStructBegin('markOrderCancellationRequestReceived_result')
16095 
    if self.ex is not None:
16096 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
16097 
      self.ex.write(oprot)
16098 
      oprot.writeFieldEnd()
16099 
    oprot.writeFieldStop()
16100 
    oprot.writeStructEnd()
16101 
 
16102 
  def validate(self):
16103 
    return
16104 
 
16105 
 
16106 
  def __repr__(self):
16107 
    L = ['%s=%r' % (key, value)
16108 
      for key, value in self.__dict__.iteritems()]
16109 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16110 
 
16111 
  def __eq__(self, other):
16112 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16113 
 
16114 
  def __ne__(self, other):
16115 
    return not (self == other)
16116 
 
16117 
class markOrderCancellationRequestConfirmed_args:
16118 
  """
16119 
  Attributes:
16120 
   - orderId
16121 
  """
16122 
 
16123 
  thrift_spec = (
16124 
    None, # 0
16125 
    (1, TType.I64, 'orderId', None, None, ), # 1
16126 
  )
16127 
 
16128 
  def __init__(self, orderId=None,):
16129 
    self.orderId = orderId
16130 
 
16131 
  def read(self, iprot):
16132 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16133 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16134 
      return
16135 
    iprot.readStructBegin()
16136 
    while True:
16137 
      (fname, ftype, fid) = iprot.readFieldBegin()
16138 
      if ftype == TType.STOP:
16139 
        break
16140 
      if fid == 1:
16141 
        if ftype == TType.I64:
16142 
          self.orderId = iprot.readI64();
16143 
        else:
16144 
          iprot.skip(ftype)
16145 
      else:
16146 
        iprot.skip(ftype)
16147 
      iprot.readFieldEnd()
16148 
    iprot.readStructEnd()
16149 
 
16150 
  def write(self, oprot):
16151 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16152 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16153 
      return
16154 
    oprot.writeStructBegin('markOrderCancellationRequestConfirmed_args')
16155 
    if self.orderId is not None:
16156 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
16157 
      oprot.writeI64(self.orderId)
16158 
      oprot.writeFieldEnd()
16159 
    oprot.writeFieldStop()
16160 
    oprot.writeStructEnd()
16161 
 
16162 
  def validate(self):
16163 
    return
16164 
 
16165 
 
16166 
  def __repr__(self):
16167 
    L = ['%s=%r' % (key, value)
16168 
      for key, value in self.__dict__.iteritems()]
16169 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16170 
 
16171 
  def __eq__(self, other):
16172 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16173 
 
16174 
  def __ne__(self, other):
16175 
    return not (self == other)
16176 
 
16177 
class markOrderCancellationRequestConfirmed_result:
16178 
  """
16179 
  Attributes:
16180 
   - ex
16181 
  """
16182 
 
16183 
  thrift_spec = (
16184 
    None, # 0
16185 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
16186 
  )
16187 
 
16188 
  def __init__(self, ex=None,):
16189 
    self.ex = ex
16190 
 
16191 
  def read(self, iprot):
16192 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16193 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16194 
      return
16195 
    iprot.readStructBegin()
16196 
    while True:
16197 
      (fname, ftype, fid) = iprot.readFieldBegin()
16198 
      if ftype == TType.STOP:
16199 
        break
16200 
      if fid == 1:
16201 
        if ftype == TType.STRUCT:
16202 
          self.ex = TransactionServiceException()
16203 
          self.ex.read(iprot)
16204 
        else:
16205 
          iprot.skip(ftype)
16206 
      else:
16207 
        iprot.skip(ftype)
16208 
      iprot.readFieldEnd()
16209 
    iprot.readStructEnd()
16210 
 
16211 
  def write(self, oprot):
16212 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16213 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16214 
      return
16215 
    oprot.writeStructBegin('markOrderCancellationRequestConfirmed_result')
16216 
    if self.ex is not None:
16217 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
16218 
      self.ex.write(oprot)
16219 
      oprot.writeFieldEnd()
16220 
    oprot.writeFieldStop()
16221 
    oprot.writeStructEnd()
16222 
 
16223 
  def validate(self):
16224 
    return
16225 
 
16226 
 
16227 
  def __repr__(self):
16228 
    L = ['%s=%r' % (key, value)
16229 
      for key, value in self.__dict__.iteritems()]
16230 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16231 
 
16232 
  def __eq__(self, other):
16233 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16234 
 
16235 
  def __ne__(self, other):
16236 
    return not (self == other)
16237 
 
16238 
class markOrderCancellationRequestDenied_args:
16239 
  """
16240 
  Attributes:
16241 
   - orderId
16242 
  """
16243 
 
16244 
  thrift_spec = (
16245 
    None, # 0
16246 
    (1, TType.I64, 'orderId', None, None, ), # 1
16247 
  )
16248 
 
16249 
  def __init__(self, orderId=None,):
16250 
    self.orderId = orderId
16251 
 
16252 
  def read(self, iprot):
16253 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16254 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16255 
      return
16256 
    iprot.readStructBegin()
16257 
    while True:
16258 
      (fname, ftype, fid) = iprot.readFieldBegin()
16259 
      if ftype == TType.STOP:
16260 
        break
16261 
      if fid == 1:
16262 
        if ftype == TType.I64:
16263 
          self.orderId = iprot.readI64();
16264 
        else:
16265 
          iprot.skip(ftype)
16266 
      else:
16267 
        iprot.skip(ftype)
16268 
      iprot.readFieldEnd()
16269 
    iprot.readStructEnd()
16270 
 
16271 
  def write(self, oprot):
16272 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16273 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16274 
      return
16275 
    oprot.writeStructBegin('markOrderCancellationRequestDenied_args')
16276 
    if self.orderId is not None:
16277 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
16278 
      oprot.writeI64(self.orderId)
16279 
      oprot.writeFieldEnd()
16280 
    oprot.writeFieldStop()
16281 
    oprot.writeStructEnd()
16282 
 
16283 
  def validate(self):
16284 
    return
16285 
 
16286 
 
16287 
  def __repr__(self):
16288 
    L = ['%s=%r' % (key, value)
16289 
      for key, value in self.__dict__.iteritems()]
16290 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16291 
 
16292 
  def __eq__(self, other):
16293 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16294 
 
16295 
  def __ne__(self, other):
16296 
    return not (self == other)
16297 
 
16298 
class markOrderCancellationRequestDenied_result:
16299 
  """
16300 
  Attributes:
16301 
   - ex
16302 
  """
16303 
 
16304 
  thrift_spec = (
16305 
    None, # 0
16306 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
16307 
  )
16308 
 
16309 
  def __init__(self, ex=None,):
16310 
    self.ex = ex
16311 
 
16312 
  def read(self, iprot):
16313 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16314 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16315 
      return
16316 
    iprot.readStructBegin()
16317 
    while True:
16318 
      (fname, ftype, fid) = iprot.readFieldBegin()
16319 
      if ftype == TType.STOP:
16320 
        break
16321 
      if fid == 1:
16322 
        if ftype == TType.STRUCT:
16323 
          self.ex = TransactionServiceException()
16324 
          self.ex.read(iprot)
16325 
        else:
16326 
          iprot.skip(ftype)
16327 
      else:
16328 
        iprot.skip(ftype)
16329 
      iprot.readFieldEnd()
16330 
    iprot.readStructEnd()
16331 
 
16332 
  def write(self, oprot):
16333 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16334 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16335 
      return
16336 
    oprot.writeStructBegin('markOrderCancellationRequestDenied_result')
16337 
    if self.ex is not None:
16338 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
16339 
      self.ex.write(oprot)
16340 
      oprot.writeFieldEnd()
16341 
    oprot.writeFieldStop()
16342 
    oprot.writeStructEnd()
16343 
 
16344 
  def validate(self):
16345 
    return
16346 
 
16347 
 
16348 
  def __repr__(self):
16349 
    L = ['%s=%r' % (key, value)
16350 
      for key, value in self.__dict__.iteritems()]
16351 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16352 
 
16353 
  def __eq__(self, other):
16354 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16355 
 
16356 
  def __ne__(self, other):
16357 
    return not (self == other)
16358 
 
4258 rajveer 16359 
class markTransactionAsPaymentFlagRemoved_args:
4247 rajveer 16360 
  """
16361 
  Attributes:
4258 rajveer 16362 
   - transactionId
4247 rajveer 16363 
  """
16364 
 
16365 
  thrift_spec = (
16366 
    None, # 0
4258 rajveer 16367 
    (1, TType.I64, 'transactionId', None, None, ), # 1
4247 rajveer 16368 
  )
16369 
 
4258 rajveer 16370 
  def __init__(self, transactionId=None,):
16371 
    self.transactionId = transactionId
4247 rajveer 16372 
 
16373 
  def read(self, iprot):
16374 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16375 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16376 
      return
16377 
    iprot.readStructBegin()
16378 
    while True:
16379 
      (fname, ftype, fid) = iprot.readFieldBegin()
16380 
      if ftype == TType.STOP:
16381 
        break
16382 
      if fid == 1:
16383 
        if ftype == TType.I64:
4258 rajveer 16384 
          self.transactionId = iprot.readI64();
4247 rajveer 16385 
        else:
16386 
          iprot.skip(ftype)
16387 
      else:
16388 
        iprot.skip(ftype)
16389 
      iprot.readFieldEnd()
16390 
    iprot.readStructEnd()
16391 
 
16392 
  def write(self, oprot):
16393 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16394 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16395 
      return
4258 rajveer 16396 
    oprot.writeStructBegin('markTransactionAsPaymentFlagRemoved_args')
16397 
    if self.transactionId is not None:
16398 
      oprot.writeFieldBegin('transactionId', TType.I64, 1)
16399 
      oprot.writeI64(self.transactionId)
4247 rajveer 16400 
      oprot.writeFieldEnd()
16401 
    oprot.writeFieldStop()
16402 
    oprot.writeStructEnd()
16403 
 
16404 
  def validate(self):
16405 
    return
16406 
 
16407 
 
16408 
  def __repr__(self):
16409 
    L = ['%s=%r' % (key, value)
16410 
      for key, value in self.__dict__.iteritems()]
16411 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16412 
 
16413 
  def __eq__(self, other):
16414 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16415 
 
16416 
  def __ne__(self, other):
16417 
    return not (self == other)
16418 
 
4258 rajveer 16419 
class markTransactionAsPaymentFlagRemoved_result:
4247 rajveer 16420 
  """
16421 
  Attributes:
16422 
   - ex
16423 
  """
16424 
 
16425 
  thrift_spec = (
16426 
    None, # 0
16427 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
16428 
  )
16429 
 
16430 
  def __init__(self, ex=None,):
16431 
    self.ex = ex
16432 
 
16433 
  def read(self, iprot):
16434 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16435 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16436 
      return
16437 
    iprot.readStructBegin()
16438 
    while True:
16439 
      (fname, ftype, fid) = iprot.readFieldBegin()
16440 
      if ftype == TType.STOP:
16441 
        break
16442 
      if fid == 1:
16443 
        if ftype == TType.STRUCT:
16444 
          self.ex = TransactionServiceException()
16445 
          self.ex.read(iprot)
16446 
        else:
16447 
          iprot.skip(ftype)
16448 
      else:
16449 
        iprot.skip(ftype)
16450 
      iprot.readFieldEnd()
16451 
    iprot.readStructEnd()
16452 
 
16453 
  def write(self, oprot):
16454 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16455 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16456 
      return
4258 rajveer 16457 
    oprot.writeStructBegin('markTransactionAsPaymentFlagRemoved_result')
4247 rajveer 16458 
    if self.ex is not None:
16459 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
16460 
      self.ex.write(oprot)
16461 
      oprot.writeFieldEnd()
16462 
    oprot.writeFieldStop()
16463 
    oprot.writeStructEnd()
16464 
 
16465 
  def validate(self):
16466 
    return
16467 
 
16468 
 
16469 
  def __repr__(self):
16470 
    L = ['%s=%r' % (key, value)
16471 
      for key, value in self.__dict__.iteritems()]
16472 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16473 
 
16474 
  def __eq__(self, other):
16475 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16476 
 
16477 
  def __ne__(self, other):
16478 
    return not (self == other)
4259 anupam.sin 16479 
 
16480 
class refundTransaction_args:
16481 
  """
16482 
  Attributes:
16483 
   - transactionId
16484 
   - refundedBy
16485 
   - reason
16486 
  """
16487 
 
16488 
  thrift_spec = (
16489 
    None, # 0
16490 
    (1, TType.I64, 'transactionId', None, None, ), # 1
16491 
    (2, TType.STRING, 'refundedBy', None, None, ), # 2
16492 
    (3, TType.STRING, 'reason', None, None, ), # 3
16493 
  )
16494 
 
16495 
  def __init__(self, transactionId=None, refundedBy=None, reason=None,):
16496 
    self.transactionId = transactionId
16497 
    self.refundedBy = refundedBy
16498 
    self.reason = reason
16499 
 
16500 
  def read(self, iprot):
16501 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16502 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16503 
      return
16504 
    iprot.readStructBegin()
16505 
    while True:
16506 
      (fname, ftype, fid) = iprot.readFieldBegin()
16507 
      if ftype == TType.STOP:
16508 
        break
16509 
      if fid == 1:
16510 
        if ftype == TType.I64:
16511 
          self.transactionId = iprot.readI64();
16512 
        else:
16513 
          iprot.skip(ftype)
16514 
      elif fid == 2:
16515 
        if ftype == TType.STRING:
16516 
          self.refundedBy = iprot.readString();
16517 
        else:
16518 
          iprot.skip(ftype)
16519 
      elif fid == 3:
16520 
        if ftype == TType.STRING:
16521 
          self.reason = iprot.readString();
16522 
        else:
16523 
          iprot.skip(ftype)
16524 
      else:
16525 
        iprot.skip(ftype)
16526 
      iprot.readFieldEnd()
16527 
    iprot.readStructEnd()
16528 
 
16529 
  def write(self, oprot):
16530 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16531 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16532 
      return
16533 
    oprot.writeStructBegin('refundTransaction_args')
16534 
    if self.transactionId is not None:
16535 
      oprot.writeFieldBegin('transactionId', TType.I64, 1)
16536 
      oprot.writeI64(self.transactionId)
16537 
      oprot.writeFieldEnd()
16538 
    if self.refundedBy is not None:
16539 
      oprot.writeFieldBegin('refundedBy', TType.STRING, 2)
16540 
      oprot.writeString(self.refundedBy)
16541 
      oprot.writeFieldEnd()
16542 
    if self.reason is not None:
16543 
      oprot.writeFieldBegin('reason', TType.STRING, 3)
16544 
      oprot.writeString(self.reason)
16545 
      oprot.writeFieldEnd()
16546 
    oprot.writeFieldStop()
16547 
    oprot.writeStructEnd()
16548 
 
16549 
  def validate(self):
16550 
    return
16551 
 
16552 
 
16553 
  def __repr__(self):
16554 
    L = ['%s=%r' % (key, value)
16555 
      for key, value in self.__dict__.iteritems()]
16556 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16557 
 
16558 
  def __eq__(self, other):
16559 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16560 
 
16561 
  def __ne__(self, other):
16562 
    return not (self == other)
16563 
 
16564 
class refundTransaction_result:
16565 
  """
16566 
  Attributes:
16567 
   - ex
16568 
  """
16569 
 
16570 
  thrift_spec = (
16571 
    None, # 0
16572 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
16573 
  )
16574 
 
16575 
  def __init__(self, ex=None,):
16576 
    self.ex = ex
16577 
 
16578 
  def read(self, iprot):
16579 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16580 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16581 
      return
16582 
    iprot.readStructBegin()
16583 
    while True:
16584 
      (fname, ftype, fid) = iprot.readFieldBegin()
16585 
      if ftype == TType.STOP:
16586 
        break
16587 
      if fid == 1:
16588 
        if ftype == TType.STRUCT:
16589 
          self.ex = TransactionServiceException()
16590 
          self.ex.read(iprot)
16591 
        else:
16592 
          iprot.skip(ftype)
16593 
      else:
16594 
        iprot.skip(ftype)
16595 
      iprot.readFieldEnd()
16596 
    iprot.readStructEnd()
16597 
 
16598 
  def write(self, oprot):
16599 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16600 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16601 
      return
16602 
    oprot.writeStructBegin('refundTransaction_result')
16603 
    if self.ex is not None:
16604 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
16605 
      self.ex.write(oprot)
16606 
      oprot.writeFieldEnd()
16607 
    oprot.writeFieldStop()
16608 
    oprot.writeStructEnd()
16609 
 
16610 
  def validate(self):
16611 
    return
16612 
 
16613 
 
16614 
  def __repr__(self):
16615 
    L = ['%s=%r' % (key, value)
16616 
      for key, value in self.__dict__.iteritems()]
16617 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16618 
 
16619 
  def __eq__(self, other):
16620 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16621 
 
16622 
  def __ne__(self, other):
16623 
    return not (self == other)
4285 rajveer 16624 
 
4324 mandeep.dh 16625 
class updateShipmentAddress_args:
16626 
  """
16627 
  Attributes:
16628 
   - orderId
16629 
   - addressId
16630 
  """
16631 
 
16632 
  thrift_spec = (
16633 
    None, # 0
16634 
    (1, TType.I64, 'orderId', None, None, ), # 1
16635 
    (2, TType.I64, 'addressId', None, None, ), # 2
16636 
  )
16637 
 
16638 
  def __init__(self, orderId=None, addressId=None,):
16639 
    self.orderId = orderId
16640 
    self.addressId = addressId
16641 
 
16642 
  def read(self, iprot):
16643 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16644 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16645 
      return
16646 
    iprot.readStructBegin()
16647 
    while True:
16648 
      (fname, ftype, fid) = iprot.readFieldBegin()
16649 
      if ftype == TType.STOP:
16650 
        break
16651 
      if fid == 1:
16652 
        if ftype == TType.I64:
16653 
          self.orderId = iprot.readI64();
16654 
        else:
16655 
          iprot.skip(ftype)
16656 
      elif fid == 2:
16657 
        if ftype == TType.I64:
16658 
          self.addressId = iprot.readI64();
16659 
        else:
16660 
          iprot.skip(ftype)
16661 
      else:
16662 
        iprot.skip(ftype)
16663 
      iprot.readFieldEnd()
16664 
    iprot.readStructEnd()
16665 
 
16666 
  def write(self, oprot):
16667 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16668 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16669 
      return
16670 
    oprot.writeStructBegin('updateShipmentAddress_args')
16671 
    if self.orderId is not None:
16672 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
16673 
      oprot.writeI64(self.orderId)
16674 
      oprot.writeFieldEnd()
16675 
    if self.addressId is not None:
16676 
      oprot.writeFieldBegin('addressId', TType.I64, 2)
16677 
      oprot.writeI64(self.addressId)
16678 
      oprot.writeFieldEnd()
16679 
    oprot.writeFieldStop()
16680 
    oprot.writeStructEnd()
16681 
 
16682 
  def validate(self):
16683 
    return
16684 
 
16685 
 
16686 
  def __repr__(self):
16687 
    L = ['%s=%r' % (key, value)
16688 
      for key, value in self.__dict__.iteritems()]
16689 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16690 
 
16691 
  def __eq__(self, other):
16692 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16693 
 
16694 
  def __ne__(self, other):
16695 
    return not (self == other)
16696 
 
16697 
class updateShipmentAddress_result:
16698 
  """
16699 
  Attributes:
16700 
   - ex
16701 
  """
16702 
 
16703 
  thrift_spec = (
16704 
    None, # 0
16705 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
16706 
  )
16707 
 
16708 
  def __init__(self, ex=None,):
16709 
    self.ex = ex
16710 
 
16711 
  def read(self, iprot):
16712 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16713 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16714 
      return
16715 
    iprot.readStructBegin()
16716 
    while True:
16717 
      (fname, ftype, fid) = iprot.readFieldBegin()
16718 
      if ftype == TType.STOP:
16719 
        break
16720 
      if fid == 1:
16721 
        if ftype == TType.STRUCT:
16722 
          self.ex = TransactionServiceException()
16723 
          self.ex.read(iprot)
16724 
        else:
16725 
          iprot.skip(ftype)
16726 
      else:
16727 
        iprot.skip(ftype)
16728 
      iprot.readFieldEnd()
16729 
    iprot.readStructEnd()
16730 
 
16731 
  def write(self, oprot):
16732 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16733 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16734 
      return
16735 
    oprot.writeStructBegin('updateShipmentAddress_result')
16736 
    if self.ex is not None:
16737 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
16738 
      self.ex.write(oprot)
16739 
      oprot.writeFieldEnd()
16740 
    oprot.writeFieldStop()
16741 
    oprot.writeStructEnd()
16742 
 
16743 
  def validate(self):
16744 
    return
16745 
 
16746 
 
16747 
  def __repr__(self):
16748 
    L = ['%s=%r' % (key, value)
16749 
      for key, value in self.__dict__.iteritems()]
16750 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16751 
 
16752 
  def __eq__(self, other):
16753 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16754 
 
16755 
  def __ne__(self, other):
16756 
    return not (self == other)
16757 
 
4285 rajveer 16758 
class acceptOrdersForItemId_args:
16759 
  """
16760 
  Attributes:
16761 
   - itemId
16762 
   - inventory
16763 
  """
16764 
 
16765 
  thrift_spec = (
16766 
    None, # 0
16767 
    (1, TType.I64, 'itemId', None, None, ), # 1
16768 
    (2, TType.I64, 'inventory', None, None, ), # 2
16769 
  )
16770 
 
16771 
  def __init__(self, itemId=None, inventory=None,):
16772 
    self.itemId = itemId
16773 
    self.inventory = inventory
16774 
 
16775 
  def read(self, iprot):
16776 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16777 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16778 
      return
16779 
    iprot.readStructBegin()
16780 
    while True:
16781 
      (fname, ftype, fid) = iprot.readFieldBegin()
16782 
      if ftype == TType.STOP:
16783 
        break
16784 
      if fid == 1:
16785 
        if ftype == TType.I64:
16786 
          self.itemId = iprot.readI64();
16787 
        else:
16788 
          iprot.skip(ftype)
16789 
      elif fid == 2:
16790 
        if ftype == TType.I64:
16791 
          self.inventory = iprot.readI64();
16792 
        else:
16793 
          iprot.skip(ftype)
16794 
      else:
16795 
        iprot.skip(ftype)
16796 
      iprot.readFieldEnd()
16797 
    iprot.readStructEnd()
16798 
 
16799 
  def write(self, oprot):
16800 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16801 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16802 
      return
16803 
    oprot.writeStructBegin('acceptOrdersForItemId_args')
16804 
    if self.itemId is not None:
16805 
      oprot.writeFieldBegin('itemId', TType.I64, 1)
16806 
      oprot.writeI64(self.itemId)
16807 
      oprot.writeFieldEnd()
16808 
    if self.inventory is not None:
16809 
      oprot.writeFieldBegin('inventory', TType.I64, 2)
16810 
      oprot.writeI64(self.inventory)
16811 
      oprot.writeFieldEnd()
16812 
    oprot.writeFieldStop()
16813 
    oprot.writeStructEnd()
16814 
 
16815 
  def validate(self):
16816 
    return
16817 
 
16818 
 
16819 
  def __repr__(self):
16820 
    L = ['%s=%r' % (key, value)
16821 
      for key, value in self.__dict__.iteritems()]
16822 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16823 
 
16824 
  def __eq__(self, other):
16825 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16826 
 
16827 
  def __ne__(self, other):
16828 
    return not (self == other)
16829 
 
16830 
class acceptOrdersForItemId_result:
16831 
  """
16832 
  Attributes:
16833 
   - success
16834 
   - ex
16835 
  """
16836 
 
16837 
  thrift_spec = (
16838 
    (0, TType.BOOL, 'success', None, None, ), # 0
16839 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
16840 
  )
16841 
 
16842 
  def __init__(self, success=None, ex=None,):
16843 
    self.success = success
16844 
    self.ex = ex
16845 
 
16846 
  def read(self, iprot):
16847 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16848 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16849 
      return
16850 
    iprot.readStructBegin()
16851 
    while True:
16852 
      (fname, ftype, fid) = iprot.readFieldBegin()
16853 
      if ftype == TType.STOP:
16854 
        break
16855 
      if fid == 0:
16856 
        if ftype == TType.BOOL:
16857 
          self.success = iprot.readBool();
16858 
        else:
16859 
          iprot.skip(ftype)
16860 
      elif fid == 1:
16861 
        if ftype == TType.STRUCT:
16862 
          self.ex = TransactionServiceException()
16863 
          self.ex.read(iprot)
16864 
        else:
16865 
          iprot.skip(ftype)
16866 
      else:
16867 
        iprot.skip(ftype)
16868 
      iprot.readFieldEnd()
16869 
    iprot.readStructEnd()
16870 
 
16871 
  def write(self, oprot):
16872 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16873 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16874 
      return
16875 
    oprot.writeStructBegin('acceptOrdersForItemId_result')
16876 
    if self.success is not None:
16877 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
16878 
      oprot.writeBool(self.success)
16879 
      oprot.writeFieldEnd()
16880 
    if self.ex is not None:
16881 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
16882 
      self.ex.write(oprot)
16883 
      oprot.writeFieldEnd()
16884 
    oprot.writeFieldStop()
16885 
    oprot.writeStructEnd()
16886 
 
16887 
  def validate(self):
16888 
    return
16889 
 
16890 
 
16891 
  def __repr__(self):
16892 
    L = ['%s=%r' % (key, value)
16893 
      for key, value in self.__dict__.iteritems()]
16894 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16895 
 
16896 
  def __eq__(self, other):
16897 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16898 
 
16899 
  def __ne__(self, other):
16900 
    return not (self == other)
4303 rajveer 16901 
 
16902 
class markOrdersAsPORaised_args:
16903 
  """
16904 
  Attributes:
16905 
   - vendorId
16906 
   - itemId
16907 
   - quantity
16908 
   - estimate
4369 rajveer 16909 
   - isReminder
4303 rajveer 16910 
  """
16911 
 
16912 
  thrift_spec = (
16913 
    None, # 0
16914 
    (1, TType.I64, 'vendorId', None, None, ), # 1
16915 
    (2, TType.I64, 'itemId', None, None, ), # 2
16916 
    (3, TType.I64, 'quantity', None, None, ), # 3
16917 
    (4, TType.I64, 'estimate', None, None, ), # 4
4369 rajveer 16918 
    (5, TType.BOOL, 'isReminder', None, None, ), # 5
4303 rajveer 16919 
  )
16920 
 
4369 rajveer 16921 
  def __init__(self, vendorId=None, itemId=None, quantity=None, estimate=None, isReminder=None,):
4303 rajveer 16922 
    self.vendorId = vendorId
16923 
    self.itemId = itemId
16924 
    self.quantity = quantity
16925 
    self.estimate = estimate
4369 rajveer 16926 
    self.isReminder = isReminder
4303 rajveer 16927 
 
16928 
  def read(self, iprot):
16929 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16930 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16931 
      return
16932 
    iprot.readStructBegin()
16933 
    while True:
16934 
      (fname, ftype, fid) = iprot.readFieldBegin()
16935 
      if ftype == TType.STOP:
16936 
        break
16937 
      if fid == 1:
16938 
        if ftype == TType.I64:
16939 
          self.vendorId = iprot.readI64();
16940 
        else:
16941 
          iprot.skip(ftype)
16942 
      elif fid == 2:
16943 
        if ftype == TType.I64:
16944 
          self.itemId = iprot.readI64();
16945 
        else:
16946 
          iprot.skip(ftype)
16947 
      elif fid == 3:
16948 
        if ftype == TType.I64:
16949 
          self.quantity = iprot.readI64();
16950 
        else:
16951 
          iprot.skip(ftype)
16952 
      elif fid == 4:
16953 
        if ftype == TType.I64:
16954 
          self.estimate = iprot.readI64();
16955 
        else:
16956 
          iprot.skip(ftype)
4369 rajveer 16957 
      elif fid == 5:
16958 
        if ftype == TType.BOOL:
16959 
          self.isReminder = iprot.readBool();
16960 
        else:
16961 
          iprot.skip(ftype)
4303 rajveer 16962 
      else:
16963 
        iprot.skip(ftype)
16964 
      iprot.readFieldEnd()
16965 
    iprot.readStructEnd()
16966 
 
16967 
  def write(self, oprot):
16968 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16969 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16970 
      return
16971 
    oprot.writeStructBegin('markOrdersAsPORaised_args')
16972 
    if self.vendorId is not None:
16973 
      oprot.writeFieldBegin('vendorId', TType.I64, 1)
16974 
      oprot.writeI64(self.vendorId)
16975 
      oprot.writeFieldEnd()
16976 
    if self.itemId is not None:
16977 
      oprot.writeFieldBegin('itemId', TType.I64, 2)
16978 
      oprot.writeI64(self.itemId)
16979 
      oprot.writeFieldEnd()
16980 
    if self.quantity is not None:
16981 
      oprot.writeFieldBegin('quantity', TType.I64, 3)
16982 
      oprot.writeI64(self.quantity)
16983 
      oprot.writeFieldEnd()
16984 
    if self.estimate is not None:
16985 
      oprot.writeFieldBegin('estimate', TType.I64, 4)
16986 
      oprot.writeI64(self.estimate)
16987 
      oprot.writeFieldEnd()
4369 rajveer 16988 
    if self.isReminder is not None:
16989 
      oprot.writeFieldBegin('isReminder', TType.BOOL, 5)
16990 
      oprot.writeBool(self.isReminder)
16991 
      oprot.writeFieldEnd()
4303 rajveer 16992 
    oprot.writeFieldStop()
16993 
    oprot.writeStructEnd()
16994 
 
16995 
  def validate(self):
16996 
    return
16997 
 
16998 
 
16999 
  def __repr__(self):
17000 
    L = ['%s=%r' % (key, value)
17001 
      for key, value in self.__dict__.iteritems()]
17002 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
17003 
 
17004 
  def __eq__(self, other):
17005 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
17006 
 
17007 
  def __ne__(self, other):
17008 
    return not (self == other)
17009 
 
17010 
class markOrdersAsPORaised_result:
17011 
  """
17012 
  Attributes:
17013 
   - ex
17014 
  """
17015 
 
17016 
  thrift_spec = (
17017 
    None, # 0
17018 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
17019 
  )
17020 
 
17021 
  def __init__(self, ex=None,):
17022 
    self.ex = ex
17023 
 
17024 
  def read(self, iprot):
17025 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
17026 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
17027 
      return
17028 
    iprot.readStructBegin()
17029 
    while True:
17030 
      (fname, ftype, fid) = iprot.readFieldBegin()
17031 
      if ftype == TType.STOP:
17032 
        break
17033 
      if fid == 1:
17034 
        if ftype == TType.STRUCT:
17035 
          self.ex = TransactionServiceException()
17036 
          self.ex.read(iprot)
17037 
        else:
17038 
          iprot.skip(ftype)
17039 
      else:
17040 
        iprot.skip(ftype)
17041 
      iprot.readFieldEnd()
17042 
    iprot.readStructEnd()
17043 
 
17044 
  def write(self, oprot):
17045 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
17046 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
17047 
      return
17048 
    oprot.writeStructBegin('markOrdersAsPORaised_result')
17049 
    if self.ex is not None:
17050 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
17051 
      self.ex.write(oprot)
17052 
      oprot.writeFieldEnd()
17053 
    oprot.writeFieldStop()
17054 
    oprot.writeStructEnd()
17055 
 
17056 
  def validate(self):
17057 
    return
17058 
 
17059 
 
17060 
  def __repr__(self):
17061 
    L = ['%s=%r' % (key, value)
17062 
      for key, value in self.__dict__.iteritems()]
17063 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
17064 
 
17065 
  def __eq__(self, other):
17066 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
17067 
 
17068 
  def __ne__(self, other):
17069 
    return not (self == other)
17070 
 
17071 
class markOrdersAsReversalInitiated_args:
17072 
  """
17073 
  Attributes:
17074 
   - vendorId
17075 
   - itemId
17076 
   - quantity
17077 
   - estimate
4369 rajveer 17078 
   - isReminder
4303 rajveer 17079 
  """
17080 
 
17081 
  thrift_spec = (
17082 
    None, # 0
17083 
    (1, TType.I64, 'vendorId', None, None, ), # 1
17084 
    (2, TType.I64, 'itemId', None, None, ), # 2
17085 
    (3, TType.I64, 'quantity', None, None, ), # 3
17086 
    (4, TType.I64, 'estimate', None, None, ), # 4
4369 rajveer 17087 
    (5, TType.BOOL, 'isReminder', None, None, ), # 5
4303 rajveer 17088 
  )
17089 
 
4369 rajveer 17090 
  def __init__(self, vendorId=None, itemId=None, quantity=None, estimate=None, isReminder=None,):
4303 rajveer 17091 
    self.vendorId = vendorId
17092 
    self.itemId = itemId
17093 
    self.quantity = quantity
17094 
    self.estimate = estimate
4369 rajveer 17095 
    self.isReminder = isReminder
4303 rajveer 17096 
 
17097 
  def read(self, iprot):
17098 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
17099 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
17100 
      return
17101 
    iprot.readStructBegin()
17102 
    while True:
17103 
      (fname, ftype, fid) = iprot.readFieldBegin()
17104 
      if ftype == TType.STOP:
17105 
        break
17106 
      if fid == 1:
17107 
        if ftype == TType.I64:
17108 
          self.vendorId = iprot.readI64();
17109 
        else:
17110 
          iprot.skip(ftype)
17111 
      elif fid == 2:
17112 
        if ftype == TType.I64:
17113 
          self.itemId = iprot.readI64();
17114 
        else:
17115 
          iprot.skip(ftype)
17116 
      elif fid == 3:
17117 
        if ftype == TType.I64:
17118 
          self.quantity = iprot.readI64();
17119 
        else:
17120 
          iprot.skip(ftype)
17121 
      elif fid == 4:
17122 
        if ftype == TType.I64:
17123 
          self.estimate = iprot.readI64();
17124 
        else:
17125 
          iprot.skip(ftype)
4369 rajveer 17126 
      elif fid == 5:
17127 
        if ftype == TType.BOOL:
17128 
          self.isReminder = iprot.readBool();
17129 
        else:
17130 
          iprot.skip(ftype)
4303 rajveer 17131 
      else:
17132 
        iprot.skip(ftype)
17133 
      iprot.readFieldEnd()
17134 
    iprot.readStructEnd()
17135 
 
17136 
  def write(self, oprot):
17137 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
17138 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
17139 
      return
17140 
    oprot.writeStructBegin('markOrdersAsReversalInitiated_args')
17141 
    if self.vendorId is not None:
17142 
      oprot.writeFieldBegin('vendorId', TType.I64, 1)
17143 
      oprot.writeI64(self.vendorId)
17144 
      oprot.writeFieldEnd()
17145 
    if self.itemId is not None:
17146 
      oprot.writeFieldBegin('itemId', TType.I64, 2)
17147 
      oprot.writeI64(self.itemId)
17148 
      oprot.writeFieldEnd()
17149 
    if self.quantity is not None:
17150 
      oprot.writeFieldBegin('quantity', TType.I64, 3)
17151 
      oprot.writeI64(self.quantity)
17152 
      oprot.writeFieldEnd()
17153 
    if self.estimate is not None:
17154 
      oprot.writeFieldBegin('estimate', TType.I64, 4)
17155 
      oprot.writeI64(self.estimate)
17156 
      oprot.writeFieldEnd()
4369 rajveer 17157 
    if self.isReminder is not None:
17158 
      oprot.writeFieldBegin('isReminder', TType.BOOL, 5)
17159 
      oprot.writeBool(self.isReminder)
17160 
      oprot.writeFieldEnd()
4303 rajveer 17161 
    oprot.writeFieldStop()
17162 
    oprot.writeStructEnd()
17163 
 
17164 
  def validate(self):
17165 
    return
17166 
 
17167 
 
17168 
  def __repr__(self):
17169 
    L = ['%s=%r' % (key, value)
17170 
      for key, value in self.__dict__.iteritems()]
17171 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
17172 
 
17173 
  def __eq__(self, other):
17174 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
17175 
 
17176 
  def __ne__(self, other):
17177 
    return not (self == other)
17178 
 
17179 
class markOrdersAsReversalInitiated_result:
17180 
  """
17181 
  Attributes:
17182 
   - ex
17183 
  """
17184 
 
17185 
  thrift_spec = (
17186 
    None, # 0
17187 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
17188 
  )
17189 
 
17190 
  def __init__(self, ex=None,):
17191 
    self.ex = ex
17192 
 
17193 
  def read(self, iprot):
17194 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
17195 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
17196 
      return
17197 
    iprot.readStructBegin()
17198 
    while True:
17199 
      (fname, ftype, fid) = iprot.readFieldBegin()
17200 
      if ftype == TType.STOP:
17201 
        break
17202 
      if fid == 1:
17203 
        if ftype == TType.STRUCT:
17204 
          self.ex = TransactionServiceException()
17205 
          self.ex.read(iprot)
17206 
        else:
17207 
          iprot.skip(ftype)
17208 
      else:
17209 
        iprot.skip(ftype)
17210 
      iprot.readFieldEnd()
17211 
    iprot.readStructEnd()
17212 
 
17213 
  def write(self, oprot):
17214 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
17215 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
17216 
      return
17217 
    oprot.writeStructBegin('markOrdersAsReversalInitiated_result')
17218 
    if self.ex is not None:
17219 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
17220 
      self.ex.write(oprot)
17221 
      oprot.writeFieldEnd()
17222 
    oprot.writeFieldStop()
17223 
    oprot.writeStructEnd()
17224 
 
17225 
  def validate(self):
17226 
    return
17227 
 
17228 
 
17229 
  def __repr__(self):
17230 
    L = ['%s=%r' % (key, value)
17231 
      for key, value in self.__dict__.iteritems()]
17232 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
17233 
 
17234 
  def __eq__(self, other):
17235 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
17236 
 
17237 
  def __ne__(self, other):
17238 
    return not (self == other)
17239 
 
17240 
class markOrdersAsNotAvailabke_args:
17241 
  """
17242 
  Attributes:
17243 
   - vendorId
17244 
   - itemId
17245 
   - quantity
17246 
   - estimate
4369 rajveer 17247 
   - isReminder
4303 rajveer 17248 
  """
17249 
 
17250 
  thrift_spec = (
17251 
    None, # 0
17252 
    (1, TType.I64, 'vendorId', None, None, ), # 1
17253 
    (2, TType.I64, 'itemId', None, None, ), # 2
17254 
    (3, TType.I64, 'quantity', None, None, ), # 3
17255 
    (4, TType.I64, 'estimate', None, None, ), # 4
4369 rajveer 17256 
    (5, TType.BOOL, 'isReminder', None, None, ), # 5
4303 rajveer 17257 
  )
17258 
 
4369 rajveer 17259 
  def __init__(self, vendorId=None, itemId=None, quantity=None, estimate=None, isReminder=None,):
4303 rajveer 17260 
    self.vendorId = vendorId
17261 
    self.itemId = itemId
17262 
    self.quantity = quantity
17263 
    self.estimate = estimate
4369 rajveer 17264 
    self.isReminder = isReminder
4303 rajveer 17265 
 
17266 
  def read(self, iprot):
17267 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
17268 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
17269 
      return
17270 
    iprot.readStructBegin()
17271 
    while True:
17272 
      (fname, ftype, fid) = iprot.readFieldBegin()
17273 
      if ftype == TType.STOP:
17274 
        break
17275 
      if fid == 1:
17276 
        if ftype == TType.I64:
17277 
          self.vendorId = iprot.readI64();
17278 
        else:
17279 
          iprot.skip(ftype)
17280 
      elif fid == 2:
17281 
        if ftype == TType.I64:
17282 
          self.itemId = iprot.readI64();
17283 
        else:
17284 
          iprot.skip(ftype)
17285 
      elif fid == 3:
17286 
        if ftype == TType.I64:
17287 
          self.quantity = iprot.readI64();
17288 
        else:
17289 
          iprot.skip(ftype)
17290 
      elif fid == 4:
17291 
        if ftype == TType.I64:
17292 
          self.estimate = iprot.readI64();
17293 
        else:
17294 
          iprot.skip(ftype)
4369 rajveer 17295 
      elif fid == 5:
17296 
        if ftype == TType.BOOL:
17297 
          self.isReminder = iprot.readBool();
17298 
        else:
17299 
          iprot.skip(ftype)
4303 rajveer 17300 
      else:
17301 
        iprot.skip(ftype)
17302 
      iprot.readFieldEnd()
17303 
    iprot.readStructEnd()
17304 
 
17305 
  def write(self, oprot):
17306 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
17307 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
17308 
      return
17309 
    oprot.writeStructBegin('markOrdersAsNotAvailabke_args')
17310 
    if self.vendorId is not None:
17311 
      oprot.writeFieldBegin('vendorId', TType.I64, 1)
17312 
      oprot.writeI64(self.vendorId)
17313 
      oprot.writeFieldEnd()
17314 
    if self.itemId is not None:
17315 
      oprot.writeFieldBegin('itemId', TType.I64, 2)
17316 
      oprot.writeI64(self.itemId)
17317 
      oprot.writeFieldEnd()
17318 
    if self.quantity is not None:
17319 
      oprot.writeFieldBegin('quantity', TType.I64, 3)
17320 
      oprot.writeI64(self.quantity)
17321 
      oprot.writeFieldEnd()
17322 
    if self.estimate is not None:
17323 
      oprot.writeFieldBegin('estimate', TType.I64, 4)
17324 
      oprot.writeI64(self.estimate)
17325 
      oprot.writeFieldEnd()
4369 rajveer 17326 
    if self.isReminder is not None:
17327 
      oprot.writeFieldBegin('isReminder', TType.BOOL, 5)
17328 
      oprot.writeBool(self.isReminder)
17329 
      oprot.writeFieldEnd()
4303 rajveer 17330 
    oprot.writeFieldStop()
17331 
    oprot.writeStructEnd()
17332 
 
17333 
  def validate(self):
17334 
    return
17335 
 
17336 
 
17337 
  def __repr__(self):
17338 
    L = ['%s=%r' % (key, value)
17339 
      for key, value in self.__dict__.iteritems()]
17340 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
17341 
 
17342 
  def __eq__(self, other):
17343 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
17344 
 
17345 
  def __ne__(self, other):
17346 
    return not (self == other)
17347 
 
17348 
class markOrdersAsNotAvailabke_result:
17349 
  """
17350 
  Attributes:
17351 
   - ex
17352 
  """
17353 
 
17354 
  thrift_spec = (
17355 
    None, # 0
17356 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
17357 
  )
17358 
 
17359 
  def __init__(self, ex=None,):
17360 
    self.ex = ex
17361 
 
17362 
  def read(self, iprot):
17363 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
17364 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
17365 
      return
17366 
    iprot.readStructBegin()
17367 
    while True:
17368 
      (fname, ftype, fid) = iprot.readFieldBegin()
17369 
      if ftype == TType.STOP:
17370 
        break
17371 
      if fid == 1:
17372 
        if ftype == TType.STRUCT:
17373 
          self.ex = TransactionServiceException()
17374 
          self.ex.read(iprot)
17375 
        else:
17376 
          iprot.skip(ftype)
17377 
      else:
17378 
        iprot.skip(ftype)
17379 
      iprot.readFieldEnd()
17380 
    iprot.readStructEnd()
17381 
 
17382 
  def write(self, oprot):
17383 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
17384 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
17385 
      return
17386 
    oprot.writeStructBegin('markOrdersAsNotAvailabke_result')
17387 
    if self.ex is not None:
17388 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
17389 
      self.ex.write(oprot)
17390 
      oprot.writeFieldEnd()
17391 
    oprot.writeFieldStop()
17392 
    oprot.writeStructEnd()
17393 
 
17394 
  def validate(self):
17395 
    return
17396 
 
17397 
 
17398 
  def __repr__(self):
17399 
    L = ['%s=%r' % (key, value)
17400 
      for key, value in self.__dict__.iteritems()]
17401 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
17402 
 
17403 
  def __eq__(self, other):
17404 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
17405 
 
17406 
  def __ne__(self, other):
17407 
    return not (self == other)
4369 rajveer 17408 
 
17409 
class markOrdersAsTimeout_args:
17410 
  """
17411 
  Attributes:
17412 
   - vendorId
17413 
  """
17414 
 
17415 
  thrift_spec = (
17416 
    None, # 0
17417 
    (1, TType.I64, 'vendorId', None, None, ), # 1
17418 
  )
17419 
 
17420 
  def __init__(self, vendorId=None,):
17421 
    self.vendorId = vendorId
17422 
 
17423 
  def read(self, iprot):
17424 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
17425 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
17426 
      return
17427 
    iprot.readStructBegin()
17428 
    while True:
17429 
      (fname, ftype, fid) = iprot.readFieldBegin()
17430 
      if ftype == TType.STOP:
17431 
        break
17432 
      if fid == 1:
17433 
        if ftype == TType.I64:
17434 
          self.vendorId = iprot.readI64();
17435 
        else:
17436 
          iprot.skip(ftype)
17437 
      else:
17438 
        iprot.skip(ftype)
17439 
      iprot.readFieldEnd()
17440 
    iprot.readStructEnd()
17441 
 
17442 
  def write(self, oprot):
17443 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
17444 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
17445 
      return
17446 
    oprot.writeStructBegin('markOrdersAsTimeout_args')
17447 
    if self.vendorId is not None:
17448 
      oprot.writeFieldBegin('vendorId', TType.I64, 1)
17449 
      oprot.writeI64(self.vendorId)
17450 
      oprot.writeFieldEnd()
17451 
    oprot.writeFieldStop()
17452 
    oprot.writeStructEnd()
17453 
 
17454 
  def validate(self):
17455 
    return
17456 
 
17457 
 
17458 
  def __repr__(self):
17459 
    L = ['%s=%r' % (key, value)
17460 
      for key, value in self.__dict__.iteritems()]
17461 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
17462 
 
17463 
  def __eq__(self, other):
17464 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
17465 
 
17466 
  def __ne__(self, other):
17467 
    return not (self == other)
17468 
 
17469 
class markOrdersAsTimeout_result:
17470 
  """
17471 
  Attributes:
17472 
   - success
17473 
   - ex
17474 
  """
17475 
 
17476 
  thrift_spec = (
17477 
    (0, TType.MAP, 'success', (TType.I32,None,TType.STRUCT,(TimeoutSummary, TimeoutSummary.thrift_spec)), None, ), # 0
17478 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
17479 
  )
17480 
 
17481 
  def __init__(self, success=None, ex=None,):
17482 
    self.success = success
17483 
    self.ex = ex
17484 
 
17485 
  def read(self, iprot):
17486 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
17487 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
17488 
      return
17489 
    iprot.readStructBegin()
17490 
    while True:
17491 
      (fname, ftype, fid) = iprot.readFieldBegin()
17492 
      if ftype == TType.STOP:
17493 
        break
17494 
      if fid == 0:
17495 
        if ftype == TType.MAP:
17496 
          self.success = {}
4837 varun.gupt 17497 
          (_ktype334, _vtype335, _size333 ) = iprot.readMapBegin()
17498 
          for _i337 in xrange(_size333):
17499 
            _key338 = iprot.readI32();
17500 
            _val339 = TimeoutSummary()
17501 
            _val339.read(iprot)
17502 
            self.success[_key338] = _val339
4369 rajveer 17503 
          iprot.readMapEnd()
17504 
        else:
17505 
          iprot.skip(ftype)
17506 
      elif fid == 1:
17507 
        if ftype == TType.STRUCT:
17508 
          self.ex = TransactionServiceException()
17509 
          self.ex.read(iprot)
17510 
        else:
17511 
          iprot.skip(ftype)
17512 
      else:
17513 
        iprot.skip(ftype)
17514 
      iprot.readFieldEnd()
17515 
    iprot.readStructEnd()
17516 
 
17517 
  def write(self, oprot):
17518 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
17519 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
17520 
      return
17521 
    oprot.writeStructBegin('markOrdersAsTimeout_result')
17522 
    if self.success is not None:
17523 
      oprot.writeFieldBegin('success', TType.MAP, 0)
17524 
      oprot.writeMapBegin(TType.I32, TType.STRUCT, len(self.success))
4837 varun.gupt 17525 
      for kiter340,viter341 in self.success.items():
17526 
        oprot.writeI32(kiter340)
17527 
        viter341.write(oprot)
4369 rajveer 17528 
      oprot.writeMapEnd()
17529 
      oprot.writeFieldEnd()
17530 
    if self.ex is not None:
17531 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
17532 
      self.ex.write(oprot)
17533 
      oprot.writeFieldEnd()
17534 
    oprot.writeFieldStop()
17535 
    oprot.writeStructEnd()
17536 
 
17537 
  def validate(self):
17538 
    return
17539 
 
17540 
 
17541 
  def __repr__(self):
17542 
    L = ['%s=%r' % (key, value)
17543 
      for key, value in self.__dict__.iteritems()]
17544 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
17545 
 
17546 
  def __eq__(self, other):
17547 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
17548 
 
17549 
  def __ne__(self, other):
17550 
    return not (self == other)
4386 anupam.sin 17551 
 
4662 rajveer 17552 
class markOrderAsLostInTransit_args:
17553 
  """
17554 
  Attributes:
17555 
   - orderId
17556 
  """
17557 
 
17558 
  thrift_spec = (
17559 
    None, # 0
17560 
    (1, TType.I64, 'orderId', None, None, ), # 1
17561 
  )
17562 
 
17563 
  def __init__(self, orderId=None,):
17564 
    self.orderId = orderId
17565 
 
17566 
  def read(self, iprot):
17567 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
17568 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
17569 
      return
17570 
    iprot.readStructBegin()
17571 
    while True:
17572 
      (fname, ftype, fid) = iprot.readFieldBegin()
17573 
      if ftype == TType.STOP:
17574 
        break
17575 
      if fid == 1:
17576 
        if ftype == TType.I64:
17577 
          self.orderId = iprot.readI64();
17578 
        else:
17579 
          iprot.skip(ftype)
17580 
      else:
17581 
        iprot.skip(ftype)
17582 
      iprot.readFieldEnd()
17583 
    iprot.readStructEnd()
17584 
 
17585 
  def write(self, oprot):
17586 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
17587 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
17588 
      return
17589 
    oprot.writeStructBegin('markOrderAsLostInTransit_args')
17590 
    if self.orderId is not None:
17591 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
17592 
      oprot.writeI64(self.orderId)
17593 
      oprot.writeFieldEnd()
17594 
    oprot.writeFieldStop()
17595 
    oprot.writeStructEnd()
17596 
 
17597 
  def validate(self):
17598 
    return
17599 
 
17600 
 
17601 
  def __repr__(self):
17602 
    L = ['%s=%r' % (key, value)
17603 
      for key, value in self.__dict__.iteritems()]
17604 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
17605 
 
17606 
  def __eq__(self, other):
17607 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
17608 
 
17609 
  def __ne__(self, other):
17610 
    return not (self == other)
17611 
 
17612 
class markOrderAsLostInTransit_result:
17613 
  """
17614 
  Attributes:
17615 
   - success
17616 
   - ex
17617 
  """
17618 
 
17619 
  thrift_spec = (
17620 
    (0, TType.BOOL, 'success', None, None, ), # 0
17621 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
17622 
  )
17623 
 
17624 
  def __init__(self, success=None, ex=None,):
17625 
    self.success = success
17626 
    self.ex = ex
17627 
 
17628 
  def read(self, iprot):
17629 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
17630 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
17631 
      return
17632 
    iprot.readStructBegin()
17633 
    while True:
17634 
      (fname, ftype, fid) = iprot.readFieldBegin()
17635 
      if ftype == TType.STOP:
17636 
        break
17637 
      if fid == 0:
17638 
        if ftype == TType.BOOL:
17639 
          self.success = iprot.readBool();
17640 
        else:
17641 
          iprot.skip(ftype)
17642 
      elif fid == 1:
17643 
        if ftype == TType.STRUCT:
17644 
          self.ex = TransactionServiceException()
17645 
          self.ex.read(iprot)
17646 
        else:
17647 
          iprot.skip(ftype)
17648 
      else:
17649 
        iprot.skip(ftype)
17650 
      iprot.readFieldEnd()
17651 
    iprot.readStructEnd()
17652 
 
17653 
  def write(self, oprot):
17654 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
17655 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
17656 
      return
17657 
    oprot.writeStructBegin('markOrderAsLostInTransit_result')
17658 
    if self.success is not None:
17659 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
17660 
      oprot.writeBool(self.success)
17661 
      oprot.writeFieldEnd()
17662 
    if self.ex is not None:
17663 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
17664 
      self.ex.write(oprot)
17665 
      oprot.writeFieldEnd()
17666 
    oprot.writeFieldStop()
17667 
    oprot.writeStructEnd()
17668 
 
17669 
  def validate(self):
17670 
    return
17671 
 
17672 
 
17673 
  def __repr__(self):
17674 
    L = ['%s=%r' % (key, value)
17675 
      for key, value in self.__dict__.iteritems()]
17676 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
17677 
 
17678 
  def __eq__(self, other):
17679 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
17680 
 
17681 
  def __ne__(self, other):
17682 
    return not (self == other)
17683 
 
4386 anupam.sin 17684 
class getOrderForAwb_args:
17685 
  """
17686 
  Attributes:
17687 
   - awb
17688 
  """
17689 
 
17690 
  thrift_spec = (
17691 
    None, # 0
17692 
    (1, TType.STRING, 'awb', None, None, ), # 1
17693 
  )
17694 
 
17695 
  def __init__(self, awb=None,):
17696 
    self.awb = awb
17697 
 
17698 
  def read(self, iprot):
17699 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
17700 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
17701 
      return
17702 
    iprot.readStructBegin()
17703 
    while True:
17704 
      (fname, ftype, fid) = iprot.readFieldBegin()
17705 
      if ftype == TType.STOP:
17706 
        break
17707 
      if fid == 1:
17708 
        if ftype == TType.STRING:
17709 
          self.awb = iprot.readString();
17710 
        else:
17711 
          iprot.skip(ftype)
17712 
      else:
17713 
        iprot.skip(ftype)
17714 
      iprot.readFieldEnd()
17715 
    iprot.readStructEnd()
17716 
 
17717 
  def write(self, oprot):
17718 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
17719 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
17720 
      return
17721 
    oprot.writeStructBegin('getOrderForAwb_args')
17722 
    if self.awb is not None:
17723 
      oprot.writeFieldBegin('awb', TType.STRING, 1)
17724 
      oprot.writeString(self.awb)
17725 
      oprot.writeFieldEnd()
17726 
    oprot.writeFieldStop()
17727 
    oprot.writeStructEnd()
17728 
 
17729 
  def validate(self):
17730 
    return
17731 
 
17732 
 
17733 
  def __repr__(self):
17734 
    L = ['%s=%r' % (key, value)
17735 
      for key, value in self.__dict__.iteritems()]
17736 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
17737 
 
17738 
  def __eq__(self, other):
17739 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
17740 
 
17741 
  def __ne__(self, other):
17742 
    return not (self == other)
17743 
 
17744 
class getOrderForAwb_result:
17745 
  """
17746 
  Attributes:
17747 
   - success
17748 
   - ex
17749 
  """
17750 
 
17751 
  thrift_spec = (
17752 
    (0, TType.STRUCT, 'success', (Order, Order.thrift_spec), None, ), # 0
17753 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
17754 
  )
17755 
 
17756 
  def __init__(self, success=None, ex=None,):
17757 
    self.success = success
17758 
    self.ex = ex
17759 
 
17760 
  def read(self, iprot):
17761 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
17762 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
17763 
      return
17764 
    iprot.readStructBegin()
17765 
    while True:
17766 
      (fname, ftype, fid) = iprot.readFieldBegin()
17767 
      if ftype == TType.STOP:
17768 
        break
17769 
      if fid == 0:
17770 
        if ftype == TType.STRUCT:
17771 
          self.success = Order()
17772 
          self.success.read(iprot)
17773 
        else:
17774 
          iprot.skip(ftype)
17775 
      elif fid == 1:
17776 
        if ftype == TType.STRUCT:
17777 
          self.ex = TransactionServiceException()
17778 
          self.ex.read(iprot)
17779 
        else:
17780 
          iprot.skip(ftype)
17781 
      else:
17782 
        iprot.skip(ftype)
17783 
      iprot.readFieldEnd()
17784 
    iprot.readStructEnd()
17785 
 
17786 
  def write(self, oprot):
17787 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
17788 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
17789 
      return
17790 
    oprot.writeStructBegin('getOrderForAwb_result')
17791 
    if self.success is not None:
17792 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
17793 
      self.success.write(oprot)
17794 
      oprot.writeFieldEnd()
17795 
    if self.ex is not None:
17796 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
17797 
      self.ex.write(oprot)
17798 
      oprot.writeFieldEnd()
17799 
    oprot.writeFieldStop()
17800 
    oprot.writeStructEnd()
17801 
 
17802 
  def validate(self):
17803 
    return
17804 
 
17805 
 
17806 
  def __repr__(self):
17807 
    L = ['%s=%r' % (key, value)
17808 
      for key, value in self.__dict__.iteritems()]
17809 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
17810 
 
17811 
  def __eq__(self, other):
17812 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
17813 
 
17814 
  def __ne__(self, other):
17815 
    return not (self == other)
4506 phani.kuma 17816 
 
17817 
class getOrdersForProviderForStatus_args:
17818 
  """
17819 
  Attributes:
17820 
   - logistics_provider_id
17821 
   - order_status
17822 
  """
17823 
 
17824 
  thrift_spec = (
17825 
    None, # 0
17826 
    (1, TType.I64, 'logistics_provider_id', None, None, ), # 1
17827 
    (2, TType.I32, 'order_status', None, None, ), # 2
17828 
  )
17829 
 
17830 
  def __init__(self, logistics_provider_id=None, order_status=None,):
17831 
    self.logistics_provider_id = logistics_provider_id
17832 
    self.order_status = order_status
17833 
 
17834 
  def read(self, iprot):
17835 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
17836 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
17837 
      return
17838 
    iprot.readStructBegin()
17839 
    while True:
17840 
      (fname, ftype, fid) = iprot.readFieldBegin()
17841 
      if ftype == TType.STOP:
17842 
        break
17843 
      if fid == 1:
17844 
        if ftype == TType.I64:
17845 
          self.logistics_provider_id = iprot.readI64();
17846 
        else:
17847 
          iprot.skip(ftype)
17848 
      elif fid == 2:
17849 
        if ftype == TType.I32:
17850 
          self.order_status = iprot.readI32();
17851 
        else:
17852 
          iprot.skip(ftype)
17853 
      else:
17854 
        iprot.skip(ftype)
17855 
      iprot.readFieldEnd()
17856 
    iprot.readStructEnd()
17857 
 
17858 
  def write(self, oprot):
17859 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
17860 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
17861 
      return
17862 
    oprot.writeStructBegin('getOrdersForProviderForStatus_args')
17863 
    if self.logistics_provider_id is not None:
17864 
      oprot.writeFieldBegin('logistics_provider_id', TType.I64, 1)
17865 
      oprot.writeI64(self.logistics_provider_id)
17866 
      oprot.writeFieldEnd()
17867 
    if self.order_status is not None:
17868 
      oprot.writeFieldBegin('order_status', TType.I32, 2)
17869 
      oprot.writeI32(self.order_status)
17870 
      oprot.writeFieldEnd()
17871 
    oprot.writeFieldStop()
17872 
    oprot.writeStructEnd()
17873 
 
17874 
  def validate(self):
17875 
    return
17876 
 
17877 
 
17878 
  def __repr__(self):
17879 
    L = ['%s=%r' % (key, value)
17880 
      for key, value in self.__dict__.iteritems()]
17881 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
17882 
 
17883 
  def __eq__(self, other):
17884 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
17885 
 
17886 
  def __ne__(self, other):
17887 
    return not (self == other)
17888 
 
17889 
class getOrdersForProviderForStatus_result:
17890 
  """
17891 
  Attributes:
17892 
   - success
17893 
   - ex
17894 
  """
17895 
 
17896 
  thrift_spec = (
17897 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
17898 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
17899 
  )
17900 
 
17901 
  def __init__(self, success=None, ex=None,):
17902 
    self.success = success
17903 
    self.ex = ex
17904 
 
17905 
  def read(self, iprot):
17906 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
17907 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
17908 
      return
17909 
    iprot.readStructBegin()
17910 
    while True:
17911 
      (fname, ftype, fid) = iprot.readFieldBegin()
17912 
      if ftype == TType.STOP:
17913 
        break
17914 
      if fid == 0:
17915 
        if ftype == TType.LIST:
17916 
          self.success = []
4837 varun.gupt 17917 
          (_etype345, _size342) = iprot.readListBegin()
17918 
          for _i346 in xrange(_size342):
17919 
            _elem347 = Order()
17920 
            _elem347.read(iprot)
17921 
            self.success.append(_elem347)
4506 phani.kuma 17922 
          iprot.readListEnd()
17923 
        else:
17924 
          iprot.skip(ftype)
17925 
      elif fid == 1:
17926 
        if ftype == TType.STRUCT:
17927 
          self.ex = TransactionServiceException()
17928 
          self.ex.read(iprot)
17929 
        else:
17930 
          iprot.skip(ftype)
17931 
      else:
17932 
        iprot.skip(ftype)
17933 
      iprot.readFieldEnd()
17934 
    iprot.readStructEnd()
17935 
 
17936 
  def write(self, oprot):
17937 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
17938 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
17939 
      return
17940 
    oprot.writeStructBegin('getOrdersForProviderForStatus_result')
17941 
    if self.success is not None:
17942 
      oprot.writeFieldBegin('success', TType.LIST, 0)
17943 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
4837 varun.gupt 17944 
      for iter348 in self.success:
17945 
        iter348.write(oprot)
4506 phani.kuma 17946 
      oprot.writeListEnd()
17947 
      oprot.writeFieldEnd()
17948 
    if self.ex is not None:
17949 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
17950 
      self.ex.write(oprot)
17951 
      oprot.writeFieldEnd()
17952 
    oprot.writeFieldStop()
17953 
    oprot.writeStructEnd()
17954 
 
17955 
  def validate(self):
17956 
    return
17957 
 
17958 
 
17959 
  def __repr__(self):
17960 
    L = ['%s=%r' % (key, value)
17961 
      for key, value in self.__dict__.iteritems()]
17962 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
17963 
 
17964 
  def __eq__(self, other):
17965 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
17966 
 
17967 
  def __ne__(self, other):
17968 
    return not (self == other)
4600 varun.gupt 17969 
 
17970 
class getBilledOrdersForVendor_args:
17971 
  """
17972 
  Attributes:
17973 
   - vendorId
17974 
   - billingDateFrom
17975 
   - billingDateTo
17976 
  """
17977 
 
17978 
  thrift_spec = (
17979 
    None, # 0
17980 
    (1, TType.I64, 'vendorId', None, None, ), # 1
17981 
    (2, TType.I64, 'billingDateFrom', None, None, ), # 2
17982 
    (3, TType.I64, 'billingDateTo', None, None, ), # 3
17983 
  )
17984 
 
17985 
  def __init__(self, vendorId=None, billingDateFrom=None, billingDateTo=None,):
17986 
    self.vendorId = vendorId
17987 
    self.billingDateFrom = billingDateFrom
17988 
    self.billingDateTo = billingDateTo
17989 
 
17990 
  def read(self, iprot):
17991 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
17992 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
17993 
      return
17994 
    iprot.readStructBegin()
17995 
    while True:
17996 
      (fname, ftype, fid) = iprot.readFieldBegin()
17997 
      if ftype == TType.STOP:
17998 
        break
17999 
      if fid == 1:
18000 
        if ftype == TType.I64:
18001 
          self.vendorId = iprot.readI64();
18002 
        else:
18003 
          iprot.skip(ftype)
18004 
      elif fid == 2:
18005 
        if ftype == TType.I64:
18006 
          self.billingDateFrom = iprot.readI64();
18007 
        else:
18008 
          iprot.skip(ftype)
18009 
      elif fid == 3:
18010 
        if ftype == TType.I64:
18011 
          self.billingDateTo = iprot.readI64();
18012 
        else:
18013 
          iprot.skip(ftype)
18014 
      else:
18015 
        iprot.skip(ftype)
18016 
      iprot.readFieldEnd()
18017 
    iprot.readStructEnd()
18018 
 
18019 
  def write(self, oprot):
18020 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
18021 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
18022 
      return
18023 
    oprot.writeStructBegin('getBilledOrdersForVendor_args')
18024 
    if self.vendorId is not None:
18025 
      oprot.writeFieldBegin('vendorId', TType.I64, 1)
18026 
      oprot.writeI64(self.vendorId)
18027 
      oprot.writeFieldEnd()
18028 
    if self.billingDateFrom is not None:
18029 
      oprot.writeFieldBegin('billingDateFrom', TType.I64, 2)
18030 
      oprot.writeI64(self.billingDateFrom)
18031 
      oprot.writeFieldEnd()
18032 
    if self.billingDateTo is not None:
18033 
      oprot.writeFieldBegin('billingDateTo', TType.I64, 3)
18034 
      oprot.writeI64(self.billingDateTo)
18035 
      oprot.writeFieldEnd()
18036 
    oprot.writeFieldStop()
18037 
    oprot.writeStructEnd()
18038 
 
18039 
  def validate(self):
18040 
    return
18041 
 
18042 
 
18043 
  def __repr__(self):
18044 
    L = ['%s=%r' % (key, value)
18045 
      for key, value in self.__dict__.iteritems()]
18046 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
18047 
 
18048 
  def __eq__(self, other):
18049 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
18050 
 
18051 
  def __ne__(self, other):
18052 
    return not (self == other)
18053 
 
18054 
class getBilledOrdersForVendor_result:
18055 
  """
18056 
  Attributes:
18057 
   - success
18058 
   - ex
18059 
  """
18060 
 
18061 
  thrift_spec = (
18062 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
18063 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
18064 
  )
18065 
 
18066 
  def __init__(self, success=None, ex=None,):
18067 
    self.success = success
18068 
    self.ex = ex
18069 
 
18070 
  def read(self, iprot):
18071 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
18072 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
18073 
      return
18074 
    iprot.readStructBegin()
18075 
    while True:
18076 
      (fname, ftype, fid) = iprot.readFieldBegin()
18077 
      if ftype == TType.STOP:
18078 
        break
18079 
      if fid == 0:
18080 
        if ftype == TType.LIST:
18081 
          self.success = []
4837 varun.gupt 18082 
          (_etype352, _size349) = iprot.readListBegin()
18083 
          for _i353 in xrange(_size349):
18084 
            _elem354 = Order()
18085 
            _elem354.read(iprot)
18086 
            self.success.append(_elem354)
4600 varun.gupt 18087 
          iprot.readListEnd()
18088 
        else:
18089 
          iprot.skip(ftype)
18090 
      elif fid == 1:
18091 
        if ftype == TType.STRUCT:
18092 
          self.ex = TransactionServiceException()
18093 
          self.ex.read(iprot)
18094 
        else:
18095 
          iprot.skip(ftype)
18096 
      else:
18097 
        iprot.skip(ftype)
18098 
      iprot.readFieldEnd()
18099 
    iprot.readStructEnd()
18100 
 
18101 
  def write(self, oprot):
18102 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
18103 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
18104 
      return
18105 
    oprot.writeStructBegin('getBilledOrdersForVendor_result')
18106 
    if self.success is not None:
18107 
      oprot.writeFieldBegin('success', TType.LIST, 0)
18108 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
4837 varun.gupt 18109 
      for iter355 in self.success:
18110 
        iter355.write(oprot)
4600 varun.gupt 18111 
      oprot.writeListEnd()
18112 
      oprot.writeFieldEnd()
18113 
    if self.ex is not None:
18114 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
18115 
      self.ex.write(oprot)
18116 
      oprot.writeFieldEnd()
18117 
    oprot.writeFieldStop()
18118 
    oprot.writeStructEnd()
18119 
 
18120 
  def validate(self):
18121 
    return
18122 
 
18123 
 
18124 
  def __repr__(self):
18125 
    L = ['%s=%r' % (key, value)
18126 
      for key, value in self.__dict__.iteritems()]
18127 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
18128 
 
18129 
  def __eq__(self, other):
18130 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
18131 
 
18132 
  def __ne__(self, other):
18133 
    return not (self == other)
18134 
 
4607 rajveer 18135 
class getSlippedSippingDateOrders_args:
18136 
 
18137 
  thrift_spec = (
18138 
  )
18139 
 
18140 
  def read(self, iprot):
18141 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
18142 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
18143 
      return
18144 
    iprot.readStructBegin()
18145 
    while True:
18146 
      (fname, ftype, fid) = iprot.readFieldBegin()
18147 
      if ftype == TType.STOP:
18148 
        break
18149 
      else:
18150 
        iprot.skip(ftype)
18151 
      iprot.readFieldEnd()
18152 
    iprot.readStructEnd()
18153 
 
18154 
  def write(self, oprot):
18155 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
18156 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
18157 
      return
18158 
    oprot.writeStructBegin('getSlippedSippingDateOrders_args')
18159 
    oprot.writeFieldStop()
18160 
    oprot.writeStructEnd()
18161 
 
18162 
  def validate(self):
18163 
    return
18164 
 
18165 
 
18166 
  def __repr__(self):
18167 
    L = ['%s=%r' % (key, value)
18168 
      for key, value in self.__dict__.iteritems()]
18169 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
18170 
 
18171 
  def __eq__(self, other):
18172 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
18173 
 
18174 
  def __ne__(self, other):
18175 
    return not (self == other)
18176 
 
18177 
class getSlippedSippingDateOrders_result:
18178 
  """
18179 
  Attributes:
18180 
   - success
18181 
   - ex
18182 
  """
18183 
 
18184 
  thrift_spec = (
18185 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
18186 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
18187 
  )
18188 
 
18189 
  def __init__(self, success=None, ex=None,):
18190 
    self.success = success
18191 
    self.ex = ex
18192 
 
18193 
  def read(self, iprot):
18194 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
18195 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
18196 
      return
18197 
    iprot.readStructBegin()
18198 
    while True:
18199 
      (fname, ftype, fid) = iprot.readFieldBegin()
18200 
      if ftype == TType.STOP:
18201 
        break
18202 
      if fid == 0:
18203 
        if ftype == TType.LIST:
18204 
          self.success = []
4837 varun.gupt 18205 
          (_etype359, _size356) = iprot.readListBegin()
18206 
          for _i360 in xrange(_size356):
18207 
            _elem361 = Order()
18208 
            _elem361.read(iprot)
18209 
            self.success.append(_elem361)
4607 rajveer 18210 
          iprot.readListEnd()
18211 
        else:
18212 
          iprot.skip(ftype)
18213 
      elif fid == 1:
18214 
        if ftype == TType.STRUCT:
18215 
          self.ex = TransactionServiceException()
18216 
          self.ex.read(iprot)
18217 
        else:
18218 
          iprot.skip(ftype)
18219 
      else:
18220 
        iprot.skip(ftype)
18221 
      iprot.readFieldEnd()
18222 
    iprot.readStructEnd()
18223 
 
18224 
  def write(self, oprot):
18225 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
18226 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
18227 
      return
18228 
    oprot.writeStructBegin('getSlippedSippingDateOrders_result')
18229 
    if self.success is not None:
18230 
      oprot.writeFieldBegin('success', TType.LIST, 0)
18231 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
4837 varun.gupt 18232 
      for iter362 in self.success:
18233 
        iter362.write(oprot)
4607 rajveer 18234 
      oprot.writeListEnd()
18235 
      oprot.writeFieldEnd()
18236 
    if self.ex is not None:
18237 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
18238 
      self.ex.write(oprot)
18239 
      oprot.writeFieldEnd()
18240 
    oprot.writeFieldStop()
18241 
    oprot.writeStructEnd()
18242 
 
18243 
  def validate(self):
18244 
    return
18245 
 
18246 
 
18247 
  def __repr__(self):
18248 
    L = ['%s=%r' % (key, value)
18249 
      for key, value in self.__dict__.iteritems()]
18250 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
18251 
 
18252 
  def __eq__(self, other):
18253 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
18254 
 
18255 
  def __ne__(self, other):
18256 
    return not (self == other)
18257 
 
4709 rajveer 18258 
class getCancelledOrders_args:
18259 
  """
18260 
  Attributes:
18261 
   - cancelDateFrom
18262 
   - cancelDateTo
18263 
  """
18264 
 
18265 
  thrift_spec = (
18266 
    None, # 0
18267 
    (1, TType.I64, 'cancelDateFrom', None, None, ), # 1
18268 
    (2, TType.I64, 'cancelDateTo', None, None, ), # 2
18269 
  )
18270 
 
18271 
  def __init__(self, cancelDateFrom=None, cancelDateTo=None,):
18272 
    self.cancelDateFrom = cancelDateFrom
18273 
    self.cancelDateTo = cancelDateTo
18274 
 
18275 
  def read(self, iprot):
18276 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
18277 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
18278 
      return
18279 
    iprot.readStructBegin()
18280 
    while True:
18281 
      (fname, ftype, fid) = iprot.readFieldBegin()
18282 
      if ftype == TType.STOP:
18283 
        break
18284 
      if fid == 1:
18285 
        if ftype == TType.I64:
18286 
          self.cancelDateFrom = iprot.readI64();
18287 
        else:
18288 
          iprot.skip(ftype)
18289 
      elif fid == 2:
18290 
        if ftype == TType.I64:
18291 
          self.cancelDateTo = iprot.readI64();
18292 
        else:
18293 
          iprot.skip(ftype)
18294 
      else:
18295 
        iprot.skip(ftype)
18296 
      iprot.readFieldEnd()
18297 
    iprot.readStructEnd()
18298 
 
18299 
  def write(self, oprot):
18300 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
18301 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
18302 
      return
18303 
    oprot.writeStructBegin('getCancelledOrders_args')
18304 
    if self.cancelDateFrom is not None:
18305 
      oprot.writeFieldBegin('cancelDateFrom', TType.I64, 1)
18306 
      oprot.writeI64(self.cancelDateFrom)
18307 
      oprot.writeFieldEnd()
18308 
    if self.cancelDateTo is not None:
18309 
      oprot.writeFieldBegin('cancelDateTo', TType.I64, 2)
18310 
      oprot.writeI64(self.cancelDateTo)
18311 
      oprot.writeFieldEnd()
18312 
    oprot.writeFieldStop()
18313 
    oprot.writeStructEnd()
18314 
 
18315 
  def validate(self):
18316 
    return
18317 
 
18318 
 
18319 
  def __repr__(self):
18320 
    L = ['%s=%r' % (key, value)
18321 
      for key, value in self.__dict__.iteritems()]
18322 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
18323 
 
18324 
  def __eq__(self, other):
18325 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
18326 
 
18327 
  def __ne__(self, other):
18328 
    return not (self == other)
18329 
 
18330 
class getCancelledOrders_result:
18331 
  """
18332 
  Attributes:
18333 
   - success
18334 
   - ex
18335 
  """
18336 
 
18337 
  thrift_spec = (
18338 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
18339 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
18340 
  )
18341 
 
18342 
  def __init__(self, success=None, ex=None,):
18343 
    self.success = success
18344 
    self.ex = ex
18345 
 
18346 
  def read(self, iprot):
18347 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
18348 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
18349 
      return
18350 
    iprot.readStructBegin()
18351 
    while True:
18352 
      (fname, ftype, fid) = iprot.readFieldBegin()
18353 
      if ftype == TType.STOP:
18354 
        break
18355 
      if fid == 0:
18356 
        if ftype == TType.LIST:
18357 
          self.success = []
4837 varun.gupt 18358 
          (_etype366, _size363) = iprot.readListBegin()
18359 
          for _i367 in xrange(_size363):
18360 
            _elem368 = Order()
18361 
            _elem368.read(iprot)
18362 
            self.success.append(_elem368)
4709 rajveer 18363 
          iprot.readListEnd()
18364 
        else:
18365 
          iprot.skip(ftype)
18366 
      elif fid == 1:
18367 
        if ftype == TType.STRUCT:
18368 
          self.ex = TransactionServiceException()
18369 
          self.ex.read(iprot)
18370 
        else:
18371 
          iprot.skip(ftype)
18372 
      else:
18373 
        iprot.skip(ftype)
18374 
      iprot.readFieldEnd()
18375 
    iprot.readStructEnd()
18376 
 
18377 
  def write(self, oprot):
18378 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
18379 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
18380 
      return
18381 
    oprot.writeStructBegin('getCancelledOrders_result')
18382 
    if self.success is not None:
18383 
      oprot.writeFieldBegin('success', TType.LIST, 0)
18384 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
4837 varun.gupt 18385 
      for iter369 in self.success:
18386 
        iter369.write(oprot)
4709 rajveer 18387 
      oprot.writeListEnd()
18388 
      oprot.writeFieldEnd()
18389 
    if self.ex is not None:
18390 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
18391 
      self.ex.write(oprot)
18392 
      oprot.writeFieldEnd()
18393 
    oprot.writeFieldStop()
18394 
    oprot.writeStructEnd()
18395 
 
18396 
  def validate(self):
18397 
    return
18398 
 
18399 
 
18400 
  def __repr__(self):
18401 
    L = ['%s=%r' % (key, value)
18402 
      for key, value in self.__dict__.iteritems()]
18403 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
18404 
 
18405 
  def __eq__(self, other):
18406 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
18407 
 
18408 
  def __ne__(self, other):
18409 
    return not (self == other)
18410 
 
4600 varun.gupt 18411 
class saveBluedartSettlements_args:
18412 
  """
18413 
  Attributes:
18414 
   - mapAWBAndAmount
18415 
  """
18416 
 
18417 
  thrift_spec = (
18418 
    None, # 0
18419 
    (1, TType.MAP, 'mapAWBAndAmount', (TType.I64,None,TType.DOUBLE,None), None, ), # 1
18420 
  )
18421 
 
18422 
  def __init__(self, mapAWBAndAmount=None,):
18423 
    self.mapAWBAndAmount = mapAWBAndAmount
18424 
 
18425 
  def read(self, iprot):
18426 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
18427 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
18428 
      return
18429 
    iprot.readStructBegin()
18430 
    while True:
18431 
      (fname, ftype, fid) = iprot.readFieldBegin()
18432 
      if ftype == TType.STOP:
18433 
        break
18434 
      if fid == 1:
18435 
        if ftype == TType.MAP:
18436 
          self.mapAWBAndAmount = {}
4837 varun.gupt 18437 
          (_ktype371, _vtype372, _size370 ) = iprot.readMapBegin()
18438 
          for _i374 in xrange(_size370):
18439 
            _key375 = iprot.readI64();
18440 
            _val376 = iprot.readDouble();
18441 
            self.mapAWBAndAmount[_key375] = _val376
4600 varun.gupt 18442 
          iprot.readMapEnd()
18443 
        else:
18444 
          iprot.skip(ftype)
18445 
      else:
18446 
        iprot.skip(ftype)
18447 
      iprot.readFieldEnd()
18448 
    iprot.readStructEnd()
18449 
 
18450 
  def write(self, oprot):
18451 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
18452 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
18453 
      return
18454 
    oprot.writeStructBegin('saveBluedartSettlements_args')
18455 
    if self.mapAWBAndAmount is not None:
18456 
      oprot.writeFieldBegin('mapAWBAndAmount', TType.MAP, 1)
18457 
      oprot.writeMapBegin(TType.I64, TType.DOUBLE, len(self.mapAWBAndAmount))
4837 varun.gupt 18458 
      for kiter377,viter378 in self.mapAWBAndAmount.items():
18459 
        oprot.writeI64(kiter377)
18460 
        oprot.writeDouble(viter378)
4600 varun.gupt 18461 
      oprot.writeMapEnd()
18462 
      oprot.writeFieldEnd()
18463 
    oprot.writeFieldStop()
18464 
    oprot.writeStructEnd()
18465 
 
18466 
  def validate(self):
18467 
    return
18468 
 
18469 
 
18470 
  def __repr__(self):
18471 
    L = ['%s=%r' % (key, value)
18472 
      for key, value in self.__dict__.iteritems()]
18473 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
18474 
 
18475 
  def __eq__(self, other):
18476 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
18477 
 
18478 
  def __ne__(self, other):
18479 
    return not (self == other)
18480 
 
18481 
class saveBluedartSettlements_result:
18482 
  """
18483 
  Attributes:
18484 
   - ex
18485 
  """
18486 
 
18487 
  thrift_spec = (
18488 
    None, # 0
18489 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
18490 
  )
18491 
 
18492 
  def __init__(self, ex=None,):
18493 
    self.ex = ex
18494 
 
18495 
  def read(self, iprot):
18496 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
18497 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
18498 
      return
18499 
    iprot.readStructBegin()
18500 
    while True:
18501 
      (fname, ftype, fid) = iprot.readFieldBegin()
18502 
      if ftype == TType.STOP:
18503 
        break
18504 
      if fid == 1:
18505 
        if ftype == TType.STRUCT:
18506 
          self.ex = TransactionServiceException()
18507 
          self.ex.read(iprot)
18508 
        else:
18509 
          iprot.skip(ftype)
18510 
      else:
18511 
        iprot.skip(ftype)
18512 
      iprot.readFieldEnd()
18513 
    iprot.readStructEnd()
18514 
 
18515 
  def write(self, oprot):
18516 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
18517 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
18518 
      return
18519 
    oprot.writeStructBegin('saveBluedartSettlements_result')
18520 
    if self.ex is not None:
18521 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
18522 
      self.ex.write(oprot)
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_args:
18543 
  """
18544 
  Attributes:
18545 
   - settlementDate
18546 
   - paymentGatewayId
18547 
   - paymentId
18548 
   - serviceTax
18549 
   - otherCharges
18550 
   - netCollection
18551 
  """
18552 
 
18553 
  thrift_spec = (
18554 
    None, # 0
18555 
    (1, TType.I64, 'settlementDate', None, None, ), # 1
18556 
    (2, TType.I64, 'paymentGatewayId', None, None, ), # 2
18557 
    (3, TType.I64, 'paymentId', None, None, ), # 3
18558 
    (4, TType.DOUBLE, 'serviceTax', None, None, ), # 4
18559 
    (5, TType.DOUBLE, 'otherCharges', None, None, ), # 5
18560 
    (6, TType.DOUBLE, 'netCollection', None, None, ), # 6
18561 
  )
18562 
 
18563 
  def __init__(self, settlementDate=None, paymentGatewayId=None, paymentId=None, serviceTax=None, otherCharges=None, netCollection=None,):
18564 
    self.settlementDate = settlementDate
18565 
    self.paymentGatewayId = paymentGatewayId
18566 
    self.paymentId = paymentId
18567 
    self.serviceTax = serviceTax
18568 
    self.otherCharges = otherCharges
18569 
    self.netCollection = netCollection
18570 
 
18571 
  def read(self, iprot):
18572 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
18573 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
18574 
      return
18575 
    iprot.readStructBegin()
18576 
    while True:
18577 
      (fname, ftype, fid) = iprot.readFieldBegin()
18578 
      if ftype == TType.STOP:
18579 
        break
18580 
      if fid == 1:
18581 
        if ftype == TType.I64:
18582 
          self.settlementDate = iprot.readI64();
18583 
        else:
18584 
          iprot.skip(ftype)
18585 
      elif fid == 2:
18586 
        if ftype == TType.I64:
18587 
          self.paymentGatewayId = iprot.readI64();
18588 
        else:
18589 
          iprot.skip(ftype)
18590 
      elif fid == 3:
18591 
        if ftype == TType.I64:
18592 
          self.paymentId = iprot.readI64();
18593 
        else:
18594 
          iprot.skip(ftype)
18595 
      elif fid == 4:
18596 
        if ftype == TType.DOUBLE:
18597 
          self.serviceTax = iprot.readDouble();
18598 
        else:
18599 
          iprot.skip(ftype)
18600 
      elif fid == 5:
18601 
        if ftype == TType.DOUBLE:
18602 
          self.otherCharges = iprot.readDouble();
18603 
        else:
18604 
          iprot.skip(ftype)
18605 
      elif fid == 6:
18606 
        if ftype == TType.DOUBLE:
18607 
          self.netCollection = iprot.readDouble();
18608 
        else:
18609 
          iprot.skip(ftype)
18610 
      else:
18611 
        iprot.skip(ftype)
18612 
      iprot.readFieldEnd()
18613 
    iprot.readStructEnd()
18614 
 
18615 
  def write(self, oprot):
18616 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
18617 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
18618 
      return
18619 
    oprot.writeStructBegin('savePaymentSettlements_args')
18620 
    if self.settlementDate is not None:
18621 
      oprot.writeFieldBegin('settlementDate', TType.I64, 1)
18622 
      oprot.writeI64(self.settlementDate)
18623 
      oprot.writeFieldEnd()
18624 
    if self.paymentGatewayId is not None:
18625 
      oprot.writeFieldBegin('paymentGatewayId', TType.I64, 2)
18626 
      oprot.writeI64(self.paymentGatewayId)
18627 
      oprot.writeFieldEnd()
18628 
    if self.paymentId is not None:
18629 
      oprot.writeFieldBegin('paymentId', TType.I64, 3)
18630 
      oprot.writeI64(self.paymentId)
18631 
      oprot.writeFieldEnd()
18632 
    if self.serviceTax is not None:
18633 
      oprot.writeFieldBegin('serviceTax', TType.DOUBLE, 4)
18634 
      oprot.writeDouble(self.serviceTax)
18635 
      oprot.writeFieldEnd()
18636 
    if self.otherCharges is not None:
18637 
      oprot.writeFieldBegin('otherCharges', TType.DOUBLE, 5)
18638 
      oprot.writeDouble(self.otherCharges)
18639 
      oprot.writeFieldEnd()
18640 
    if self.netCollection is not None:
18641 
      oprot.writeFieldBegin('netCollection', TType.DOUBLE, 6)
18642 
      oprot.writeDouble(self.netCollection)
18643 
      oprot.writeFieldEnd()
18644 
    oprot.writeFieldStop()
18645 
    oprot.writeStructEnd()
18646 
 
18647 
  def validate(self):
18648 
    return
18649 
 
18650 
 
18651 
  def __repr__(self):
18652 
    L = ['%s=%r' % (key, value)
18653 
      for key, value in self.__dict__.iteritems()]
18654 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
18655 
 
18656 
  def __eq__(self, other):
18657 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
18658 
 
18659 
  def __ne__(self, other):
18660 
    return not (self == other)
18661 
 
18662 
class savePaymentSettlements_result:
18663 
  """
18664 
  Attributes:
18665 
   - ex
18666 
  """
18667 
 
18668 
  thrift_spec = (
18669 
    None, # 0
18670 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
18671 
  )
18672 
 
18673 
  def __init__(self, ex=None,):
18674 
    self.ex = ex
18675 
 
18676 
  def read(self, iprot):
18677 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
18678 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
18679 
      return
18680 
    iprot.readStructBegin()
18681 
    while True:
18682 
      (fname, ftype, fid) = iprot.readFieldBegin()
18683 
      if ftype == TType.STOP:
18684 
        break
18685 
      if fid == 1:
18686 
        if ftype == TType.STRUCT:
18687 
          self.ex = TransactionServiceException()
18688 
          self.ex.read(iprot)
18689 
        else:
18690 
          iprot.skip(ftype)
18691 
      else:
18692 
        iprot.skip(ftype)
18693 
      iprot.readFieldEnd()
18694 
    iprot.readStructEnd()
18695 
 
18696 
  def write(self, oprot):
18697 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
18698 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
18699 
      return
18700 
    oprot.writeStructBegin('savePaymentSettlements_result')
18701 
    if self.ex is not None:
18702 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
18703 
      self.ex.write(oprot)
18704 
      oprot.writeFieldEnd()
18705 
    oprot.writeFieldStop()
18706 
    oprot.writeStructEnd()
18707 
 
18708 
  def validate(self):
18709 
    return
18710 
 
18711 
 
18712 
  def __repr__(self):
18713 
    L = ['%s=%r' % (key, value)
18714 
      for key, value in self.__dict__.iteritems()]
18715 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
18716 
 
18717 
  def __eq__(self, other):
18718 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
18719 
 
18720 
  def __ne__(self, other):
18721 
    return not (self == other)
18722 
 
4875 varun.gupt 18723 
class saveCODPaymentSettlement_args:
18724 
  """
18725 
  Attributes:
18726 
   - orderId
18727 
   - settlementDate
18728 
   - collection
18729 
  """
18730 
 
18731 
  thrift_spec = (
18732 
    None, # 0
18733 
    (1, TType.I64, 'orderId', None, None, ), # 1
18734 
    (2, TType.I64, 'settlementDate', None, None, ), # 2
18735 
    (3, TType.DOUBLE, 'collection', None, None, ), # 3
18736 
  )
18737 
 
18738 
  def __init__(self, orderId=None, settlementDate=None, collection=None,):
18739 
    self.orderId = orderId
18740 
    self.settlementDate = settlementDate
18741 
    self.collection = collection
18742 
 
18743 
  def read(self, iprot):
18744 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
18745 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
18746 
      return
18747 
    iprot.readStructBegin()
18748 
    while True:
18749 
      (fname, ftype, fid) = iprot.readFieldBegin()
18750 
      if ftype == TType.STOP:
18751 
        break
18752 
      if fid == 1:
18753 
        if ftype == TType.I64:
18754 
          self.orderId = iprot.readI64();
18755 
        else:
18756 
          iprot.skip(ftype)
18757 
      elif fid == 2:
18758 
        if ftype == TType.I64:
18759 
          self.settlementDate = iprot.readI64();
18760 
        else:
18761 
          iprot.skip(ftype)
18762 
      elif fid == 3:
18763 
        if ftype == TType.DOUBLE:
18764 
          self.collection = iprot.readDouble();
18765 
        else:
18766 
          iprot.skip(ftype)
18767 
      else:
18768 
        iprot.skip(ftype)
18769 
      iprot.readFieldEnd()
18770 
    iprot.readStructEnd()
18771 
 
18772 
  def write(self, oprot):
18773 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
18774 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
18775 
      return
18776 
    oprot.writeStructBegin('saveCODPaymentSettlement_args')
18777 
    if self.orderId is not None:
18778 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
18779 
      oprot.writeI64(self.orderId)
18780 
      oprot.writeFieldEnd()
18781 
    if self.settlementDate is not None:
18782 
      oprot.writeFieldBegin('settlementDate', TType.I64, 2)
18783 
      oprot.writeI64(self.settlementDate)
18784 
      oprot.writeFieldEnd()
18785 
    if self.collection is not None:
18786 
      oprot.writeFieldBegin('collection', TType.DOUBLE, 3)
18787 
      oprot.writeDouble(self.collection)
18788 
      oprot.writeFieldEnd()
18789 
    oprot.writeFieldStop()
18790 
    oprot.writeStructEnd()
18791 
 
18792 
  def validate(self):
18793 
    return
18794 
 
18795 
 
18796 
  def __repr__(self):
18797 
    L = ['%s=%r' % (key, value)
18798 
      for key, value in self.__dict__.iteritems()]
18799 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
18800 
 
18801 
  def __eq__(self, other):
18802 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
18803 
 
18804 
  def __ne__(self, other):
18805 
    return not (self == other)
18806 
 
18807 
class saveCODPaymentSettlement_result:
18808 
  """
18809 
  Attributes:
18810 
   - ex
18811 
  """
18812 
 
18813 
  thrift_spec = (
18814 
    None, # 0
18815 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
18816 
  )
18817 
 
18818 
  def __init__(self, ex=None,):
18819 
    self.ex = ex
18820 
 
18821 
  def read(self, iprot):
18822 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
18823 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
18824 
      return
18825 
    iprot.readStructBegin()
18826 
    while True:
18827 
      (fname, ftype, fid) = iprot.readFieldBegin()
18828 
      if ftype == TType.STOP:
18829 
        break
18830 
      if fid == 1:
18831 
        if ftype == TType.STRUCT:
18832 
          self.ex = TransactionServiceException()
18833 
          self.ex.read(iprot)
18834 
        else:
18835 
          iprot.skip(ftype)
18836 
      else:
18837 
        iprot.skip(ftype)
18838 
      iprot.readFieldEnd()
18839 
    iprot.readStructEnd()
18840 
 
18841 
  def write(self, oprot):
18842 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
18843 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
18844 
      return
18845 
    oprot.writeStructBegin('saveCODPaymentSettlement_result')
18846 
    if self.ex is not None:
18847 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
18848 
      self.ex.write(oprot)
18849 
      oprot.writeFieldEnd()
18850 
    oprot.writeFieldStop()
18851 
    oprot.writeStructEnd()
18852 
 
18853 
  def validate(self):
18854 
    return
18855 
 
18856 
 
18857 
  def __repr__(self):
18858 
    L = ['%s=%r' % (key, value)
18859 
      for key, value in self.__dict__.iteritems()]
18860 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
18861 
 
18862 
  def __eq__(self, other):
18863 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
18864 
 
18865 
  def __ne__(self, other):
18866 
    return not (self == other)
18867 
 
4600 varun.gupt 18868 
class saveEBSSettlementSummary_args:
18869 
  """
18870 
  Attributes:
18871 
   - settlementId
18872 
   - settlementDate
18873 
   - transactionDateFrom
18874 
   - transactionDateTo
18875 
   - amount
18876 
  """
18877 
 
18878 
  thrift_spec = (
18879 
    None, # 0
18880 
    (1, TType.I64, 'settlementId', None, None, ), # 1
18881 
    (2, TType.I64, 'settlementDate', None, None, ), # 2
18882 
    (3, TType.I64, 'transactionDateFrom', None, None, ), # 3
18883 
    (4, TType.I64, 'transactionDateTo', None, None, ), # 4
18884 
    (5, TType.DOUBLE, 'amount', None, None, ), # 5
18885 
  )
18886 
 
18887 
  def __init__(self, settlementId=None, settlementDate=None, transactionDateFrom=None, transactionDateTo=None, amount=None,):
18888 
    self.settlementId = settlementId
18889 
    self.settlementDate = settlementDate
18890 
    self.transactionDateFrom = transactionDateFrom
18891 
    self.transactionDateTo = transactionDateTo
18892 
    self.amount = amount
18893 
 
18894 
  def read(self, iprot):
18895 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
18896 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
18897 
      return
18898 
    iprot.readStructBegin()
18899 
    while True:
18900 
      (fname, ftype, fid) = iprot.readFieldBegin()
18901 
      if ftype == TType.STOP:
18902 
        break
18903 
      if fid == 1:
18904 
        if ftype == TType.I64:
18905 
          self.settlementId = iprot.readI64();
18906 
        else:
18907 
          iprot.skip(ftype)
18908 
      elif fid == 2:
18909 
        if ftype == TType.I64:
18910 
          self.settlementDate = iprot.readI64();
18911 
        else:
18912 
          iprot.skip(ftype)
18913 
      elif fid == 3:
18914 
        if ftype == TType.I64:
18915 
          self.transactionDateFrom = iprot.readI64();
18916 
        else:
18917 
          iprot.skip(ftype)
18918 
      elif fid == 4:
18919 
        if ftype == TType.I64:
18920 
          self.transactionDateTo = iprot.readI64();
18921 
        else:
18922 
          iprot.skip(ftype)
18923 
      elif fid == 5:
18924 
        if ftype == TType.DOUBLE:
18925 
          self.amount = iprot.readDouble();
18926 
        else:
18927 
          iprot.skip(ftype)
18928 
      else:
18929 
        iprot.skip(ftype)
18930 
      iprot.readFieldEnd()
18931 
    iprot.readStructEnd()
18932 
 
18933 
  def write(self, oprot):
18934 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
18935 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
18936 
      return
18937 
    oprot.writeStructBegin('saveEBSSettlementSummary_args')
18938 
    if self.settlementId is not None:
18939 
      oprot.writeFieldBegin('settlementId', TType.I64, 1)
18940 
      oprot.writeI64(self.settlementId)
18941 
      oprot.writeFieldEnd()
18942 
    if self.settlementDate is not None:
18943 
      oprot.writeFieldBegin('settlementDate', TType.I64, 2)
18944 
      oprot.writeI64(self.settlementDate)
18945 
      oprot.writeFieldEnd()
18946 
    if self.transactionDateFrom is not None:
18947 
      oprot.writeFieldBegin('transactionDateFrom', TType.I64, 3)
18948 
      oprot.writeI64(self.transactionDateFrom)
18949 
      oprot.writeFieldEnd()
18950 
    if self.transactionDateTo is not None:
18951 
      oprot.writeFieldBegin('transactionDateTo', TType.I64, 4)
18952 
      oprot.writeI64(self.transactionDateTo)
18953 
      oprot.writeFieldEnd()
18954 
    if self.amount is not None:
18955 
      oprot.writeFieldBegin('amount', TType.DOUBLE, 5)
18956 
      oprot.writeDouble(self.amount)
18957 
      oprot.writeFieldEnd()
18958 
    oprot.writeFieldStop()
18959 
    oprot.writeStructEnd()
18960 
 
18961 
  def validate(self):
18962 
    return
18963 
 
18964 
 
18965 
  def __repr__(self):
18966 
    L = ['%s=%r' % (key, value)
18967 
      for key, value in self.__dict__.iteritems()]
18968 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
18969 
 
18970 
  def __eq__(self, other):
18971 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
18972 
 
18973 
  def __ne__(self, other):
18974 
    return not (self == other)
18975 
 
18976 
class saveEBSSettlementSummary_result:
18977 
  """
18978 
  Attributes:
18979 
   - ex
18980 
  """
18981 
 
18982 
  thrift_spec = (
18983 
    None, # 0
18984 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
18985 
  )
18986 
 
18987 
  def __init__(self, ex=None,):
18988 
    self.ex = ex
18989 
 
18990 
  def read(self, iprot):
18991 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
18992 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
18993 
      return
18994 
    iprot.readStructBegin()
18995 
    while True:
18996 
      (fname, ftype, fid) = iprot.readFieldBegin()
18997 
      if ftype == TType.STOP:
18998 
        break
18999 
      if fid == 1:
19000 
        if ftype == TType.STRUCT:
19001 
          self.ex = TransactionServiceException()
19002 
          self.ex.read(iprot)
19003 
        else:
19004 
          iprot.skip(ftype)
19005 
      else:
19006 
        iprot.skip(ftype)
19007 
      iprot.readFieldEnd()
19008 
    iprot.readStructEnd()
19009 
 
19010 
  def write(self, oprot):
19011 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
19012 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
19013 
      return
19014 
    oprot.writeStructBegin('saveEBSSettlementSummary_result')
19015 
    if self.ex is not None:
19016 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
19017 
      self.ex.write(oprot)
19018 
      oprot.writeFieldEnd()
19019 
    oprot.writeFieldStop()
19020 
    oprot.writeStructEnd()
19021 
 
19022 
  def validate(self):
19023 
    return
19024 
 
19025 
 
19026 
  def __repr__(self):
19027 
    L = ['%s=%r' % (key, value)
19028 
      for key, value in self.__dict__.iteritems()]
19029 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
19030 
 
19031 
  def __eq__(self, other):
19032 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
19033 
 
19034 
  def __ne__(self, other):
19035 
    return not (self == other)
19036 
 
19037 
class getSettlementForPaymentId_args:
19038 
  """
19039 
  Attributes:
19040 
   - paymentId
19041 
  """
19042 
 
19043 
  thrift_spec = (
19044 
    None, # 0
19045 
    (1, TType.I64, 'paymentId', None, None, ), # 1
19046 
  )
19047 
 
19048 
  def __init__(self, paymentId=None,):
19049 
    self.paymentId = paymentId
19050 
 
19051 
  def read(self, iprot):
19052 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
19053 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
19054 
      return
19055 
    iprot.readStructBegin()
19056 
    while True:
19057 
      (fname, ftype, fid) = iprot.readFieldBegin()
19058 
      if ftype == TType.STOP:
19059 
        break
19060 
      if fid == 1:
19061 
        if ftype == TType.I64:
19062 
          self.paymentId = iprot.readI64();
19063 
        else:
19064 
          iprot.skip(ftype)
19065 
      else:
19066 
        iprot.skip(ftype)
19067 
      iprot.readFieldEnd()
19068 
    iprot.readStructEnd()
19069 
 
19070 
  def write(self, oprot):
19071 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
19072 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
19073 
      return
19074 
    oprot.writeStructBegin('getSettlementForPaymentId_args')
19075 
    if self.paymentId is not None:
19076 
      oprot.writeFieldBegin('paymentId', TType.I64, 1)
19077 
      oprot.writeI64(self.paymentId)
19078 
      oprot.writeFieldEnd()
19079 
    oprot.writeFieldStop()
19080 
    oprot.writeStructEnd()
19081 
 
19082 
  def validate(self):
19083 
    return
19084 
 
19085 
 
19086 
  def __repr__(self):
19087 
    L = ['%s=%r' % (key, value)
19088 
      for key, value in self.__dict__.iteritems()]
19089 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
19090 
 
19091 
  def __eq__(self, other):
19092 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
19093 
 
19094 
  def __ne__(self, other):
19095 
    return not (self == other)
19096 
 
19097 
class getSettlementForPaymentId_result:
19098 
  """
19099 
  Attributes:
19100 
   - success
19101 
   - ex
19102 
  """
19103 
 
19104 
  thrift_spec = (
19105 
    (0, TType.STRUCT, 'success', (PaymentSettlement, PaymentSettlement.thrift_spec), None, ), # 0
19106 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
19107 
  )
19108 
 
19109 
  def __init__(self, success=None, ex=None,):
19110 
    self.success = success
19111 
    self.ex = ex
19112 
 
19113 
  def read(self, iprot):
19114 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
19115 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
19116 
      return
19117 
    iprot.readStructBegin()
19118 
    while True:
19119 
      (fname, ftype, fid) = iprot.readFieldBegin()
19120 
      if ftype == TType.STOP:
19121 
        break
19122 
      if fid == 0:
19123 
        if ftype == TType.STRUCT:
19124 
          self.success = PaymentSettlement()
19125 
          self.success.read(iprot)
19126 
        else:
19127 
          iprot.skip(ftype)
19128 
      elif fid == 1:
19129 
        if ftype == TType.STRUCT:
19130 
          self.ex = TransactionServiceException()
19131 
          self.ex.read(iprot)
19132 
        else:
19133 
          iprot.skip(ftype)
19134 
      else:
19135 
        iprot.skip(ftype)
19136 
      iprot.readFieldEnd()
19137 
    iprot.readStructEnd()
19138 
 
19139 
  def write(self, oprot):
19140 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
19141 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
19142 
      return
19143 
    oprot.writeStructBegin('getSettlementForPaymentId_result')
19144 
    if self.success is not None:
19145 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
19146 
      self.success.write(oprot)
19147 
      oprot.writeFieldEnd()
19148 
    if self.ex is not None:
19149 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
19150 
      self.ex.write(oprot)
19151 
      oprot.writeFieldEnd()
19152 
    oprot.writeFieldStop()
19153 
    oprot.writeStructEnd()
19154 
 
19155 
  def validate(self):
19156 
    return
19157 
 
19158 
 
19159 
  def __repr__(self):
19160 
    L = ['%s=%r' % (key, value)
19161 
      for key, value in self.__dict__.iteritems()]
19162 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
19163 
 
19164 
  def __eq__(self, other):
19165 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
19166 
 
19167 
  def __ne__(self, other):
19168 
    return not (self == other)
19169 
 
19170 
class getEBSSettlementSummaries_args:
19171 
 
19172 
  thrift_spec = (
19173 
  )
19174 
 
19175 
  def read(self, iprot):
19176 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
19177 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
19178 
      return
19179 
    iprot.readStructBegin()
19180 
    while True:
19181 
      (fname, ftype, fid) = iprot.readFieldBegin()
19182 
      if ftype == TType.STOP:
19183 
        break
19184 
      else:
19185 
        iprot.skip(ftype)
19186 
      iprot.readFieldEnd()
19187 
    iprot.readStructEnd()
19188 
 
19189 
  def write(self, oprot):
19190 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
19191 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
19192 
      return
19193 
    oprot.writeStructBegin('getEBSSettlementSummaries_args')
19194 
    oprot.writeFieldStop()
19195 
    oprot.writeStructEnd()
19196 
 
19197 
  def validate(self):
19198 
    return
19199 
 
19200 
 
19201 
  def __repr__(self):
19202 
    L = ['%s=%r' % (key, value)
19203 
      for key, value in self.__dict__.iteritems()]
19204 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
19205 
 
19206 
  def __eq__(self, other):
19207 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
19208 
 
19209 
  def __ne__(self, other):
19210 
    return not (self == other)
19211 
 
19212 
class getEBSSettlementSummaries_result:
19213 
  """
19214 
  Attributes:
19215 
   - success
19216 
   - ex
19217 
  """
19218 
 
19219 
  thrift_spec = (
19220 
    (0, TType.MAP, 'success', (TType.I64,None,TType.STRING,None), None, ), # 0
19221 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
19222 
  )
19223 
 
19224 
  def __init__(self, success=None, ex=None,):
19225 
    self.success = success
19226 
    self.ex = ex
19227 
 
19228 
  def read(self, iprot):
19229 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
19230 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
19231 
      return
19232 
    iprot.readStructBegin()
19233 
    while True:
19234 
      (fname, ftype, fid) = iprot.readFieldBegin()
19235 
      if ftype == TType.STOP:
19236 
        break
19237 
      if fid == 0:
19238 
        if ftype == TType.MAP:
19239 
          self.success = {}
4837 varun.gupt 19240 
          (_ktype380, _vtype381, _size379 ) = iprot.readMapBegin()
19241 
          for _i383 in xrange(_size379):
19242 
            _key384 = iprot.readI64();
19243 
            _val385 = iprot.readString();
19244 
            self.success[_key384] = _val385
4600 varun.gupt 19245 
          iprot.readMapEnd()
19246 
        else:
19247 
          iprot.skip(ftype)
19248 
      elif fid == 1:
19249 
        if ftype == TType.STRUCT:
19250 
          self.ex = TransactionServiceException()
19251 
          self.ex.read(iprot)
19252 
        else:
19253 
          iprot.skip(ftype)
19254 
      else:
19255 
        iprot.skip(ftype)
19256 
      iprot.readFieldEnd()
19257 
    iprot.readStructEnd()
19258 
 
19259 
  def write(self, oprot):
19260 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
19261 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
19262 
      return
19263 
    oprot.writeStructBegin('getEBSSettlementSummaries_result')
19264 
    if self.success is not None:
19265 
      oprot.writeFieldBegin('success', TType.MAP, 0)
19266 
      oprot.writeMapBegin(TType.I64, TType.STRING, len(self.success))
4837 varun.gupt 19267 
      for kiter386,viter387 in self.success.items():
19268 
        oprot.writeI64(kiter386)
19269 
        oprot.writeString(viter387)
4600 varun.gupt 19270 
      oprot.writeMapEnd()
19271 
      oprot.writeFieldEnd()
19272 
    if self.ex is not None:
19273 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
19274 
      self.ex.write(oprot)
19275 
      oprot.writeFieldEnd()
19276 
    oprot.writeFieldStop()
19277 
    oprot.writeStructEnd()
19278 
 
19279 
  def validate(self):
19280 
    return
19281 
 
19282 
 
19283 
  def __repr__(self):
19284 
    L = ['%s=%r' % (key, value)
19285 
      for key, value in self.__dict__.iteritems()]
19286 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
19287 
 
19288 
  def __eq__(self, other):
19289 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
19290 
 
19291 
  def __ne__(self, other):
19292 
    return not (self == other)
19293 
 
19294 
class markEBSSettlementUploaded_args:
19295 
  """
19296 
  Attributes:
19297 
   - settlementId
19298 
  """
19299 
 
19300 
  thrift_spec = (
19301 
    None, # 0
19302 
    (1, TType.I64, 'settlementId', None, None, ), # 1
19303 
  )
19304 
 
19305 
  def __init__(self, settlementId=None,):
19306 
    self.settlementId = settlementId
19307 
 
19308 
  def read(self, iprot):
19309 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
19310 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
19311 
      return
19312 
    iprot.readStructBegin()
19313 
    while True:
19314 
      (fname, ftype, fid) = iprot.readFieldBegin()
19315 
      if ftype == TType.STOP:
19316 
        break
19317 
      if fid == 1:
19318 
        if ftype == TType.I64:
19319 
          self.settlementId = iprot.readI64();
19320 
        else:
19321 
          iprot.skip(ftype)
19322 
      else:
19323 
        iprot.skip(ftype)
19324 
      iprot.readFieldEnd()
19325 
    iprot.readStructEnd()
19326 
 
19327 
  def write(self, oprot):
19328 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
19329 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
19330 
      return
19331 
    oprot.writeStructBegin('markEBSSettlementUploaded_args')
19332 
    if self.settlementId is not None:
19333 
      oprot.writeFieldBegin('settlementId', TType.I64, 1)
19334 
      oprot.writeI64(self.settlementId)
19335 
      oprot.writeFieldEnd()
19336 
    oprot.writeFieldStop()
19337 
    oprot.writeStructEnd()
19338 
 
19339 
  def validate(self):
19340 
    return
19341 
 
19342 
 
19343 
  def __repr__(self):
19344 
    L = ['%s=%r' % (key, value)
19345 
      for key, value in self.__dict__.iteritems()]
19346 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
19347 
 
19348 
  def __eq__(self, other):
19349 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
19350 
 
19351 
  def __ne__(self, other):
19352 
    return not (self == other)
19353 
 
19354 
class markEBSSettlementUploaded_result:
19355 
  """
19356 
  Attributes:
19357 
   - ex
19358 
  """
19359 
 
19360 
  thrift_spec = (
19361 
    None, # 0
19362 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
19363 
  )
19364 
 
19365 
  def __init__(self, ex=None,):
19366 
    self.ex = ex
19367 
 
19368 
  def read(self, iprot):
19369 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
19370 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
19371 
      return
19372 
    iprot.readStructBegin()
19373 
    while True:
19374 
      (fname, ftype, fid) = iprot.readFieldBegin()
19375 
      if ftype == TType.STOP:
19376 
        break
19377 
      if fid == 1:
19378 
        if ftype == TType.STRUCT:
19379 
          self.ex = TransactionServiceException()
19380 
          self.ex.read(iprot)
19381 
        else:
19382 
          iprot.skip(ftype)
19383 
      else:
19384 
        iprot.skip(ftype)
19385 
      iprot.readFieldEnd()
19386 
    iprot.readStructEnd()
19387 
 
19388 
  def write(self, oprot):
19389 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
19390 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
19391 
      return
19392 
    oprot.writeStructBegin('markEBSSettlementUploaded_result')
19393 
    if self.ex is not None:
19394 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
19395 
      self.ex.write(oprot)
19396 
      oprot.writeFieldEnd()
19397 
    oprot.writeFieldStop()
19398 
    oprot.writeStructEnd()
19399 
 
19400 
  def validate(self):
19401 
    return
19402 
 
19403 
 
19404 
  def __repr__(self):
19405 
    L = ['%s=%r' % (key, value)
19406 
      for key, value in self.__dict__.iteritems()]
19407 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
19408 
 
19409 
  def __eq__(self, other):
19410 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
19411 
 
19412 
  def __ne__(self, other):
19413 
    return not (self == other)
19414 
 
19415 
class getEBSSettlementDate_args:
19416 
  """
19417 
  Attributes:
19418 
   - settlementId
19419 
  """
19420 
 
19421 
  thrift_spec = (
19422 
    None, # 0
19423 
    (1, TType.I64, 'settlementId', None, None, ), # 1
19424 
  )
19425 
 
19426 
  def __init__(self, settlementId=None,):
19427 
    self.settlementId = settlementId
19428 
 
19429 
  def read(self, iprot):
19430 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
19431 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
19432 
      return
19433 
    iprot.readStructBegin()
19434 
    while True:
19435 
      (fname, ftype, fid) = iprot.readFieldBegin()
19436 
      if ftype == TType.STOP:
19437 
        break
19438 
      if fid == 1:
19439 
        if ftype == TType.I64:
19440 
          self.settlementId = iprot.readI64();
19441 
        else:
19442 
          iprot.skip(ftype)
19443 
      else:
19444 
        iprot.skip(ftype)
19445 
      iprot.readFieldEnd()
19446 
    iprot.readStructEnd()
19447 
 
19448 
  def write(self, oprot):
19449 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
19450 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
19451 
      return
19452 
    oprot.writeStructBegin('getEBSSettlementDate_args')
19453 
    if self.settlementId is not None:
19454 
      oprot.writeFieldBegin('settlementId', TType.I64, 1)
19455 
      oprot.writeI64(self.settlementId)
19456 
      oprot.writeFieldEnd()
19457 
    oprot.writeFieldStop()
19458 
    oprot.writeStructEnd()
19459 
 
19460 
  def validate(self):
19461 
    return
19462 
 
19463 
 
19464 
  def __repr__(self):
19465 
    L = ['%s=%r' % (key, value)
19466 
      for key, value in self.__dict__.iteritems()]
19467 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
19468 
 
19469 
  def __eq__(self, other):
19470 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
19471 
 
19472 
  def __ne__(self, other):
19473 
    return not (self == other)
19474 
 
19475 
class getEBSSettlementDate_result:
19476 
  """
19477 
  Attributes:
19478 
   - success
19479 
   - ex
19480 
  """
19481 
 
19482 
  thrift_spec = (
19483 
    (0, TType.I64, 'success', None, None, ), # 0
19484 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
19485 
  )
19486 
 
19487 
  def __init__(self, success=None, ex=None,):
19488 
    self.success = success
19489 
    self.ex = ex
19490 
 
19491 
  def read(self, iprot):
19492 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
19493 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
19494 
      return
19495 
    iprot.readStructBegin()
19496 
    while True:
19497 
      (fname, ftype, fid) = iprot.readFieldBegin()
19498 
      if ftype == TType.STOP:
19499 
        break
19500 
      if fid == 0:
19501 
        if ftype == TType.I64:
19502 
          self.success = iprot.readI64();
19503 
        else:
19504 
          iprot.skip(ftype)
19505 
      elif fid == 1:
19506 
        if ftype == TType.STRUCT:
19507 
          self.ex = TransactionServiceException()
19508 
          self.ex.read(iprot)
19509 
        else:
19510 
          iprot.skip(ftype)
19511 
      else:
19512 
        iprot.skip(ftype)
19513 
      iprot.readFieldEnd()
19514 
    iprot.readStructEnd()
19515 
 
19516 
  def write(self, oprot):
19517 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
19518 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
19519 
      return
19520 
    oprot.writeStructBegin('getEBSSettlementDate_result')
19521 
    if self.success is not None:
19522 
      oprot.writeFieldBegin('success', TType.I64, 0)
19523 
      oprot.writeI64(self.success)
19524 
      oprot.writeFieldEnd()
19525 
    if self.ex is not None:
19526 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
19527 
      self.ex.write(oprot)
19528 
      oprot.writeFieldEnd()
19529 
    oprot.writeFieldStop()
19530 
    oprot.writeStructEnd()
19531 
 
19532 
  def validate(self):
19533 
    return
19534 
 
19535 
 
19536 
  def __repr__(self):
19537 
    L = ['%s=%r' % (key, value)
19538 
      for key, value in self.__dict__.iteritems()]
19539 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
19540 
 
19541 
  def __eq__(self, other):
19542 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
19543 
 
19544 
  def __ne__(self, other):
19545 
    return not (self == other)
4715 varun.gupt 19546 
 
19547 
class getSettlementsByDate_args:
19548 
  """
19549 
  Attributes:
19550 
   - settlementDateFrom
19551 
   - settlementDateTo
19552 
   - isRefund
19553 
  """
19554 
 
19555 
  thrift_spec = (
19556 
    None, # 0
19557 
    (1, TType.I64, 'settlementDateFrom', None, None, ), # 1
19558 
    (2, TType.I64, 'settlementDateTo', None, None, ), # 2
19559 
    (3, TType.BOOL, 'isRefund', None, None, ), # 3
19560 
  )
19561 
 
19562 
  def __init__(self, settlementDateFrom=None, settlementDateTo=None, isRefund=None,):
19563 
    self.settlementDateFrom = settlementDateFrom
19564 
    self.settlementDateTo = settlementDateTo
19565 
    self.isRefund = isRefund
19566 
 
19567 
  def read(self, iprot):
19568 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
19569 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
19570 
      return
19571 
    iprot.readStructBegin()
19572 
    while True:
19573 
      (fname, ftype, fid) = iprot.readFieldBegin()
19574 
      if ftype == TType.STOP:
19575 
        break
19576 
      if fid == 1:
19577 
        if ftype == TType.I64:
19578 
          self.settlementDateFrom = iprot.readI64();
19579 
        else:
19580 
          iprot.skip(ftype)
19581 
      elif fid == 2:
19582 
        if ftype == TType.I64:
19583 
          self.settlementDateTo = iprot.readI64();
19584 
        else:
19585 
          iprot.skip(ftype)
19586 
      elif fid == 3:
19587 
        if ftype == TType.BOOL:
19588 
          self.isRefund = iprot.readBool();
19589 
        else:
19590 
          iprot.skip(ftype)
19591 
      else:
19592 
        iprot.skip(ftype)
19593 
      iprot.readFieldEnd()
19594 
    iprot.readStructEnd()
19595 
 
19596 
  def write(self, oprot):
19597 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
19598 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
19599 
      return
19600 
    oprot.writeStructBegin('getSettlementsByDate_args')
19601 
    if self.settlementDateFrom is not None:
19602 
      oprot.writeFieldBegin('settlementDateFrom', TType.I64, 1)
19603 
      oprot.writeI64(self.settlementDateFrom)
19604 
      oprot.writeFieldEnd()
19605 
    if self.settlementDateTo is not None:
19606 
      oprot.writeFieldBegin('settlementDateTo', TType.I64, 2)
19607 
      oprot.writeI64(self.settlementDateTo)
19608 
      oprot.writeFieldEnd()
19609 
    if self.isRefund is not None:
19610 
      oprot.writeFieldBegin('isRefund', TType.BOOL, 3)
19611 
      oprot.writeBool(self.isRefund)
19612 
      oprot.writeFieldEnd()
19613 
    oprot.writeFieldStop()
19614 
    oprot.writeStructEnd()
19615 
 
19616 
  def validate(self):
19617 
    return
19618 
 
19619 
 
19620 
  def __repr__(self):
19621 
    L = ['%s=%r' % (key, value)
19622 
      for key, value in self.__dict__.iteritems()]
19623 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
19624 
 
19625 
  def __eq__(self, other):
19626 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
19627 
 
19628 
  def __ne__(self, other):
19629 
    return not (self == other)
19630 
 
19631 
class getSettlementsByDate_result:
19632 
  """
19633 
  Attributes:
19634 
   - success
19635 
   - ex
19636 
  """
19637 
 
19638 
  thrift_spec = (
19639 
    (0, TType.LIST, 'success', (TType.STRUCT,(PaymentSettlement, PaymentSettlement.thrift_spec)), None, ), # 0
19640 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
19641 
  )
19642 
 
19643 
  def __init__(self, success=None, ex=None,):
19644 
    self.success = success
19645 
    self.ex = ex
19646 
 
19647 
  def read(self, iprot):
19648 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
19649 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
19650 
      return
19651 
    iprot.readStructBegin()
19652 
    while True:
19653 
      (fname, ftype, fid) = iprot.readFieldBegin()
19654 
      if ftype == TType.STOP:
19655 
        break
19656 
      if fid == 0:
19657 
        if ftype == TType.LIST:
19658 
          self.success = []
4837 varun.gupt 19659 
          (_etype391, _size388) = iprot.readListBegin()
19660 
          for _i392 in xrange(_size388):
19661 
            _elem393 = PaymentSettlement()
19662 
            _elem393.read(iprot)
19663 
            self.success.append(_elem393)
4715 varun.gupt 19664 
          iprot.readListEnd()
19665 
        else:
19666 
          iprot.skip(ftype)
19667 
      elif fid == 1:
19668 
        if ftype == TType.STRUCT:
19669 
          self.ex = TransactionServiceException()
19670 
          self.ex.read(iprot)
19671 
        else:
19672 
          iprot.skip(ftype)
19673 
      else:
19674 
        iprot.skip(ftype)
19675 
      iprot.readFieldEnd()
19676 
    iprot.readStructEnd()
19677 
 
19678 
  def write(self, oprot):
19679 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
19680 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
19681 
      return
19682 
    oprot.writeStructBegin('getSettlementsByDate_result')
19683 
    if self.success is not None:
19684 
      oprot.writeFieldBegin('success', TType.LIST, 0)
19685 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
4837 varun.gupt 19686 
      for iter394 in self.success:
19687 
        iter394.write(oprot)
4715 varun.gupt 19688 
      oprot.writeListEnd()
19689 
      oprot.writeFieldEnd()
19690 
    if self.ex is not None:
19691 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
19692 
      self.ex.write(oprot)
19693 
      oprot.writeFieldEnd()
19694 
    oprot.writeFieldStop()
19695 
    oprot.writeStructEnd()
19696 
 
19697 
  def validate(self):
19698 
    return
19699 
 
19700 
 
19701 
  def __repr__(self):
19702 
    L = ['%s=%r' % (key, value)
19703 
      for key, value in self.__dict__.iteritems()]
19704 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
19705 
 
19706 
  def __eq__(self, other):
19707 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
19708 
 
19709 
  def __ne__(self, other):
19710 
    return not (self == other)
19711 
 
19712 
class getReshippedOrderIds_args:
19713 
  """
19714 
  Attributes:
19715 
   - orderIds
19716 
  """
19717 
 
19718 
  thrift_spec = (
19719 
    None, # 0
19720 
    (1, TType.LIST, 'orderIds', (TType.I64,None), None, ), # 1
19721 
  )
19722 
 
19723 
  def __init__(self, orderIds=None,):
19724 
    self.orderIds = orderIds
19725 
 
19726 
  def read(self, iprot):
19727 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
19728 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
19729 
      return
19730 
    iprot.readStructBegin()
19731 
    while True:
19732 
      (fname, ftype, fid) = iprot.readFieldBegin()
19733 
      if ftype == TType.STOP:
19734 
        break
19735 
      if fid == 1:
19736 
        if ftype == TType.LIST:
19737 
          self.orderIds = []
4837 varun.gupt 19738 
          (_etype398, _size395) = iprot.readListBegin()
19739 
          for _i399 in xrange(_size395):
19740 
            _elem400 = iprot.readI64();
19741 
            self.orderIds.append(_elem400)
4715 varun.gupt 19742 
          iprot.readListEnd()
19743 
        else:
19744 
          iprot.skip(ftype)
19745 
      else:
19746 
        iprot.skip(ftype)
19747 
      iprot.readFieldEnd()
19748 
    iprot.readStructEnd()
19749 
 
19750 
  def write(self, oprot):
19751 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
19752 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
19753 
      return
19754 
    oprot.writeStructBegin('getReshippedOrderIds_args')
19755 
    if self.orderIds is not None:
19756 
      oprot.writeFieldBegin('orderIds', TType.LIST, 1)
19757 
      oprot.writeListBegin(TType.I64, len(self.orderIds))
4837 varun.gupt 19758 
      for iter401 in self.orderIds:
19759 
        oprot.writeI64(iter401)
4715 varun.gupt 19760 
      oprot.writeListEnd()
19761 
      oprot.writeFieldEnd()
19762 
    oprot.writeFieldStop()
19763 
    oprot.writeStructEnd()
19764 
 
19765 
  def validate(self):
19766 
    return
19767 
 
19768 
 
19769 
  def __repr__(self):
19770 
    L = ['%s=%r' % (key, value)
19771 
      for key, value in self.__dict__.iteritems()]
19772 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
19773 
 
19774 
  def __eq__(self, other):
19775 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
19776 
 
19777 
  def __ne__(self, other):
19778 
    return not (self == other)
19779 
 
19780 
class getReshippedOrderIds_result:
19781 
  """
19782 
  Attributes:
19783 
   - success
19784 
   - ex
19785 
  """
19786 
 
19787 
  thrift_spec = (
19788 
    (0, TType.LIST, 'success', (TType.I64,None), None, ), # 0
19789 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
19790 
  )
19791 
 
19792 
  def __init__(self, success=None, ex=None,):
19793 
    self.success = success
19794 
    self.ex = ex
19795 
 
19796 
  def read(self, iprot):
19797 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
19798 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
19799 
      return
19800 
    iprot.readStructBegin()
19801 
    while True:
19802 
      (fname, ftype, fid) = iprot.readFieldBegin()
19803 
      if ftype == TType.STOP:
19804 
        break
19805 
      if fid == 0:
19806 
        if ftype == TType.LIST:
19807 
          self.success = []
4837 varun.gupt 19808 
          (_etype405, _size402) = iprot.readListBegin()
19809 
          for _i406 in xrange(_size402):
19810 
            _elem407 = iprot.readI64();
19811 
            self.success.append(_elem407)
4715 varun.gupt 19812 
          iprot.readListEnd()
19813 
        else:
19814 
          iprot.skip(ftype)
19815 
      elif fid == 1:
19816 
        if ftype == TType.STRUCT:
19817 
          self.ex = TransactionServiceException()
19818 
          self.ex.read(iprot)
19819 
        else:
19820 
          iprot.skip(ftype)
19821 
      else:
19822 
        iprot.skip(ftype)
19823 
      iprot.readFieldEnd()
19824 
    iprot.readStructEnd()
19825 
 
19826 
  def write(self, oprot):
19827 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
19828 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
19829 
      return
19830 
    oprot.writeStructBegin('getReshippedOrderIds_result')
19831 
    if self.success is not None:
19832 
      oprot.writeFieldBegin('success', TType.LIST, 0)
19833 
      oprot.writeListBegin(TType.I64, len(self.success))
4837 varun.gupt 19834 
      for iter408 in self.success:
19835 
        oprot.writeI64(iter408)
4715 varun.gupt 19836 
      oprot.writeListEnd()
19837 
      oprot.writeFieldEnd()
19838 
    if self.ex is not None:
19839 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
19840 
      self.ex.write(oprot)
19841 
      oprot.writeFieldEnd()
19842 
    oprot.writeFieldStop()
19843 
    oprot.writeStructEnd()
19844 
 
19845 
  def validate(self):
19846 
    return
19847 
 
19848 
 
19849 
  def __repr__(self):
19850 
    L = ['%s=%r' % (key, value)
19851 
      for key, value in self.__dict__.iteritems()]
19852 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
19853 
 
19854 
  def __eq__(self, other):
19855 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
19856 
 
19857 
  def __ne__(self, other):
19858 
    return not (self == other)
4757 mandeep.dh 19859 
 
19860 
class updateOrdersAsPORaised_args:
19861 
  """
19862 
  Attributes:
19863 
   - itemIdQuantityMap
19864 
   - purchaseOrderId
19865 
   - warehouseId
19866 
  """
19867 
 
19868 
  thrift_spec = (
19869 
    None, # 0
19870 
    (1, TType.MAP, 'itemIdQuantityMap', (TType.I64,None,TType.I64,None), None, ), # 1
19871 
    (2, TType.I64, 'purchaseOrderId', None, None, ), # 2
19872 
    (3, TType.I64, 'warehouseId', None, None, ), # 3
19873 
  )
19874 
 
19875 
  def __init__(self, itemIdQuantityMap=None, purchaseOrderId=None, warehouseId=None,):
19876 
    self.itemIdQuantityMap = itemIdQuantityMap
19877 
    self.purchaseOrderId = purchaseOrderId
19878 
    self.warehouseId = warehouseId
19879 
 
19880 
  def read(self, iprot):
19881 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
19882 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
19883 
      return
19884 
    iprot.readStructBegin()
19885 
    while True:
19886 
      (fname, ftype, fid) = iprot.readFieldBegin()
19887 
      if ftype == TType.STOP:
19888 
        break
19889 
      if fid == 1:
19890 
        if ftype == TType.MAP:
19891 
          self.itemIdQuantityMap = {}
4837 varun.gupt 19892 
          (_ktype410, _vtype411, _size409 ) = iprot.readMapBegin()
19893 
          for _i413 in xrange(_size409):
19894 
            _key414 = iprot.readI64();
19895 
            _val415 = iprot.readI64();
19896 
            self.itemIdQuantityMap[_key414] = _val415
4757 mandeep.dh 19897 
          iprot.readMapEnd()
19898 
        else:
19899 
          iprot.skip(ftype)
19900 
      elif fid == 2:
19901 
        if ftype == TType.I64:
19902 
          self.purchaseOrderId = iprot.readI64();
19903 
        else:
19904 
          iprot.skip(ftype)
19905 
      elif fid == 3:
19906 
        if ftype == TType.I64:
19907 
          self.warehouseId = iprot.readI64();
19908 
        else:
19909 
          iprot.skip(ftype)
19910 
      else:
19911 
        iprot.skip(ftype)
19912 
      iprot.readFieldEnd()
19913 
    iprot.readStructEnd()
19914 
 
19915 
  def write(self, oprot):
19916 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
19917 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
19918 
      return
19919 
    oprot.writeStructBegin('updateOrdersAsPORaised_args')
19920 
    if self.itemIdQuantityMap is not None:
19921 
      oprot.writeFieldBegin('itemIdQuantityMap', TType.MAP, 1)
19922 
      oprot.writeMapBegin(TType.I64, TType.I64, len(self.itemIdQuantityMap))
4837 varun.gupt 19923 
      for kiter416,viter417 in self.itemIdQuantityMap.items():
19924 
        oprot.writeI64(kiter416)
19925 
        oprot.writeI64(viter417)
4757 mandeep.dh 19926 
      oprot.writeMapEnd()
19927 
      oprot.writeFieldEnd()
19928 
    if self.purchaseOrderId is not None:
19929 
      oprot.writeFieldBegin('purchaseOrderId', TType.I64, 2)
19930 
      oprot.writeI64(self.purchaseOrderId)
19931 
      oprot.writeFieldEnd()
19932 
    if self.warehouseId is not None:
19933 
      oprot.writeFieldBegin('warehouseId', TType.I64, 3)
19934 
      oprot.writeI64(self.warehouseId)
19935 
      oprot.writeFieldEnd()
19936 
    oprot.writeFieldStop()
19937 
    oprot.writeStructEnd()
19938 
 
19939 
  def validate(self):
19940 
    return
19941 
 
19942 
 
19943 
  def __repr__(self):
19944 
    L = ['%s=%r' % (key, value)
19945 
      for key, value in self.__dict__.iteritems()]
19946 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
19947 
 
19948 
  def __eq__(self, other):
19949 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
19950 
 
19951 
  def __ne__(self, other):
19952 
    return not (self == other)
19953 
 
19954 
class updateOrdersAsPORaised_result:
19955 
  """
19956 
  Attributes:
19957 
   - ex
19958 
  """
19959 
 
19960 
  thrift_spec = (
19961 
    None, # 0
19962 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
19963 
  )
19964 
 
19965 
  def __init__(self, ex=None,):
19966 
    self.ex = ex
19967 
 
19968 
  def read(self, iprot):
19969 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
19970 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
19971 
      return
19972 
    iprot.readStructBegin()
19973 
    while True:
19974 
      (fname, ftype, fid) = iprot.readFieldBegin()
19975 
      if ftype == TType.STOP:
19976 
        break
19977 
      if fid == 1:
19978 
        if ftype == TType.STRUCT:
19979 
          self.ex = TransactionServiceException()
19980 
          self.ex.read(iprot)
19981 
        else:
19982 
          iprot.skip(ftype)
19983 
      else:
19984 
        iprot.skip(ftype)
19985 
      iprot.readFieldEnd()
19986 
    iprot.readStructEnd()
19987 
 
19988 
  def write(self, oprot):
19989 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
19990 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
19991 
      return
19992 
    oprot.writeStructBegin('updateOrdersAsPORaised_result')
19993 
    if self.ex is not None:
19994 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
19995 
      self.ex.write(oprot)
19996 
      oprot.writeFieldEnd()
19997 
    oprot.writeFieldStop()
19998 
    oprot.writeStructEnd()
19999 
 
20000 
  def validate(self):
20001 
    return
20002 
 
20003 
 
20004 
  def __repr__(self):
20005 
    L = ['%s=%r' % (key, value)
20006 
      for key, value in self.__dict__.iteritems()]
20007 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
20008 
 
20009 
  def __eq__(self, other):
20010 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
20011 
 
20012 
  def __ne__(self, other):
20013 
    return not (self == other)
4875 varun.gupt 20014 
 
20015 
class getOrdersWhereVendorNotPaid_args:
20016 
  """
20017 
  Attributes:
20018 
   - vendorId
20019 
  """
20020 
 
20021 
  thrift_spec = (
20022 
    None, # 0
20023 
    (1, TType.I64, 'vendorId', None, None, ), # 1
20024 
  )
20025 
 
20026 
  def __init__(self, vendorId=None,):
20027 
    self.vendorId = vendorId
20028 
 
20029 
  def read(self, iprot):
20030 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
20031 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
20032 
      return
20033 
    iprot.readStructBegin()
20034 
    while True:
20035 
      (fname, ftype, fid) = iprot.readFieldBegin()
20036 
      if ftype == TType.STOP:
20037 
        break
20038 
      if fid == 1:
20039 
        if ftype == TType.I64:
20040 
          self.vendorId = iprot.readI64();
20041 
        else:
20042 
          iprot.skip(ftype)
20043 
      else:
20044 
        iprot.skip(ftype)
20045 
      iprot.readFieldEnd()
20046 
    iprot.readStructEnd()
20047 
 
20048 
  def write(self, oprot):
20049 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
20050 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
20051 
      return
20052 
    oprot.writeStructBegin('getOrdersWhereVendorNotPaid_args')
20053 
    if self.vendorId is not None:
20054 
      oprot.writeFieldBegin('vendorId', TType.I64, 1)
20055 
      oprot.writeI64(self.vendorId)
20056 
      oprot.writeFieldEnd()
20057 
    oprot.writeFieldStop()
20058 
    oprot.writeStructEnd()
20059 
 
20060 
  def validate(self):
20061 
    return
20062 
 
20063 
 
20064 
  def __repr__(self):
20065 
    L = ['%s=%r' % (key, value)
20066 
      for key, value in self.__dict__.iteritems()]
20067 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
20068 
 
20069 
  def __eq__(self, other):
20070 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
20071 
 
20072 
  def __ne__(self, other):
20073 
    return not (self == other)
20074 
 
20075 
class getOrdersWhereVendorNotPaid_result:
20076 
  """
20077 
  Attributes:
20078 
   - success
20079 
   - ex
20080 
  """
20081 
 
20082 
  thrift_spec = (
20083 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
20084 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
20085 
  )
20086 
 
20087 
  def __init__(self, success=None, ex=None,):
20088 
    self.success = success
20089 
    self.ex = ex
20090 
 
20091 
  def read(self, iprot):
20092 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
20093 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
20094 
      return
20095 
    iprot.readStructBegin()
20096 
    while True:
20097 
      (fname, ftype, fid) = iprot.readFieldBegin()
20098 
      if ftype == TType.STOP:
20099 
        break
20100 
      if fid == 0:
20101 
        if ftype == TType.LIST:
20102 
          self.success = []
20103 
          (_etype421, _size418) = iprot.readListBegin()
20104 
          for _i422 in xrange(_size418):
20105 
            _elem423 = Order()
20106 
            _elem423.read(iprot)
20107 
            self.success.append(_elem423)
20108 
          iprot.readListEnd()
20109 
        else:
20110 
          iprot.skip(ftype)
20111 
      elif fid == 1:
20112 
        if ftype == TType.STRUCT:
20113 
          self.ex = TransactionServiceException()
20114 
          self.ex.read(iprot)
20115 
        else:
20116 
          iprot.skip(ftype)
20117 
      else:
20118 
        iprot.skip(ftype)
20119 
      iprot.readFieldEnd()
20120 
    iprot.readStructEnd()
20121 
 
20122 
  def write(self, oprot):
20123 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
20124 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
20125 
      return
20126 
    oprot.writeStructBegin('getOrdersWhereVendorNotPaid_result')
20127 
    if self.success is not None:
20128 
      oprot.writeFieldBegin('success', TType.LIST, 0)
20129 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
20130 
      for iter424 in self.success:
20131 
        iter424.write(oprot)
20132 
      oprot.writeListEnd()
20133 
      oprot.writeFieldEnd()
20134 
    if self.ex is not None:
20135 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
20136 
      self.ex.write(oprot)
20137 
      oprot.writeFieldEnd()
20138 
    oprot.writeFieldStop()
20139 
    oprot.writeStructEnd()
20140 
 
20141 
  def validate(self):
20142 
    return
20143 
 
20144 
 
20145 
  def __repr__(self):
20146 
    L = ['%s=%r' % (key, value)
20147 
      for key, value in self.__dict__.iteritems()]
20148 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
20149 
 
20150 
  def __eq__(self, other):
20151 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
20152 
 
20153 
  def __ne__(self, other):
20154 
    return not (self == other)