Subversion Repositories SmartDukaan

Rev

Rev 4999 | Rev 5067 | 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 
 
4999 phani.kuma 208 
  def getOrderList(self, order_ids):
209 
    """
210 
    Parameters:
211 
     - order_ids
212 
    """
213 
    pass
214 
 
1528 ankur.sing 215 
  def getOrderForCustomer(self, orderId, customerId):
216 
    """
217 
    Returns an order for the order Id. Also checks if the order belongs to the customer whose Id is passed.
218 
    Throws exception if either order Id is invalid or order does not below to the customer whose Id is passed.
3431 rajveer 219 
 
1528 ankur.sing 220 
    Parameters:
221 
     - orderId
222 
     - customerId
223 
    """
224 
    pass
225 
 
4444 rajveer 226 
  def getAlerts(self, type, warehouseId, status, timestamp):
3064 chandransh 227 
    """
228 
    Parameters:
4394 rajveer 229 
     - type
4444 rajveer 230 
     - warehouseId
4394 rajveer 231 
     - status
232 
     - timestamp
3064 chandransh 233 
    """
234 
    pass
235 
 
4444 rajveer 236 
  def addAlert(self, type, warehouseId, description):
3064 chandransh 237 
    """
238 
    Parameters:
239 
     - type
4444 rajveer 240 
     - warehouseId
4394 rajveer 241 
     - description
3064 chandransh 242 
    """
243 
    pass
244 
 
4444 rajveer 245 
  def markAlertsAsSeen(self, warehouseId):
246 
    """
247 
    Parameters:
248 
     - warehouseId
249 
    """
250 
    pass
251 
 
3064 chandransh 252 
  def getValidOrderCount(self, ):
253 
    """
254 
    Return the number of valid orders. (OrderStatus >= OrderStatus.SUBMITTED_FOR_PROCESSING)
255 
    """
256 
    pass
257 
 
258 
  def getNoOfCustomersWithSuccessfulTransaction(self, ):
259 
    """
260 
    Returns the number of distinct customers who have done successful transactions
261 
    """
262 
    pass
263 
 
264 
  def getValidOrdersAmountRange(self, ):
265 
    """
266 
    Returns the minimum and maximum amounts of a valid order. (OrderStatus >= OrderStatus.SUBMITTED_FOR_PROCESSING)
267 
    List contains two values, first minimum amount and second maximum amount.
268 
    """
269 
    pass
270 
 
271 
  def getValidOrders(self, limit):
272 
    """
273 
    Returns list of Orders in descending order by Order creation date. List is restricted to limit Orders.
274 
    If limit is passed as 0, then all valid Orders are returned.
3431 rajveer 275 
 
3064 chandransh 276 
    Parameters:
277 
     - limit
278 
    """
279 
    pass
280 
 
1220 chandransh 281 
  def batchOrders(self, warehouseId):
282 
    """
283 
    Create a batch of all the pending orders for the given warehouse.
284 
    The returned list is orderd by created_timestamp.
285 
    If there are no pending orders, an empty list is returned.
3431 rajveer 286 
 
1220 chandransh 287 
    Parameters:
288 
     - warehouseId
289 
    """
290 
    pass
291 
 
1208 chandransh 292 
  def markOrderAsOutOfStock(self, orderId):
293 
    """
294 
    Mark the given order as out of stock. Throws an exception if the order with the given Id couldn't be found.
3431 rajveer 295 
 
1208 chandransh 296 
    Parameters:
297 
     - orderId
298 
    """
299 
    pass
300 
 
3064 chandransh 301 
  def verifyOrder(self, orderId):
759 chandransh 302 
    """
3064 chandransh 303 
    Marks the given order as SUBMITTED_FOR_PROCESSING and updates the verified
304 
    timestamp. It is intended to be used for COD orders but can be harmlessly
305 
    used for all other orders as well.
306 
    Throws an exception if no such order exists.
3431 rajveer 307 
 
759 chandransh 308 
    Parameters:
3064 chandransh 309 
     - orderId
310 
    """
311 
    pass
312 
 
313 
  def acceptOrder(self, orderId):
314 
    """
315 
    Marks the given order as ACCEPTED and updates the accepted timestamp. If the
316 
    given order is not a COD order, it also captures the payment if the same has
317 
    not been captured.
318 
    Throws an exception if no such order exists.
3431 rajveer 319 
 
3064 chandransh 320 
    Parameters:
321 
     - orderId
322 
    """
323 
    pass
324 
 
4763 rajveer 325 
  def addBillingDetails(self, orderId, invoice_number, serialNumber, itemNumber, billed_by, jacketNumber, billingType, vendorId, authorize):
3064 chandransh 326 
    """
327 
    Add billing details such as the bill number and the biller to the Order.
4658 mandeep.dh 328 
    Adds jacket number, item number and Serial no. to the order. Doesn't update
3064 chandransh 329 
    the IMEI no. if a -1 is supplied.
330 
    Also, it generates an invoice number for the order, marks the order as
331 
    BILLED and sets the billing timestamp.
332 
    Returns false if it doesn't find the order with the given ID.
3431 rajveer 333 
 
3064 chandransh 334 
    Parameters:
335 
     - orderId
4283 anupam.sin 336 
     - invoice_number
4658 mandeep.dh 337 
     - serialNumber
3064 chandransh 338 
     - itemNumber
4283 anupam.sin 339 
     - billed_by
340 
     - jacketNumber
3064 chandransh 341 
     - billingType
4283 anupam.sin 342 
     - vendorId
4763 rajveer 343 
     - authorize
3064 chandransh 344 
    """
345 
    pass
346 
 
4763 rajveer 347 
  def addInvoiceNumber(self, orderId, invoiceNumber, color):
4579 rajveer 348 
    """
349 
    Add the invoice number to the order.
350 
 
351 
    Parameters:
352 
     - orderId
353 
     - invoiceNumber
4763 rajveer 354 
     - color
4579 rajveer 355 
    """
356 
    pass
357 
 
4910 phani.kuma 358 
  def markOrdersAsShippedFromWarehouse(self, warehouseId, providerId, cod, orderIds):
3064 chandransh 359 
    """
360 
    Depending on the third parameter, marks either all prepaid or all cod orders BILLED by the
4910 phani.kuma 361 
    given warehouse and were picked up by the given provider as SHIPPED_FROM_WH.
4410 rajveer 362 
 
363 
    Parameters:
364 
     - warehouseId
365 
     - providerId
366 
     - cod
4910 phani.kuma 367 
     - orderIds
4410 rajveer 368 
    """
369 
    pass
370 
 
4910 phani.kuma 371 
  def markOrdersAsPickedUp(self, providerId, pickupDetails):
4410 rajveer 372 
    """
4910 phani.kuma 373 
    Marks all SHIPPED_FROM_WH orders of the previous day for a provider as SHIPPED_TO_LOGISTICS.
374 
    Raises an exception if we encounter report for an AWB number that we did not ship.
3431 rajveer 375 
 
3064 chandransh 376 
    Parameters:
759 chandransh 377 
     - providerId
4910 phani.kuma 378 
     - pickupDetails
759 chandransh 379 
    """
380 
    pass
381 
 
4910 phani.kuma 382 
  def getOrdersNotPickedUp(self, providerId):
1113 chandransh 383 
    """
384 
    Returns a list of orders that were shipped from warehouse but did not appear in the pick-up report.
3431 rajveer 385 
 
1113 chandransh 386 
    Parameters:
387 
     - providerId
388 
    """
389 
    pass
390 
 
1132 chandransh 391 
  def markOrdersAsDelivered(self, providerId, deliveredOrders):
392 
    """
393 
    Marks all orders with AWBs in the given map as delivered. Also sets the delivery timestamp and
394 
    the name of the receiver.
395 
    Raises an exception if we encounter report for an AWB number that we did not ship.
3431 rajveer 396 
 
1132 chandransh 397 
    Parameters:
398 
     - providerId
399 
     - deliveredOrders
400 
    """
401 
    pass
402 
 
4910 phani.kuma 403 
  def markAsRTOrders(self, providerId, returnedOrders):
1135 chandransh 404 
    """
4910 phani.kuma 405 
    Mark all orders with AWBs in the given map as RTO. Also sets the delivery timestamp.
1135 chandransh 406 
    Raises an exception if we encounter report for an AWB number that we did not ship.
3431 rajveer 407 
 
1135 chandransh 408 
    Parameters:
409 
     - providerId
410 
     - returnedOrders
411 
    """
412 
    pass
413 
 
4910 phani.kuma 414 
  def getRTOrders(self, providerId):
415 
    """
416 
    Returns a list of orders that were returned by courier.
417 
 
418 
    Parameters:
419 
     - providerId
420 
    """
421 
    pass
422 
 
1246 chandransh 423 
  def updateNonDeliveryReason(self, providerId, undeliveredOrders):
424 
    """
425 
    Update the status description of orders whose AWB numbers are keys of the Map.
3431 rajveer 426 
 
1246 chandransh 427 
    Parameters:
428 
     - providerId
429 
     - undeliveredOrders
430 
    """
431 
    pass
432 
 
4910 phani.kuma 433 
  def getNonDeliveredOrdersbyCourier(self, providerId):
434 
    """
435 
    Returns a list of orders that were picked up or shipped four days ago but did not get delivered.
436 
 
437 
    Parameters:
438 
     - providerId
439 
    """
440 
    pass
441 
 
442 
  def markOrdersAsLocalConnected(self, providerId, local_connected_orders):
443 
    """
444 
    Mark all orders with AWBs in the given map as local connected. Also sets the local connected timestamp.
445 
 
446 
    Parameters:
447 
     - providerId
448 
     - local_connected_orders
449 
    """
450 
    pass
451 
 
452 
  def getOrdersNotLocalConnected(self, providerId):
453 
    """
454 
    Returns a list of orders that were picked up or shipped but pending local connection.
455 
 
456 
    Parameters:
457 
     - providerId
458 
    """
459 
    pass
460 
 
461 
  def markOrdersAsDestinationCityReached(self, providerId, destination_city_reached_orders):
462 
    """
463 
    Mark all orders with AWBs in the given map as reached destination city. Also sets the reached destination timestamp.
464 
 
465 
    Parameters:
466 
     - providerId
467 
     - destination_city_reached_orders
468 
    """
469 
    pass
470 
 
471 
  def markOrdersAsFirstDeliveryAttempted(self, providerId, first_atdl_orders):
472 
    """
473 
    Mark all orders with AWBs in the given map as first delivery attempt made. Also sets the first delivery attempted timestamp.
474 
 
475 
    Parameters:
476 
     - providerId
477 
     - first_atdl_orders
478 
    """
479 
    pass
480 
 
1408 ankur.sing 481 
  def getUndeliveredOrders(self, providerId, warehouseId):
482 
    """
483 
    Returns the list of orders whose delivery time has passed but have not been
484 
    delivered yet for the given provider and warehouse. To get a complete list of
485 
    undelivered orders, pass them as -1.
486 
    Returns an empty list if no such orders exist.
3431 rajveer 487 
 
1408 ankur.sing 488 
    Parameters:
489 
     - providerId
490 
     - warehouseId
491 
    """
492 
    pass
493 
 
4783 phani.kuma 494 
  def getUndeliveredOrdersExpectedDeliveryDateNotMet(self, ):
495 
    """
496 
    Returns the list of orders whose expected delivery date has passed but have not been
497 
    delivered yet.
498 
    Returns an empty list if no such orders exist.
499 
    """
500 
    pass
501 
 
2536 chandransh 502 
  def toggleDOAFlag(self, orderId):
503 
    """
504 
    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.
505 
    Returns the final flag status.
506 
    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 507 
 
2536 chandransh 508 
    Parameters:
509 
     - orderId
510 
    """
511 
    pass
1886 ankur.sing 512 
 
4712 rajveer 513 
  def markOrderAsDelivered(self, orderId, deliveryTimestamp, receiver):
514 
    """
515 
    Parameters:
516 
     - orderId
517 
     - deliveryTimestamp
518 
     - receiver
519 
    """
520 
    pass
521 
 
4454 rajveer 522 
  def markOrderDoaRequestReceived(self, orderId):
523 
    """
524 
    Once user raise the request for a DOA, order status will be changed from DELVIERY_SUCCESS to DOA_REQUEST_RECEIVED
525 
 
526 
    Parameters:
527 
     - orderId
528 
    """
529 
    pass
530 
 
531 
  def markOrderDoaRequestAuthorized(self, orderId, isAuthorized):
532 
    """
533 
    CRM person can authorize or deny the request reised by customer. If he authorizes order will change from DOA_REQUEST_RECEIVED
534 
    to DOA_REQUEST_AUTHORIZED. If he denies, status will be changed back to DELVIERY_SUCCESS.
535 
 
536 
    Parameters:
537 
     - orderId
538 
     - isAuthorized
539 
    """
540 
    pass
541 
 
4488 rajveer 542 
  def markOrderReturnRequestReceived(self, orderId):
543 
    """
544 
    Once user raise the request for a RET, order status will be changed from DELVIERY_SUCCESS to RET_REQUEST_RECEIVED
545 
 
546 
    Parameters:
547 
     - orderId
548 
    """
549 
    pass
550 
 
551 
  def markOrderReturnRequestAuthorized(self, orderId, isAuthorized):
552 
    """
553 
    CRM person can authorize or deny the request reised by customer. If he authorizes order will change from RET_REQUEST_RECEIVED
554 
    to RET_REQUEST_AUTHORIZED. If he denies, status will be changed back to DELVIERY_SUCCESS.
555 
 
556 
    Parameters:
557 
     - orderId
558 
     - isAuthorized
559 
    """
560 
    pass
561 
 
4579 rajveer 562 
  def requestPickupNumber(self, orderId, providerId):
2536 chandransh 563 
    """
564 
    Sends out an email to the account manager of the original courier provider used to ship the order.
4452 rajveer 565 
    If the order status was DELIVERY_SUCCESS, it is changed to be DOA_PICKUP_REQUEST_RAISED.
566 
    If the order status was DOA_PICKUP_REQUEST_RAISED, it is left unchanged.
2536 chandransh 567 
    For any other status, it returns false.
568 
    Throws an exception if the order with the given id couldn't be found.
3431 rajveer 569 
 
2536 chandransh 570 
    Parameters:
571 
     - orderId
4579 rajveer 572 
     - providerId
2536 chandransh 573 
    """
574 
    pass
575 
 
4602 rajveer 576 
  def authorizePickup(self, orderId, pickupNumber, providerId):
2536 chandransh 577 
    """
4452 rajveer 578 
    If the order status is DOA_PICKUP_REQUEST_RAISED, it does the following
2536 chandransh 579 
    	1. Sends out an email to the customer with the dispatch advice that he has to print as an attachment.
580 
    	2. Changes order status to be DOA_PICKUP_AUTHORIZED.
581 
    	3. Returns true
2591 chandransh 582 
    If the order is in any other status, it returns false.
2536 chandransh 583 
    Throws an exception if the order with the given id couldn't be found.
3431 rajveer 584 
 
2536 chandransh 585 
    Parameters:
586 
     - orderId
587 
     - pickupNumber
4602 rajveer 588 
     - providerId
2536 chandransh 589 
    """
590 
    pass
591 
 
2764 chandransh 592 
  def markDoasAsPickedUp(self, providerId, pickupDetails):
593 
    """
594 
    Marks all DOA_PICKUP_AUTHORIZED orders of the previous day for a provider as DOA_RETURN_IN_TRANSIT.
3431 rajveer 595 
 
2764 chandransh 596 
    Parameters:
597 
     - providerId
598 
     - pickupDetails
599 
    """
600 
    pass
601 
 
4910 phani.kuma 602 
  def getDoasNotPickedUp(self, providerId):
603 
    """
604 
    Returns a list of orders that were authorized for pickup but did not appear in the pick-up report.
605 
 
606 
    Parameters:
607 
     - providerId
608 
    """
609 
    pass
610 
 
4741 phani.kuma 611 
  def markReturnOrdersAsPickedUp(self, providerId, pickupDetails):
612 
    """
613 
    Marks all RET_PICKUP_CONFIRMED orders of the previous day for a provider as RET_RETURN_IN_TRANSIT.
614 
 
615 
    Parameters:
616 
     - providerId
617 
     - pickupDetails
618 
    """
619 
    pass
620 
 
4910 phani.kuma 621 
  def getReturnOrdersNotPickedUp(self, providerId):
622 
    """
623 
    Returns a list of orders that were authorized for pickup but did not appear in the pick-up report.
624 
 
625 
    Parameters:
626 
     - providerId
627 
    """
628 
    pass
629 
 
4479 rajveer 630 
  def receiveReturn(self, orderId, receiveCondition):
2591 chandransh 631 
    """
4452 rajveer 632 
    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 633 
    If the order status is RTO_IN_TRANSIT, marks the order status as RTO_RECEIVED_PRESTINE and returns true.
2591 chandransh 634 
    If the order is in any other state, it returns false.
635 
    Throws an exception if the order with the given id couldn't be found.
3431 rajveer 636 
 
2591 chandransh 637 
    Parameters:
638 
     - orderId
4479 rajveer 639 
     - receiveCondition
2591 chandransh 640 
    """
641 
    pass
2536 chandransh 642 
 
2591 chandransh 643 
  def validateDoa(self, orderId, isValid):
644 
    """
4452 rajveer 645 
    Used to validate the DOA certificate for an order in the DOA_RECEIVED_PRESTINE state. If the certificate is valid,
2616 chandransh 646 
    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 647 
    If the order is in any other state, it returns false.
648 
    Throws an exception if the order with the given id couldn't be found.
3431 rajveer 649 
 
2591 chandransh 650 
    Parameters:
651 
     - orderId
652 
     - isValid
653 
    """
654 
    pass
655 
 
4495 rajveer 656 
  def validateReturnProduct(self, orderId, isUsable):
657 
    """
658 
    Parameters:
659 
     - orderId
660 
     - isUsable
661 
    """
662 
    pass
663 
 
2616 chandransh 664 
  def reshipOrder(self, orderId):
665 
    """
4484 rajveer 666 
    If the order is in RTO_RECEIVED_PRESTINE or DOA_CERT_INVALID state, it does the following:
2616 chandransh 667 
    	1. Creates a new order for processing in the BILLED state. All billing information is saved.
4484 rajveer 668 
    	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 669 
 
670 
    If the order is in DOA_CERT_VALID state, it does the following:
671 
    	1. Creates a new order for processing in the SUBMITTED_FOR_PROCESSING state.
672 
    	2. Creates a return order for the warehouse executive to return the DOA material.
4452 rajveer 673 
    	3. Marks the current order as the final DOA_VALID_RESHIPPED state.
3431 rajveer 674 
 
2616 chandransh 675 
    Returns the id of the newly created order.
3431 rajveer 676 
 
2616 chandransh 677 
    Throws an exception if the order with the given id couldn't be found.
3431 rajveer 678 
 
2616 chandransh 679 
    Parameters:
680 
     - orderId
681 
    """
682 
    pass
2591 chandransh 683 
 
3226 chandransh 684 
  def refundOrder(self, orderId, refundedBy, reason):
2616 chandransh 685 
    """
4484 rajveer 686 
    If the order is in RTO_RECEIVED_PRESTINE, DOA_CERT_VALID or DOA_CERT_INVALID state, it does the following:
2616 chandransh 687 
    	1. Creates a refund request for batch processing.
688 
    	2. Creates a return order for the warehouse executive to return the shipped material.
4484 rajveer 689 
    	3. Marks the current order as RTO_REFUNDED, DOA_VALID_REFUNDED or DOA_INVALID_REFUNDED final states.
3431 rajveer 690 
 
2616 chandransh 691 
    If the order is in SUBMITTED_FOR_PROCESSING or INVENTORY_LOW state, it does the following:
692 
    	1. Creates a refund request for batch processing.
3226 chandransh 693 
    	2. Cancels the reservation of the item in the warehouse.
694 
    	3. Marks the current order as the REFUNDED final state.
3431 rajveer 695 
 
3226 chandransh 696 
    For all COD orders, if the order is in INIT, SUBMITTED_FOR_PROCESSING or INVENTORY_LOW state, it does the following:
697 
    	1. Cancels the reservation of the item in the warehouse.
698 
    	2. Marks the current order as CANCELED.
699 
 
700 
    In all cases, it updates the reason for cancellation or refund and the person who performed the action.
701 
 
2616 chandransh 702 
    Returns True if it is successful, False otherwise.
3431 rajveer 703 
 
2616 chandransh 704 
    Throws an exception if the order with the given id couldn't be found.
3431 rajveer 705 
 
2616 chandransh 706 
    Parameters:
707 
     - orderId
3226 chandransh 708 
     - refundedBy
709 
     - reason
2616 chandransh 710 
    """
711 
    pass
712 
 
2690 chandransh 713 
  def getReturnOrders(self, warehouseId, fromDate, toDate):
714 
    """
715 
    Get all return orders created between the from and to dates for the given warehouse.
716 
    Ignores the warehouse if it is passed as -1.
3431 rajveer 717 
 
2690 chandransh 718 
    Parameters:
719 
     - warehouseId
720 
     - fromDate
721 
     - toDate
722 
    """
723 
    pass
2616 chandransh 724 
 
2700 chandransh 725 
  def getReturnOrder(self, id):
726 
    """
727 
    Returns the ReturnOrder corresponding to the given id.
728 
    Throws an exception if the return order with the given id couldn't be found.
3431 rajveer 729 
 
2700 chandransh 730 
    Parameters:
731 
     - id
732 
    """
733 
    pass
734 
 
2690 chandransh 735 
  def processReturn(self, returnOrderId):
736 
    """
737 
    Marks the return order with the given id as processed. Raises an exception if no such return order exists.
3431 rajveer 738 
 
2690 chandransh 739 
    Parameters:
740 
     - returnOrderId
741 
    """
742 
    pass
743 
 
3451 chandransh 744 
  def updateWeight(self, orderId, weight):
745 
    """
746 
    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 747 
 
3451 chandransh 748 
    Parameters:
749 
     - orderId
750 
     - weight
751 
    """
752 
    pass
753 
 
3469 chandransh 754 
  def changeItem(self, orderId, itemId):
755 
    """
756 
    Change the item to be shipped for this order. Also adjusts the reservation in the inventory accordingly.
757 
    Currently, it also ensures that only a different color of the given item is shipped.
3451 chandransh 758 
 
3469 chandransh 759 
    Parameters:
760 
     - orderId
761 
     - itemId
762 
    """
763 
    pass
764 
 
765 
  def shiftToWarehouse(self, orderId, warehouseId):
766 
    """
767 
    Moves the given order to the given warehouse. Also adjusts the inventory reservations accordingly.
768 
 
769 
    Parameters:
770 
     - orderId
771 
     - warehouseId
772 
    """
773 
    pass
774 
 
4647 rajveer 775 
  def addDelayReason(self, orderId, delayReason, furtherDelay, delayReasonText):
3553 chandransh 776 
    """
777 
    Adds the given delay reason to the given order.
3986 chandransh 778 
    Increases the expected delivery time of the given order by the given no. of days.
3553 chandransh 779 
    Raises an exception if no order with the given id can be found.
3469 chandransh 780 
 
3553 chandransh 781 
    Parameters:
782 
     - orderId
783 
     - delayReason
3986 chandransh 784 
     - furtherDelay
4647 rajveer 785 
     - delayReasonText
3553 chandransh 786 
    """
787 
    pass
788 
 
3956 chandransh 789 
  def reconcileCodCollection(self, collectedAmountMap, xferBy, xferTxnId, xferDate):
790 
    """
791 
    Marks the COD orders with given AWB nos. as having been processed.
792 
    Updates the captured amount for the corresponding payment.
3553 chandransh 793 
 
3956 chandransh 794 
    Returns a map of AWBs which were not processed and the associated reason. An AWB is not processed if:
795 
    1. There is no order corresponding to an AWB number.
796 
    2. The captured amount for a payment exceeds the total payment.
797 
    3. The order corresponding to an AWB no. is in a state prior to DELIVERY_SUCCESS.
798 
 
799 
    Parameters:
800 
     - collectedAmountMap
801 
     - xferBy
802 
     - xferTxnId
803 
     - xferDate
804 
    """
805 
    pass
806 
 
4008 mandeep.dh 807 
  def getTransactionsRequiringExtraProcessing(self, category):
808 
    """
4065 mandeep.dh 809 
    Returns the list of transaction ids that require some extra processing and
4008 mandeep.dh 810 
    which belong to a particular category. This is currently used by CRM
4065 mandeep.dh 811 
    application. If no such transaction ids are present, it returns an empty list.
3956 chandransh 812 
 
4008 mandeep.dh 813 
    Parameters:
814 
     - category
815 
    """
816 
    pass
817 
 
818 
  def markTransactionAsProcessed(self, transactionId, category):
819 
    """
820 
    Marks a particular transaction as processed for a particular cateogory.
4065 mandeep.dh 821 
    It essentially deletes the transaction id record for a particular
822 
    processing type category (if present) from DB.
823 
    This is currently used by CRM application.
4008 mandeep.dh 824 
 
825 
    Parameters:
826 
     - transactionId
827 
     - category
828 
    """
829 
    pass
830 
 
4018 chandransh 831 
  def getItemWiseRiskyOrdersCount(self, ):
832 
    """
833 
    Returns a map containing the number of risky orders keyed by item id. A risky order
834 
    is defined as one whose shipping date is about to expire.
835 
    """
836 
    pass
4008 mandeep.dh 837 
 
4295 varun.gupt 838 
  def getOrdersForItemIds(self, itemIds):
839 
    """
840 
    Returns a list of all orders which have items with given id
841 
 
842 
    Parameters:
843 
     - itemIds
844 
    """
845 
    pass
846 
 
4247 rajveer 847 
  def markOrderCancellationRequestReceived(self, orderId):
848 
    """
849 
    Mark order as cancellation request received. If customer sends request of cancellation of
850 
    a particular order, this method will be called. It will just change status of the order
851 
    depending on its current status. It also records the previous status, so that we can move
852 
    back to that status if cancellation request is denied.
4018 chandransh 853 
 
4247 rajveer 854 
    Parameters:
855 
     - orderId
856 
    """
857 
    pass
858 
 
859 
  def markOrderCancellationRequestConfirmed(self, orderId):
860 
    """
861 
    If we decide to to cancel order, CRM will call this method to move the status of order to
862 
    cancellation request confirmed. After this OM will be able to cancel the order.
863 
 
864 
    Parameters:
865 
     - orderId
866 
    """
867 
    pass
868 
 
869 
  def markOrderCancellationRequestDenied(self, orderId):
870 
    """
871 
    If we decide to not to cancel order, we will move the order ro previous status.
872 
 
873 
    Parameters:
874 
     - orderId
875 
    """
876 
    pass
877 
 
4258 rajveer 878 
  def markTransactionAsPaymentFlagRemoved(self, transactionId):
4247 rajveer 879 
    """
4258 rajveer 880 
    If we and/or payment gateway has decided to accept the payment, this method needs to be called.
881 
    Changed transaction and all orders status to payment accepted.
4247 rajveer 882 
 
883 
    Parameters:
4258 rajveer 884 
     - transactionId
4247 rajveer 885 
    """
886 
    pass
887 
 
4259 anupam.sin 888 
  def refundTransaction(self, transactionId, refundedBy, reason):
889 
    """
890 
    This method is called when a flagged payment is deemed unserviceable and the corresponding orders
891 
    need to be cancelled
4247 rajveer 892 
 
4259 anupam.sin 893 
    Parameters:
894 
     - transactionId
895 
     - refundedBy
896 
     - reason
897 
    """
898 
    pass
899 
 
4324 mandeep.dh 900 
  def updateShipmentAddress(self, orderId, addressId):
901 
    """
902 
    Updates shipment address of an order. Delivery and shipping date estimates
903 
    etc. are also updated here.
904 
 
905 
    Throws TransactionServiceException in case address change is not
906 
    possible due to certain reasons such as new pincode in address is
907 
    not serviceable etc.
908 
 
909 
    Parameters:
910 
     - orderId
911 
     - addressId
912 
    """
913 
    pass
914 
 
4285 rajveer 915 
  def acceptOrdersForItemId(self, itemId, inventory):
916 
    """
917 
    Marks the orders as ACCEPTED for the given itemId and inventory. It also updates the accepted timestamp. If the
918 
    given order is not a COD order, it also captures the payment if the same has not been captured.
4259 anupam.sin 919 
 
4285 rajveer 920 
    Parameters:
921 
     - itemId
922 
     - inventory
923 
    """
924 
    pass
925 
 
4369 rajveer 926 
  def markOrdersAsPORaised(self, vendorId, itemId, quantity, estimate, isReminder):
4303 rajveer 927 
    """
928 
    Parameters:
929 
     - vendorId
930 
     - itemId
931 
     - quantity
932 
     - estimate
4369 rajveer 933 
     - isReminder
4303 rajveer 934 
    """
935 
    pass
4285 rajveer 936 
 
4369 rajveer 937 
  def markOrdersAsReversalInitiated(self, vendorId, itemId, quantity, estimate, isReminder):
4303 rajveer 938 
    """
939 
    Parameters:
940 
     - vendorId
941 
     - itemId
942 
     - quantity
943 
     - estimate
4369 rajveer 944 
     - isReminder
4303 rajveer 945 
    """
946 
    pass
947 
 
4369 rajveer 948 
  def markOrdersAsNotAvailabke(self, vendorId, itemId, quantity, estimate, isReminder):
4303 rajveer 949 
    """
950 
    Parameters:
951 
     - vendorId
952 
     - itemId
953 
     - quantity
954 
     - estimate
4369 rajveer 955 
     - isReminder
4303 rajveer 956 
    """
957 
    pass
958 
 
4369 rajveer 959 
  def markOrdersAsTimeout(self, vendorId):
960 
    """
961 
    Parameters:
962 
     - vendorId
963 
    """
964 
    pass
4303 rajveer 965 
 
4662 rajveer 966 
  def markOrderAsLostInTransit(self, orderId):
967 
    """
968 
    Mark order as LOST_IN_TRANSIT
969 
 
970 
    Parameters:
971 
     - orderId
972 
    """
973 
    pass
974 
 
4386 anupam.sin 975 
  def getOrderForAwb(self, awb):
976 
    """
977 
    Returns the order corresponding to an AWB number
4369 rajveer 978 
 
4386 anupam.sin 979 
    Parameters:
980 
     - awb
981 
    """
982 
    pass
983 
 
4910 phani.kuma 984 
  def getOrdersForProviderForStatus(self, logistics_provider_id, order_status_list):
4506 phani.kuma 985 
    """
4910 phani.kuma 986 
    Returns the order corresponding to a logistics provider id for a given list of order status
4386 anupam.sin 987 
 
4506 phani.kuma 988 
    Parameters:
989 
     - logistics_provider_id
4910 phani.kuma 990 
     - order_status_list
4506 phani.kuma 991 
    """
992 
    pass
993 
 
4600 varun.gupt 994 
  def getBilledOrdersForVendor(self, vendorId, billingDateFrom, billingDateTo):
995 
    """
996 
    Returns list of orders fullfiled from a certain vendor and billed in a given date range
4506 phani.kuma 997 
 
4600 varun.gupt 998 
    Parameters:
999 
     - vendorId
1000 
     - billingDateFrom
1001 
     - billingDateTo
1002 
    """
1003 
    pass
1004 
 
4607 rajveer 1005 
  def getSlippedSippingDateOrders(self, ):
1006 
    pass
1007 
 
4709 rajveer 1008 
  def getCancelledOrders(self, cancelDateFrom, cancelDateTo):
1009 
    """
1010 
    Parameters:
1011 
     - cancelDateFrom
1012 
     - cancelDateTo
1013 
    """
1014 
    pass
1015 
 
4600 varun.gupt 1016 
  def saveBluedartSettlements(self, mapAWBAndAmount):
1017 
    """
1018 
    Parameters:
1019 
     - mapAWBAndAmount
1020 
    """
1021 
    pass
1022 
 
4905 varun.gupt 1023 
  def savePaymentSettlements(self, settlementDate, paymentGatewayId, referenceId, serviceTax, otherCharges, netCollection):
4600 varun.gupt 1024 
    """
1025 
    Parameters:
1026 
     - settlementDate
1027 
     - paymentGatewayId
4905 varun.gupt 1028 
     - referenceId
4600 varun.gupt 1029 
     - serviceTax
1030 
     - otherCharges
1031 
     - netCollection
1032 
    """
1033 
    pass
1034 
 
1035 
  def saveEBSSettlementSummary(self, settlementId, settlementDate, transactionDateFrom, transactionDateTo, amount):
1036 
    """
1037 
    Parameters:
1038 
     - settlementId
1039 
     - settlementDate
1040 
     - transactionDateFrom
1041 
     - transactionDateTo
1042 
     - amount
1043 
    """
1044 
    pass
1045 
 
1046 
  def getSettlementForPaymentId(self, paymentId):
1047 
    """
1048 
    Parameters:
1049 
     - paymentId
1050 
    """
1051 
    pass
1052 
 
1053 
  def getEBSSettlementSummaries(self, ):
1054 
    pass
1055 
 
1056 
  def markEBSSettlementUploaded(self, settlementId):
1057 
    """
1058 
    Parameters:
1059 
     - settlementId
1060 
    """
1061 
    pass
1062 
 
1063 
  def getEBSSettlementDate(self, settlementId):
1064 
    """
1065 
    Parameters:
1066 
     - settlementId
1067 
    """
1068 
    pass
1069 
 
4715 varun.gupt 1070 
  def getSettlementsByDate(self, settlementDateFrom, settlementDateTo, isRefund):
1071 
    """
1072 
    Parameters:
1073 
     - settlementDateFrom
1074 
     - settlementDateTo
1075 
     - isRefund
1076 
    """
1077 
    pass
4600 varun.gupt 1078 
 
4715 varun.gupt 1079 
  def getReshippedOrderIds(self, orderIds):
1080 
    """
1081 
    Returns list of Order Ids, which belong to reshiped orders, shortlisted from a given list of Order Ids
1082 
 
1083 
    Parameters:
1084 
     - orderIds
1085 
    """
1086 
    pass
1087 
 
4757 mandeep.dh 1088 
  def updateOrdersAsPORaised(self, itemIdQuantityMap, purchaseOrderId, warehouseId):
1089 
    """
1090 
    Updates orders as PO raised. Also updates purchase order id in orders. Pass a map of items mapped to
1091 
    the quantities for which the PO is raised.
4715 varun.gupt 1092 
 
4757 mandeep.dh 1093 
    Parameters:
1094 
     - itemIdQuantityMap
1095 
     - purchaseOrderId
1096 
     - warehouseId
1097 
    """
1098 
    pass
1099 
 
4875 varun.gupt 1100 
  def getOrdersWhereVendorNotPaid(self, vendorId):
1101 
    """
1102 
    Parameters:
1103 
     - vendorId
1104 
    """
1105 
    pass
4757 mandeep.dh 1106 
 
5031 varun.gupt 1107 
  def getStatusDistributionOfOrders(self, startDate, endDate):
1108 
    """
1109 
    Parameters:
1110 
     - startDate
1111 
     - endDate
1112 
    """
1113 
    pass
4875 varun.gupt 1114 
 
5031 varun.gupt 1115 
 
3376 rajveer 1116 
class Client(shop2020.thriftpy.generic.GenericService.Client, Iface):
94 ashish 1117 
  def __init__(self, iprot, oprot=None):
3376 rajveer 1118 
    shop2020.thriftpy.generic.GenericService.Client.__init__(self, iprot, oprot)
94 ashish 1119 
 
1120 
  def createTransaction(self, transaction):
1121 
    """
1122 
    Parameters:
1123 
     - transaction
1124 
    """
1125 
    self.send_createTransaction(transaction)
132 ashish 1126 
    return self.recv_createTransaction()
94 ashish 1127 
 
1128 
  def send_createTransaction(self, transaction):
1129 
    self._oprot.writeMessageBegin('createTransaction', TMessageType.CALL, self._seqid)
1130 
    args = createTransaction_args()
1131 
    args.transaction = transaction
1132 
    args.write(self._oprot)
1133 
    self._oprot.writeMessageEnd()
1134 
    self._oprot.trans.flush()
1135 
 
1136 
  def recv_createTransaction(self, ):
1137 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1138 
    if mtype == TMessageType.EXCEPTION:
1139 
      x = TApplicationException()
1140 
      x.read(self._iprot)
1141 
      self._iprot.readMessageEnd()
1142 
      raise x
1143 
    result = createTransaction_result()
1144 
    result.read(self._iprot)
1145 
    self._iprot.readMessageEnd()
3431 rajveer 1146 
    if result.success is not None:
132 ashish 1147 
      return result.success
3431 rajveer 1148 
    if result.ex is not None:
94 ashish 1149 
      raise result.ex
132 ashish 1150 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "createTransaction failed: unknown result");
94 ashish 1151 
 
1152 
  def getTransaction(self, id):
1153 
    """
1154 
    Parameters:
1155 
     - id
1156 
    """
1157 
    self.send_getTransaction(id)
1158 
    return self.recv_getTransaction()
1159 
 
1160 
  def send_getTransaction(self, id):
1161 
    self._oprot.writeMessageBegin('getTransaction', TMessageType.CALL, self._seqid)
1162 
    args = getTransaction_args()
1163 
    args.id = id
1164 
    args.write(self._oprot)
1165 
    self._oprot.writeMessageEnd()
1166 
    self._oprot.trans.flush()
1167 
 
1168 
  def recv_getTransaction(self, ):
1169 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1170 
    if mtype == TMessageType.EXCEPTION:
1171 
      x = TApplicationException()
1172 
      x.read(self._iprot)
1173 
      self._iprot.readMessageEnd()
1174 
      raise x
1175 
    result = getTransaction_result()
1176 
    result.read(self._iprot)
1177 
    self._iprot.readMessageEnd()
3431 rajveer 1178 
    if result.success is not None:
94 ashish 1179 
      return result.success
3431 rajveer 1180 
    if result.ex is not None:
94 ashish 1181 
      raise result.ex
1182 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getTransaction failed: unknown result");
1183 
 
1184 
  def getTransactionsForCustomer(self, customerId, from_date, to_date, status):
1185 
    """
1186 
    Parameters:
1187 
     - customerId
1188 
     - from_date
1189 
     - to_date
1190 
     - status
1191 
    """
1192 
    self.send_getTransactionsForCustomer(customerId, from_date, to_date, status)
1193 
    return self.recv_getTransactionsForCustomer()
1194 
 
1195 
  def send_getTransactionsForCustomer(self, customerId, from_date, to_date, status):
1196 
    self._oprot.writeMessageBegin('getTransactionsForCustomer', TMessageType.CALL, self._seqid)
1197 
    args = getTransactionsForCustomer_args()
1198 
    args.customerId = customerId
1199 
    args.from_date = from_date
1200 
    args.to_date = to_date
1201 
    args.status = status
1202 
    args.write(self._oprot)
1203 
    self._oprot.writeMessageEnd()
1204 
    self._oprot.trans.flush()
1205 
 
1206 
  def recv_getTransactionsForCustomer(self, ):
1207 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1208 
    if mtype == TMessageType.EXCEPTION:
1209 
      x = TApplicationException()
1210 
      x.read(self._iprot)
1211 
      self._iprot.readMessageEnd()
1212 
      raise x
1213 
    result = getTransactionsForCustomer_result()
1214 
    result.read(self._iprot)
1215 
    self._iprot.readMessageEnd()
3431 rajveer 1216 
    if result.success is not None:
94 ashish 1217 
      return result.success
3431 rajveer 1218 
    if result.ex is not None:
94 ashish 1219 
      raise result.ex
1220 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getTransactionsForCustomer failed: unknown result");
1221 
 
132 ashish 1222 
  def getTransactionsForShoppingCartId(self, shoppingCartId):
1223 
    """
1224 
    Parameters:
1225 
     - shoppingCartId
1226 
    """
1227 
    self.send_getTransactionsForShoppingCartId(shoppingCartId)
1228 
    return self.recv_getTransactionsForShoppingCartId()
1229 
 
1230 
  def send_getTransactionsForShoppingCartId(self, shoppingCartId):
1231 
    self._oprot.writeMessageBegin('getTransactionsForShoppingCartId', TMessageType.CALL, self._seqid)
1232 
    args = getTransactionsForShoppingCartId_args()
1233 
    args.shoppingCartId = shoppingCartId
1234 
    args.write(self._oprot)
1235 
    self._oprot.writeMessageEnd()
1236 
    self._oprot.trans.flush()
1237 
 
1238 
  def recv_getTransactionsForShoppingCartId(self, ):
1239 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1240 
    if mtype == TMessageType.EXCEPTION:
1241 
      x = TApplicationException()
1242 
      x.read(self._iprot)
1243 
      self._iprot.readMessageEnd()
1244 
      raise x
1245 
    result = getTransactionsForShoppingCartId_result()
1246 
    result.read(self._iprot)
1247 
    self._iprot.readMessageEnd()
3431 rajveer 1248 
    if result.success is not None:
132 ashish 1249 
      return result.success
3431 rajveer 1250 
    if result.ex is not None:
132 ashish 1251 
      raise result.ex
1252 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getTransactionsForShoppingCartId failed: unknown result");
1253 
 
94 ashish 1254 
  def getTransactionStatus(self, transactionId):
1255 
    """
1256 
    Parameters:
1257 
     - transactionId
1258 
    """
1259 
    self.send_getTransactionStatus(transactionId)
1260 
    return self.recv_getTransactionStatus()
1261 
 
1262 
  def send_getTransactionStatus(self, transactionId):
1263 
    self._oprot.writeMessageBegin('getTransactionStatus', TMessageType.CALL, self._seqid)
1264 
    args = getTransactionStatus_args()
1265 
    args.transactionId = transactionId
1266 
    args.write(self._oprot)
1267 
    self._oprot.writeMessageEnd()
1268 
    self._oprot.trans.flush()
1269 
 
1270 
  def recv_getTransactionStatus(self, ):
1271 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1272 
    if mtype == TMessageType.EXCEPTION:
1273 
      x = TApplicationException()
1274 
      x.read(self._iprot)
1275 
      self._iprot.readMessageEnd()
1276 
      raise x
1277 
    result = getTransactionStatus_result()
1278 
    result.read(self._iprot)
1279 
    self._iprot.readMessageEnd()
3431 rajveer 1280 
    if result.success is not None:
94 ashish 1281 
      return result.success
3431 rajveer 1282 
    if result.ex is not None:
94 ashish 1283 
      raise result.ex
1284 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getTransactionStatus failed: unknown result");
1285 
 
1286 
  def changeTransactionStatus(self, transactionId, status, description):
1287 
    """
1288 
    Parameters:
1289 
     - transactionId
1290 
     - status
1291 
     - description
1292 
    """
1293 
    self.send_changeTransactionStatus(transactionId, status, description)
1294 
    return self.recv_changeTransactionStatus()
1295 
 
1296 
  def send_changeTransactionStatus(self, transactionId, status, description):
1297 
    self._oprot.writeMessageBegin('changeTransactionStatus', TMessageType.CALL, self._seqid)
1298 
    args = changeTransactionStatus_args()
1299 
    args.transactionId = transactionId
1300 
    args.status = status
1301 
    args.description = description
1302 
    args.write(self._oprot)
1303 
    self._oprot.writeMessageEnd()
1304 
    self._oprot.trans.flush()
1305 
 
1306 
  def recv_changeTransactionStatus(self, ):
1307 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1308 
    if mtype == TMessageType.EXCEPTION:
1309 
      x = TApplicationException()
1310 
      x.read(self._iprot)
1311 
      self._iprot.readMessageEnd()
1312 
      raise x
1313 
    result = changeTransactionStatus_result()
1314 
    result.read(self._iprot)
1315 
    self._iprot.readMessageEnd()
3431 rajveer 1316 
    if result.success is not None:
94 ashish 1317 
      return result.success
3431 rajveer 1318 
    if result.ex is not None:
94 ashish 1319 
      raise result.ex
1320 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "changeTransactionStatus failed: unknown result");
1321 
 
1398 varun.gupt 1322 
  def enqueueTransactionInfoEmail(self, transactionId):
1382 varun.gupt 1323 
    """
1324 
    Parameters:
1325 
     - transactionId
1326 
    """
1398 varun.gupt 1327 
    self.send_enqueueTransactionInfoEmail(transactionId)
1328 
    return self.recv_enqueueTransactionInfoEmail()
1382 varun.gupt 1329 
 
1398 varun.gupt 1330 
  def send_enqueueTransactionInfoEmail(self, transactionId):
1331 
    self._oprot.writeMessageBegin('enqueueTransactionInfoEmail', TMessageType.CALL, self._seqid)
1332 
    args = enqueueTransactionInfoEmail_args()
1382 varun.gupt 1333 
    args.transactionId = transactionId
1334 
    args.write(self._oprot)
1335 
    self._oprot.writeMessageEnd()
1336 
    self._oprot.trans.flush()
1337 
 
1398 varun.gupt 1338 
  def recv_enqueueTransactionInfoEmail(self, ):
1382 varun.gupt 1339 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1340 
    if mtype == TMessageType.EXCEPTION:
1341 
      x = TApplicationException()
1342 
      x.read(self._iprot)
1343 
      self._iprot.readMessageEnd()
1344 
      raise x
1398 varun.gupt 1345 
    result = enqueueTransactionInfoEmail_result()
1382 varun.gupt 1346 
    result.read(self._iprot)
1347 
    self._iprot.readMessageEnd()
3431 rajveer 1348 
    if result.success is not None:
1382 varun.gupt 1349 
      return result.success
3431 rajveer 1350 
    if result.ex is not None:
1382 varun.gupt 1351 
      raise result.ex
1398 varun.gupt 1352 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "enqueueTransactionInfoEmail failed: unknown result");
1382 varun.gupt 1353 
 
4801 anupam.sin 1354 
  def getAllOrders(self, statuses, from_date, to_date, warehouse_id):
94 ashish 1355 
    """
1356 
    Parameters:
4801 anupam.sin 1357 
     - statuses
483 rajveer 1358 
     - from_date
1359 
     - to_date
1360 
     - warehouse_id
94 ashish 1361 
    """
4801 anupam.sin 1362 
    self.send_getAllOrders(statuses, from_date, to_date, warehouse_id)
483 rajveer 1363 
    return self.recv_getAllOrders()
94 ashish 1364 
 
4801 anupam.sin 1365 
  def send_getAllOrders(self, statuses, from_date, to_date, warehouse_id):
483 rajveer 1366 
    self._oprot.writeMessageBegin('getAllOrders', TMessageType.CALL, self._seqid)
1367 
    args = getAllOrders_args()
4801 anupam.sin 1368 
    args.statuses = statuses
483 rajveer 1369 
    args.from_date = from_date
1370 
    args.to_date = to_date
1371 
    args.warehouse_id = warehouse_id
94 ashish 1372 
    args.write(self._oprot)
1373 
    self._oprot.writeMessageEnd()
1374 
    self._oprot.trans.flush()
1375 
 
483 rajveer 1376 
  def recv_getAllOrders(self, ):
94 ashish 1377 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1378 
    if mtype == TMessageType.EXCEPTION:
1379 
      x = TApplicationException()
1380 
      x.read(self._iprot)
1381 
      self._iprot.readMessageEnd()
1382 
      raise x
483 rajveer 1383 
    result = getAllOrders_result()
94 ashish 1384 
    result.read(self._iprot)
1385 
    self._iprot.readMessageEnd()
3431 rajveer 1386 
    if result.success is not None:
94 ashish 1387 
      return result.success
3431 rajveer 1388 
    if result.ex is not None:
94 ashish 1389 
      raise result.ex
483 rajveer 1390 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAllOrders failed: unknown result");
94 ashish 1391 
 
4133 chandransh 1392 
  def getOrdersInBatch(self, statuses, offset, limit, warehouse_id):
1393 
    """
1394 
    Returns at most 'limit' orders with the given statuses for the given warehouse starting from the given offset.
1395 
    Pass the status as null and the limit as 0 to ignore them.
1396 
 
1397 
    Parameters:
1398 
     - statuses
1399 
     - offset
1400 
     - limit
1401 
     - warehouse_id
1402 
    """
1403 
    self.send_getOrdersInBatch(statuses, offset, limit, warehouse_id)
1404 
    return self.recv_getOrdersInBatch()
1405 
 
1406 
  def send_getOrdersInBatch(self, statuses, offset, limit, warehouse_id):
1407 
    self._oprot.writeMessageBegin('getOrdersInBatch', TMessageType.CALL, self._seqid)
1408 
    args = getOrdersInBatch_args()
1409 
    args.statuses = statuses
1410 
    args.offset = offset
1411 
    args.limit = limit
1412 
    args.warehouse_id = warehouse_id
1413 
    args.write(self._oprot)
1414 
    self._oprot.writeMessageEnd()
1415 
    self._oprot.trans.flush()
1416 
 
1417 
  def recv_getOrdersInBatch(self, ):
1418 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1419 
    if mtype == TMessageType.EXCEPTION:
1420 
      x = TApplicationException()
1421 
      x.read(self._iprot)
1422 
      self._iprot.readMessageEnd()
1423 
      raise x
1424 
    result = getOrdersInBatch_result()
1425 
    result.read(self._iprot)
1426 
    self._iprot.readMessageEnd()
1427 
    if result.success is not None:
1428 
      return result.success
1429 
    if result.ex is not None:
1430 
      raise result.ex
1431 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getOrdersInBatch failed: unknown result");
1432 
 
1433 
  def getOrderCount(self, statuses, warehouseId):
1434 
    """
1435 
    Returns the count of orders with the given statuses assigned to the given warehouse.
1436 
 
1437 
    Parameters:
1438 
     - statuses
1439 
     - warehouseId
1440 
    """
1441 
    self.send_getOrderCount(statuses, warehouseId)
1442 
    return self.recv_getOrderCount()
1443 
 
1444 
  def send_getOrderCount(self, statuses, warehouseId):
1445 
    self._oprot.writeMessageBegin('getOrderCount', TMessageType.CALL, self._seqid)
1446 
    args = getOrderCount_args()
1447 
    args.statuses = statuses
1448 
    args.warehouseId = warehouseId
1449 
    args.write(self._oprot)
1450 
    self._oprot.writeMessageEnd()
1451 
    self._oprot.trans.flush()
1452 
 
1453 
  def recv_getOrderCount(self, ):
1454 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1455 
    if mtype == TMessageType.EXCEPTION:
1456 
      x = TApplicationException()
1457 
      x.read(self._iprot)
1458 
      self._iprot.readMessageEnd()
1459 
      raise x
1460 
    result = getOrderCount_result()
1461 
    result.read(self._iprot)
1462 
    self._iprot.readMessageEnd()
1463 
    if result.success is not None:
1464 
      return result.success
1465 
    if result.ex is not None:
1466 
      raise result.ex
1467 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getOrderCount failed: unknown result");
1468 
 
999 varun.gupt 1469 
  def getOrdersByBillingDate(self, status, start_billing_date, end_billing_date, warehouse_id):
1470 
    """
1132 chandransh 1471 
    Returns orders within a range of their billing dates
3431 rajveer 1472 
 
999 varun.gupt 1473 
    Parameters:
1474 
     - status
1475 
     - start_billing_date
1476 
     - end_billing_date
1477 
     - warehouse_id
1478 
    """
1479 
    self.send_getOrdersByBillingDate(status, start_billing_date, end_billing_date, warehouse_id)
1480 
    return self.recv_getOrdersByBillingDate()
1481 
 
1482 
  def send_getOrdersByBillingDate(self, status, start_billing_date, end_billing_date, warehouse_id):
1483 
    self._oprot.writeMessageBegin('getOrdersByBillingDate', TMessageType.CALL, self._seqid)
1484 
    args = getOrdersByBillingDate_args()
1485 
    args.status = status
1486 
    args.start_billing_date = start_billing_date
1487 
    args.end_billing_date = end_billing_date
1488 
    args.warehouse_id = warehouse_id
1489 
    args.write(self._oprot)
1490 
    self._oprot.writeMessageEnd()
1491 
    self._oprot.trans.flush()
1492 
 
1493 
  def recv_getOrdersByBillingDate(self, ):
1494 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1495 
    if mtype == TMessageType.EXCEPTION:
1496 
      x = TApplicationException()
1497 
      x.read(self._iprot)
1498 
      self._iprot.readMessageEnd()
1499 
      raise x
1500 
    result = getOrdersByBillingDate_result()
1501 
    result.read(self._iprot)
1502 
    self._iprot.readMessageEnd()
3431 rajveer 1503 
    if result.success is not None:
999 varun.gupt 1504 
      return result.success
3431 rajveer 1505 
    if result.ex is not None:
999 varun.gupt 1506 
      raise result.ex
1507 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getOrdersByBillingDate failed: unknown result");
1508 
 
3451 chandransh 1509 
  def getOrdersByShippingDate(self, fromShippingDate, toShippingDate, providerId, warehouseId, cod):
3427 chandransh 1510 
    """
1511 
    Returns orders for a particular provider and warehouse which were shipped between the given dates.
3451 chandransh 1512 
    Returned orders comprise of COD orders if cod parameter is true. It comprises of prepaid orders otherwise.
1513 
    Pass providerId and warehouseId as -1 to ignore both these parameters.
3431 rajveer 1514 
 
3427 chandransh 1515 
    Parameters:
1516 
     - fromShippingDate
1517 
     - toShippingDate
1518 
     - providerId
1519 
     - warehouseId
3451 chandransh 1520 
     - cod
3427 chandransh 1521 
    """
3451 chandransh 1522 
    self.send_getOrdersByShippingDate(fromShippingDate, toShippingDate, providerId, warehouseId, cod)
3427 chandransh 1523 
    return self.recv_getOrdersByShippingDate()
1524 
 
3451 chandransh 1525 
  def send_getOrdersByShippingDate(self, fromShippingDate, toShippingDate, providerId, warehouseId, cod):
3427 chandransh 1526 
    self._oprot.writeMessageBegin('getOrdersByShippingDate', TMessageType.CALL, self._seqid)
1527 
    args = getOrdersByShippingDate_args()
1528 
    args.fromShippingDate = fromShippingDate
1529 
    args.toShippingDate = toShippingDate
1530 
    args.providerId = providerId
1531 
    args.warehouseId = warehouseId
3451 chandransh 1532 
    args.cod = cod
3427 chandransh 1533 
    args.write(self._oprot)
1534 
    self._oprot.writeMessageEnd()
1535 
    self._oprot.trans.flush()
1536 
 
1537 
  def recv_getOrdersByShippingDate(self, ):
1538 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1539 
    if mtype == TMessageType.EXCEPTION:
1540 
      x = TApplicationException()
1541 
      x.read(self._iprot)
1542 
      self._iprot.readMessageEnd()
1543 
      raise x
1544 
    result = getOrdersByShippingDate_result()
1545 
    result.read(self._iprot)
1546 
    self._iprot.readMessageEnd()
3431 rajveer 1547 
    if result.success is not None:
3427 chandransh 1548 
      return result.success
3431 rajveer 1549 
    if result.ex is not None:
3427 chandransh 1550 
      raise result.ex
1551 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getOrdersByShippingDate failed: unknown result");
1552 
 
1382 varun.gupt 1553 
  def getReturnableOrdersForCustomer(self, customer_id, limit):
1554 
    """
1555 
    Returns order ids for orders which can be returned
3431 rajveer 1556 
 
1382 varun.gupt 1557 
    Parameters:
1558 
     - customer_id
1559 
     - limit
1560 
    """
1561 
    self.send_getReturnableOrdersForCustomer(customer_id, limit)
1562 
    return self.recv_getReturnableOrdersForCustomer()
1563 
 
1564 
  def send_getReturnableOrdersForCustomer(self, customer_id, limit):
1565 
    self._oprot.writeMessageBegin('getReturnableOrdersForCustomer', TMessageType.CALL, self._seqid)
1566 
    args = getReturnableOrdersForCustomer_args()
1567 
    args.customer_id = customer_id
1568 
    args.limit = limit
1569 
    args.write(self._oprot)
1570 
    self._oprot.writeMessageEnd()
1571 
    self._oprot.trans.flush()
1572 
 
1573 
  def recv_getReturnableOrdersForCustomer(self, ):
1574 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1575 
    if mtype == TMessageType.EXCEPTION:
1576 
      x = TApplicationException()
1577 
      x.read(self._iprot)
1578 
      self._iprot.readMessageEnd()
1579 
      raise x
1580 
    result = getReturnableOrdersForCustomer_result()
1581 
    result.read(self._iprot)
1582 
    self._iprot.readMessageEnd()
3431 rajveer 1583 
    if result.success is not None:
1382 varun.gupt 1584 
      return result.success
3431 rajveer 1585 
    if result.ex is not None:
1382 varun.gupt 1586 
      raise result.ex
1587 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getReturnableOrdersForCustomer failed: unknown result");
1588 
 
1589 
  def getCancellableOrdersForCustomer(self, customer_id, limit):
1590 
    """
1591 
    Returns order ids for orders which can be cancelled
3431 rajveer 1592 
 
1382 varun.gupt 1593 
    Parameters:
1594 
     - customer_id
1595 
     - limit
1596 
    """
1597 
    self.send_getCancellableOrdersForCustomer(customer_id, limit)
1598 
    return self.recv_getCancellableOrdersForCustomer()
1599 
 
1600 
  def send_getCancellableOrdersForCustomer(self, customer_id, limit):
1601 
    self._oprot.writeMessageBegin('getCancellableOrdersForCustomer', TMessageType.CALL, self._seqid)
1602 
    args = getCancellableOrdersForCustomer_args()
1603 
    args.customer_id = customer_id
1604 
    args.limit = limit
1605 
    args.write(self._oprot)
1606 
    self._oprot.writeMessageEnd()
1607 
    self._oprot.trans.flush()
1608 
 
1609 
  def recv_getCancellableOrdersForCustomer(self, ):
1610 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1611 
    if mtype == TMessageType.EXCEPTION:
1612 
      x = TApplicationException()
1613 
      x.read(self._iprot)
1614 
      self._iprot.readMessageEnd()
1615 
      raise x
1616 
    result = getCancellableOrdersForCustomer_result()
1617 
    result.read(self._iprot)
1618 
    self._iprot.readMessageEnd()
3431 rajveer 1619 
    if result.success is not None:
1382 varun.gupt 1620 
      return result.success
3431 rajveer 1621 
    if result.ex is not None:
1382 varun.gupt 1622 
      raise result.ex
1623 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getCancellableOrdersForCustomer failed: unknown result");
1624 
 
483 rajveer 1625 
  def changeOrderStatus(self, orderId, status, description):
94 ashish 1626 
    """
1627 
    Parameters:
483 rajveer 1628 
     - orderId
1629 
     - status
1630 
     - description
94 ashish 1631 
    """
483 rajveer 1632 
    self.send_changeOrderStatus(orderId, status, description)
1633 
    return self.recv_changeOrderStatus()
94 ashish 1634 
 
483 rajveer 1635 
  def send_changeOrderStatus(self, orderId, status, description):
1636 
    self._oprot.writeMessageBegin('changeOrderStatus', TMessageType.CALL, self._seqid)
1637 
    args = changeOrderStatus_args()
1638 
    args.orderId = orderId
1639 
    args.status = status
1640 
    args.description = description
94 ashish 1641 
    args.write(self._oprot)
1642 
    self._oprot.writeMessageEnd()
1643 
    self._oprot.trans.flush()
1644 
 
483 rajveer 1645 
  def recv_changeOrderStatus(self, ):
94 ashish 1646 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1647 
    if mtype == TMessageType.EXCEPTION:
1648 
      x = TApplicationException()
1649 
      x.read(self._iprot)
1650 
      self._iprot.readMessageEnd()
1651 
      raise x
483 rajveer 1652 
    result = changeOrderStatus_result()
94 ashish 1653 
    result.read(self._iprot)
1654 
    self._iprot.readMessageEnd()
3431 rajveer 1655 
    if result.success is not None:
94 ashish 1656 
      return result.success
3431 rajveer 1657 
    if result.ex is not None:
94 ashish 1658 
      raise result.ex
483 rajveer 1659 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "changeOrderStatus failed: unknown result");
94 ashish 1660 
 
1528 ankur.sing 1661 
  def getOrdersForTransaction(self, transactionId, customerId):
94 ashish 1662 
    """
1528 ankur.sing 1663 
    Returns list of orders for given transaction Id. Also filters based on customer Id so that
1664 
    only user who owns the transaction can view its order details.
3431 rajveer 1665 
 
94 ashish 1666 
    Parameters:
1667 
     - transactionId
1528 ankur.sing 1668 
     - customerId
94 ashish 1669 
    """
1528 ankur.sing 1670 
    self.send_getOrdersForTransaction(transactionId, customerId)
483 rajveer 1671 
    return self.recv_getOrdersForTransaction()
94 ashish 1672 
 
1528 ankur.sing 1673 
  def send_getOrdersForTransaction(self, transactionId, customerId):
483 rajveer 1674 
    self._oprot.writeMessageBegin('getOrdersForTransaction', TMessageType.CALL, self._seqid)
1675 
    args = getOrdersForTransaction_args()
94 ashish 1676 
    args.transactionId = transactionId
1528 ankur.sing 1677 
    args.customerId = customerId
94 ashish 1678 
    args.write(self._oprot)
1679 
    self._oprot.writeMessageEnd()
1680 
    self._oprot.trans.flush()
1681 
 
483 rajveer 1682 
  def recv_getOrdersForTransaction(self, ):
94 ashish 1683 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1684 
    if mtype == TMessageType.EXCEPTION:
1685 
      x = TApplicationException()
1686 
      x.read(self._iprot)
1687 
      self._iprot.readMessageEnd()
1688 
      raise x
483 rajveer 1689 
    result = getOrdersForTransaction_result()
94 ashish 1690 
    result.read(self._iprot)
1691 
    self._iprot.readMessageEnd()
3431 rajveer 1692 
    if result.success is not None:
94 ashish 1693 
      return result.success
3431 rajveer 1694 
    if result.ex is not None:
94 ashish 1695 
      raise result.ex
483 rajveer 1696 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getOrdersForTransaction failed: unknown result");
94 ashish 1697 
 
3014 chandransh 1698 
  def getOrdersForCustomer(self, customerId, from_date, to_date, statuses):
94 ashish 1699 
    """
3014 chandransh 1700 
    Returns list of orders for the given customer created between the given dates and having the given statuses.
1701 
    Pass and empty list to ignore filtering on statuses.
3431 rajveer 1702 
 
94 ashish 1703 
    Parameters:
483 rajveer 1704 
     - customerId
1705 
     - from_date
1706 
     - to_date
3014 chandransh 1707 
     - statuses
94 ashish 1708 
    """
3014 chandransh 1709 
    self.send_getOrdersForCustomer(customerId, from_date, to_date, statuses)
483 rajveer 1710 
    return self.recv_getOrdersForCustomer()
94 ashish 1711 
 
3014 chandransh 1712 
  def send_getOrdersForCustomer(self, customerId, from_date, to_date, statuses):
483 rajveer 1713 
    self._oprot.writeMessageBegin('getOrdersForCustomer', TMessageType.CALL, self._seqid)
1714 
    args = getOrdersForCustomer_args()
1715 
    args.customerId = customerId
1716 
    args.from_date = from_date
1717 
    args.to_date = to_date
3014 chandransh 1718 
    args.statuses = statuses
94 ashish 1719 
    args.write(self._oprot)
1720 
    self._oprot.writeMessageEnd()
1721 
    self._oprot.trans.flush()
1722 
 
483 rajveer 1723 
  def recv_getOrdersForCustomer(self, ):
94 ashish 1724 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1725 
    if mtype == TMessageType.EXCEPTION:
1726 
      x = TApplicationException()
1727 
      x.read(self._iprot)
1728 
      self._iprot.readMessageEnd()
1729 
      raise x
483 rajveer 1730 
    result = getOrdersForCustomer_result()
94 ashish 1731 
    result.read(self._iprot)
1732 
    self._iprot.readMessageEnd()
3431 rajveer 1733 
    if result.success is not None:
94 ashish 1734 
      return result.success
3431 rajveer 1735 
    if result.ex is not None:
94 ashish 1736 
      raise result.ex
483 rajveer 1737 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getOrdersForCustomer failed: unknown result");
94 ashish 1738 
 
483 rajveer 1739 
  def createOrder(self, order):
94 ashish 1740 
    """
1741 
    Parameters:
483 rajveer 1742 
     - order
94 ashish 1743 
    """
483 rajveer 1744 
    self.send_createOrder(order)
1745 
    return self.recv_createOrder()
94 ashish 1746 
 
483 rajveer 1747 
  def send_createOrder(self, order):
1748 
    self._oprot.writeMessageBegin('createOrder', TMessageType.CALL, self._seqid)
1749 
    args = createOrder_args()
1750 
    args.order = order
94 ashish 1751 
    args.write(self._oprot)
1752 
    self._oprot.writeMessageEnd()
1753 
    self._oprot.trans.flush()
1754 
 
483 rajveer 1755 
  def recv_createOrder(self, ):
94 ashish 1756 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1757 
    if mtype == TMessageType.EXCEPTION:
1758 
      x = TApplicationException()
1759 
      x.read(self._iprot)
1760 
      self._iprot.readMessageEnd()
1761 
      raise x
483 rajveer 1762 
    result = createOrder_result()
94 ashish 1763 
    result.read(self._iprot)
1764 
    self._iprot.readMessageEnd()
3431 rajveer 1765 
    if result.success is not None:
94 ashish 1766 
      return result.success
3431 rajveer 1767 
    if result.ex is not None:
94 ashish 1768 
      raise result.ex
483 rajveer 1769 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "createOrder failed: unknown result");
94 ashish 1770 
 
483 rajveer 1771 
  def getOrder(self, id):
94 ashish 1772 
    """
1773 
    Parameters:
483 rajveer 1774 
     - id
94 ashish 1775 
    """
483 rajveer 1776 
    self.send_getOrder(id)
1777 
    return self.recv_getOrder()
94 ashish 1778 
 
483 rajveer 1779 
  def send_getOrder(self, id):
1780 
    self._oprot.writeMessageBegin('getOrder', TMessageType.CALL, self._seqid)
1781 
    args = getOrder_args()
1782 
    args.id = id
94 ashish 1783 
    args.write(self._oprot)
1784 
    self._oprot.writeMessageEnd()
1785 
    self._oprot.trans.flush()
1786 
 
483 rajveer 1787 
  def recv_getOrder(self, ):
94 ashish 1788 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1789 
    if mtype == TMessageType.EXCEPTION:
1790 
      x = TApplicationException()
1791 
      x.read(self._iprot)
1792 
      self._iprot.readMessageEnd()
1793 
      raise x
483 rajveer 1794 
    result = getOrder_result()
94 ashish 1795 
    result.read(self._iprot)
1796 
    self._iprot.readMessageEnd()
3431 rajveer 1797 
    if result.success is not None:
94 ashish 1798 
      return result.success
3431 rajveer 1799 
    if result.ex is not None:
94 ashish 1800 
      raise result.ex
483 rajveer 1801 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getOrder failed: unknown result");
94 ashish 1802 
 
483 rajveer 1803 
  def getLineItemsForOrder(self, orderId):
94 ashish 1804 
    """
1805 
    Parameters:
483 rajveer 1806 
     - orderId
94 ashish 1807 
    """
483 rajveer 1808 
    self.send_getLineItemsForOrder(orderId)
1809 
    return self.recv_getLineItemsForOrder()
94 ashish 1810 
 
483 rajveer 1811 
  def send_getLineItemsForOrder(self, orderId):
1812 
    self._oprot.writeMessageBegin('getLineItemsForOrder', TMessageType.CALL, self._seqid)
1813 
    args = getLineItemsForOrder_args()
1814 
    args.orderId = orderId
94 ashish 1815 
    args.write(self._oprot)
1816 
    self._oprot.writeMessageEnd()
1817 
    self._oprot.trans.flush()
1818 
 
483 rajveer 1819 
  def recv_getLineItemsForOrder(self, ):
94 ashish 1820 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1821 
    if mtype == TMessageType.EXCEPTION:
1822 
      x = TApplicationException()
1823 
      x.read(self._iprot)
1824 
      self._iprot.readMessageEnd()
1825 
      raise x
483 rajveer 1826 
    result = getLineItemsForOrder_result()
94 ashish 1827 
    result.read(self._iprot)
1828 
    self._iprot.readMessageEnd()
3431 rajveer 1829 
    if result.success is not None:
94 ashish 1830 
      return result.success
3431 rajveer 1831 
    if result.ex is not None:
94 ashish 1832 
      raise result.ex
483 rajveer 1833 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getLineItemsForOrder failed: unknown result");
94 ashish 1834 
 
4999 phani.kuma 1835 
  def getOrderList(self, order_ids):
1836 
    """
1837 
    Parameters:
1838 
     - order_ids
1839 
    """
1840 
    self.send_getOrderList(order_ids)
1841 
    return self.recv_getOrderList()
1842 
 
1843 
  def send_getOrderList(self, order_ids):
1844 
    self._oprot.writeMessageBegin('getOrderList', TMessageType.CALL, self._seqid)
1845 
    args = getOrderList_args()
1846 
    args.order_ids = order_ids
1847 
    args.write(self._oprot)
1848 
    self._oprot.writeMessageEnd()
1849 
    self._oprot.trans.flush()
1850 
 
1851 
  def recv_getOrderList(self, ):
1852 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1853 
    if mtype == TMessageType.EXCEPTION:
1854 
      x = TApplicationException()
1855 
      x.read(self._iprot)
1856 
      self._iprot.readMessageEnd()
1857 
      raise x
1858 
    result = getOrderList_result()
1859 
    result.read(self._iprot)
1860 
    self._iprot.readMessageEnd()
1861 
    if result.success is not None:
1862 
      return result.success
1863 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getOrderList failed: unknown result");
1864 
 
1528 ankur.sing 1865 
  def getOrderForCustomer(self, orderId, customerId):
1866 
    """
1867 
    Returns an order for the order Id. Also checks if the order belongs to the customer whose Id is passed.
1868 
    Throws exception if either order Id is invalid or order does not below to the customer whose Id is passed.
3431 rajveer 1869 
 
1528 ankur.sing 1870 
    Parameters:
1871 
     - orderId
1872 
     - customerId
1873 
    """
1874 
    self.send_getOrderForCustomer(orderId, customerId)
1875 
    return self.recv_getOrderForCustomer()
1876 
 
1877 
  def send_getOrderForCustomer(self, orderId, customerId):
1878 
    self._oprot.writeMessageBegin('getOrderForCustomer', TMessageType.CALL, self._seqid)
1879 
    args = getOrderForCustomer_args()
1880 
    args.orderId = orderId
1881 
    args.customerId = customerId
1882 
    args.write(self._oprot)
1883 
    self._oprot.writeMessageEnd()
1884 
    self._oprot.trans.flush()
1885 
 
1886 
  def recv_getOrderForCustomer(self, ):
1887 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1888 
    if mtype == TMessageType.EXCEPTION:
1889 
      x = TApplicationException()
1890 
      x.read(self._iprot)
1891 
      self._iprot.readMessageEnd()
1892 
      raise x
1893 
    result = getOrderForCustomer_result()
1894 
    result.read(self._iprot)
1895 
    self._iprot.readMessageEnd()
3431 rajveer 1896 
    if result.success is not None:
1528 ankur.sing 1897 
      return result.success
3431 rajveer 1898 
    if result.ex is not None:
1528 ankur.sing 1899 
      raise result.ex
1900 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getOrderForCustomer failed: unknown result");
1901 
 
4444 rajveer 1902 
  def getAlerts(self, type, warehouseId, status, timestamp):
3064 chandransh 1903 
    """
1904 
    Parameters:
4394 rajveer 1905 
     - type
4444 rajveer 1906 
     - warehouseId
4394 rajveer 1907 
     - status
1908 
     - timestamp
3064 chandransh 1909 
    """
4444 rajveer 1910 
    self.send_getAlerts(type, warehouseId, status, timestamp)
3064 chandransh 1911 
    return self.recv_getAlerts()
1912 
 
4444 rajveer 1913 
  def send_getAlerts(self, type, warehouseId, status, timestamp):
3064 chandransh 1914 
    self._oprot.writeMessageBegin('getAlerts', TMessageType.CALL, self._seqid)
1915 
    args = getAlerts_args()
4394 rajveer 1916 
    args.type = type
4444 rajveer 1917 
    args.warehouseId = warehouseId
4394 rajveer 1918 
    args.status = status
1919 
    args.timestamp = timestamp
3064 chandransh 1920 
    args.write(self._oprot)
1921 
    self._oprot.writeMessageEnd()
1922 
    self._oprot.trans.flush()
1923 
 
1924 
  def recv_getAlerts(self, ):
1925 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1926 
    if mtype == TMessageType.EXCEPTION:
1927 
      x = TApplicationException()
1928 
      x.read(self._iprot)
1929 
      self._iprot.readMessageEnd()
1930 
      raise x
1931 
    result = getAlerts_result()
1932 
    result.read(self._iprot)
1933 
    self._iprot.readMessageEnd()
3431 rajveer 1934 
    if result.success is not None:
3064 chandransh 1935 
      return result.success
1936 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAlerts failed: unknown result");
1937 
 
4444 rajveer 1938 
  def addAlert(self, type, warehouseId, description):
3064 chandransh 1939 
    """
1940 
    Parameters:
1941 
     - type
4444 rajveer 1942 
     - warehouseId
4394 rajveer 1943 
     - description
3064 chandransh 1944 
    """
4444 rajveer 1945 
    self.send_addAlert(type, warehouseId, description)
4394 rajveer 1946 
    self.recv_addAlert()
3064 chandransh 1947 
 
4444 rajveer 1948 
  def send_addAlert(self, type, warehouseId, description):
4394 rajveer 1949 
    self._oprot.writeMessageBegin('addAlert', TMessageType.CALL, self._seqid)
1950 
    args = addAlert_args()
3064 chandransh 1951 
    args.type = type
4444 rajveer 1952 
    args.warehouseId = warehouseId
4394 rajveer 1953 
    args.description = description
3064 chandransh 1954 
    args.write(self._oprot)
1955 
    self._oprot.writeMessageEnd()
1956 
    self._oprot.trans.flush()
1957 
 
4394 rajveer 1958 
  def recv_addAlert(self, ):
3064 chandransh 1959 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1960 
    if mtype == TMessageType.EXCEPTION:
1961 
      x = TApplicationException()
1962 
      x.read(self._iprot)
1963 
      self._iprot.readMessageEnd()
1964 
      raise x
4394 rajveer 1965 
    result = addAlert_result()
3064 chandransh 1966 
    result.read(self._iprot)
1967 
    self._iprot.readMessageEnd()
1968 
    return
1969 
 
4444 rajveer 1970 
  def markAlertsAsSeen(self, warehouseId):
1971 
    """
1972 
    Parameters:
1973 
     - warehouseId
1974 
    """
1975 
    self.send_markAlertsAsSeen(warehouseId)
1976 
    self.recv_markAlertsAsSeen()
1977 
 
1978 
  def send_markAlertsAsSeen(self, warehouseId):
1979 
    self._oprot.writeMessageBegin('markAlertsAsSeen', TMessageType.CALL, self._seqid)
1980 
    args = markAlertsAsSeen_args()
1981 
    args.warehouseId = warehouseId
1982 
    args.write(self._oprot)
1983 
    self._oprot.writeMessageEnd()
1984 
    self._oprot.trans.flush()
1985 
 
1986 
  def recv_markAlertsAsSeen(self, ):
1987 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1988 
    if mtype == TMessageType.EXCEPTION:
1989 
      x = TApplicationException()
1990 
      x.read(self._iprot)
1991 
      self._iprot.readMessageEnd()
1992 
      raise x
1993 
    result = markAlertsAsSeen_result()
1994 
    result.read(self._iprot)
1995 
    self._iprot.readMessageEnd()
1996 
    return
1997 
 
3064 chandransh 1998 
  def getValidOrderCount(self, ):
1999 
    """
2000 
    Return the number of valid orders. (OrderStatus >= OrderStatus.SUBMITTED_FOR_PROCESSING)
2001 
    """
2002 
    self.send_getValidOrderCount()
2003 
    return self.recv_getValidOrderCount()
2004 
 
2005 
  def send_getValidOrderCount(self, ):
2006 
    self._oprot.writeMessageBegin('getValidOrderCount', TMessageType.CALL, self._seqid)
2007 
    args = getValidOrderCount_args()
2008 
    args.write(self._oprot)
2009 
    self._oprot.writeMessageEnd()
2010 
    self._oprot.trans.flush()
2011 
 
2012 
  def recv_getValidOrderCount(self, ):
2013 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2014 
    if mtype == TMessageType.EXCEPTION:
2015 
      x = TApplicationException()
2016 
      x.read(self._iprot)
2017 
      self._iprot.readMessageEnd()
2018 
      raise x
2019 
    result = getValidOrderCount_result()
2020 
    result.read(self._iprot)
2021 
    self._iprot.readMessageEnd()
3431 rajveer 2022 
    if result.success is not None:
3064 chandransh 2023 
      return result.success
2024 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getValidOrderCount failed: unknown result");
2025 
 
2026 
  def getNoOfCustomersWithSuccessfulTransaction(self, ):
2027 
    """
2028 
    Returns the number of distinct customers who have done successful transactions
2029 
    """
2030 
    self.send_getNoOfCustomersWithSuccessfulTransaction()
2031 
    return self.recv_getNoOfCustomersWithSuccessfulTransaction()
2032 
 
2033 
  def send_getNoOfCustomersWithSuccessfulTransaction(self, ):
2034 
    self._oprot.writeMessageBegin('getNoOfCustomersWithSuccessfulTransaction', TMessageType.CALL, self._seqid)
2035 
    args = getNoOfCustomersWithSuccessfulTransaction_args()
2036 
    args.write(self._oprot)
2037 
    self._oprot.writeMessageEnd()
2038 
    self._oprot.trans.flush()
2039 
 
2040 
  def recv_getNoOfCustomersWithSuccessfulTransaction(self, ):
2041 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2042 
    if mtype == TMessageType.EXCEPTION:
2043 
      x = TApplicationException()
2044 
      x.read(self._iprot)
2045 
      self._iprot.readMessageEnd()
2046 
      raise x
2047 
    result = getNoOfCustomersWithSuccessfulTransaction_result()
2048 
    result.read(self._iprot)
2049 
    self._iprot.readMessageEnd()
3431 rajveer 2050 
    if result.success is not None:
3064 chandransh 2051 
      return result.success
2052 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getNoOfCustomersWithSuccessfulTransaction failed: unknown result");
2053 
 
2054 
  def getValidOrdersAmountRange(self, ):
2055 
    """
2056 
    Returns the minimum and maximum amounts of a valid order. (OrderStatus >= OrderStatus.SUBMITTED_FOR_PROCESSING)
2057 
    List contains two values, first minimum amount and second maximum amount.
2058 
    """
2059 
    self.send_getValidOrdersAmountRange()
2060 
    return self.recv_getValidOrdersAmountRange()
2061 
 
2062 
  def send_getValidOrdersAmountRange(self, ):
2063 
    self._oprot.writeMessageBegin('getValidOrdersAmountRange', TMessageType.CALL, self._seqid)
2064 
    args = getValidOrdersAmountRange_args()
2065 
    args.write(self._oprot)
2066 
    self._oprot.writeMessageEnd()
2067 
    self._oprot.trans.flush()
2068 
 
2069 
  def recv_getValidOrdersAmountRange(self, ):
2070 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2071 
    if mtype == TMessageType.EXCEPTION:
2072 
      x = TApplicationException()
2073 
      x.read(self._iprot)
2074 
      self._iprot.readMessageEnd()
2075 
      raise x
2076 
    result = getValidOrdersAmountRange_result()
2077 
    result.read(self._iprot)
2078 
    self._iprot.readMessageEnd()
3431 rajveer 2079 
    if result.success is not None:
3064 chandransh 2080 
      return result.success
2081 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getValidOrdersAmountRange failed: unknown result");
2082 
 
2083 
  def getValidOrders(self, limit):
2084 
    """
2085 
    Returns list of Orders in descending order by Order creation date. List is restricted to limit Orders.
2086 
    If limit is passed as 0, then all valid Orders are returned.
3431 rajveer 2087 
 
3064 chandransh 2088 
    Parameters:
2089 
     - limit
2090 
    """
2091 
    self.send_getValidOrders(limit)
2092 
    return self.recv_getValidOrders()
2093 
 
2094 
  def send_getValidOrders(self, limit):
2095 
    self._oprot.writeMessageBegin('getValidOrders', TMessageType.CALL, self._seqid)
2096 
    args = getValidOrders_args()
2097 
    args.limit = limit
2098 
    args.write(self._oprot)
2099 
    self._oprot.writeMessageEnd()
2100 
    self._oprot.trans.flush()
2101 
 
2102 
  def recv_getValidOrders(self, ):
2103 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2104 
    if mtype == TMessageType.EXCEPTION:
2105 
      x = TApplicationException()
2106 
      x.read(self._iprot)
2107 
      self._iprot.readMessageEnd()
2108 
      raise x
2109 
    result = getValidOrders_result()
2110 
    result.read(self._iprot)
2111 
    self._iprot.readMessageEnd()
3431 rajveer 2112 
    if result.success is not None:
3064 chandransh 2113 
      return result.success
2114 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getValidOrders failed: unknown result");
2115 
 
1220 chandransh 2116 
  def batchOrders(self, warehouseId):
2117 
    """
2118 
    Create a batch of all the pending orders for the given warehouse.
2119 
    The returned list is orderd by created_timestamp.
2120 
    If there are no pending orders, an empty list is returned.
3431 rajveer 2121 
 
1220 chandransh 2122 
    Parameters:
2123 
     - warehouseId
2124 
    """
2125 
    self.send_batchOrders(warehouseId)
2126 
    return self.recv_batchOrders()
2127 
 
2128 
  def send_batchOrders(self, warehouseId):
2129 
    self._oprot.writeMessageBegin('batchOrders', TMessageType.CALL, self._seqid)
2130 
    args = batchOrders_args()
2131 
    args.warehouseId = warehouseId
2132 
    args.write(self._oprot)
2133 
    self._oprot.writeMessageEnd()
2134 
    self._oprot.trans.flush()
2135 
 
2136 
  def recv_batchOrders(self, ):
2137 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2138 
    if mtype == TMessageType.EXCEPTION:
2139 
      x = TApplicationException()
2140 
      x.read(self._iprot)
2141 
      self._iprot.readMessageEnd()
2142 
      raise x
2143 
    result = batchOrders_result()
2144 
    result.read(self._iprot)
2145 
    self._iprot.readMessageEnd()
3431 rajveer 2146 
    if result.success is not None:
1220 chandransh 2147 
      return result.success
3431 rajveer 2148 
    if result.ex is not None:
1220 chandransh 2149 
      raise result.ex
2150 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "batchOrders failed: unknown result");
2151 
 
1208 chandransh 2152 
  def markOrderAsOutOfStock(self, orderId):
2153 
    """
2154 
    Mark the given order as out of stock. Throws an exception if the order with the given Id couldn't be found.
3431 rajveer 2155 
 
1208 chandransh 2156 
    Parameters:
2157 
     - orderId
2158 
    """
2159 
    self.send_markOrderAsOutOfStock(orderId)
2160 
    return self.recv_markOrderAsOutOfStock()
2161 
 
2162 
  def send_markOrderAsOutOfStock(self, orderId):
2163 
    self._oprot.writeMessageBegin('markOrderAsOutOfStock', TMessageType.CALL, self._seqid)
2164 
    args = markOrderAsOutOfStock_args()
2165 
    args.orderId = orderId
2166 
    args.write(self._oprot)
2167 
    self._oprot.writeMessageEnd()
2168 
    self._oprot.trans.flush()
2169 
 
2170 
  def recv_markOrderAsOutOfStock(self, ):
2171 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2172 
    if mtype == TMessageType.EXCEPTION:
2173 
      x = TApplicationException()
2174 
      x.read(self._iprot)
2175 
      self._iprot.readMessageEnd()
2176 
      raise x
2177 
    result = markOrderAsOutOfStock_result()
2178 
    result.read(self._iprot)
2179 
    self._iprot.readMessageEnd()
3431 rajveer 2180 
    if result.success is not None:
1208 chandransh 2181 
      return result.success
3431 rajveer 2182 
    if result.ex is not None:
1208 chandransh 2183 
      raise result.ex
2184 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "markOrderAsOutOfStock failed: unknown result");
2185 
 
3064 chandransh 2186 
  def verifyOrder(self, orderId):
759 chandransh 2187 
    """
3064 chandransh 2188 
    Marks the given order as SUBMITTED_FOR_PROCESSING and updates the verified
2189 
    timestamp. It is intended to be used for COD orders but can be harmlessly
2190 
    used for all other orders as well.
2191 
    Throws an exception if no such order exists.
3431 rajveer 2192 
 
759 chandransh 2193 
    Parameters:
3064 chandransh 2194 
     - orderId
759 chandransh 2195 
    """
3064 chandransh 2196 
    self.send_verifyOrder(orderId)
2197 
    return self.recv_verifyOrder()
759 chandransh 2198 
 
3064 chandransh 2199 
  def send_verifyOrder(self, orderId):
2200 
    self._oprot.writeMessageBegin('verifyOrder', TMessageType.CALL, self._seqid)
2201 
    args = verifyOrder_args()
2202 
    args.orderId = orderId
759 chandransh 2203 
    args.write(self._oprot)
2204 
    self._oprot.writeMessageEnd()
2205 
    self._oprot.trans.flush()
2206 
 
3064 chandransh 2207 
  def recv_verifyOrder(self, ):
759 chandransh 2208 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2209 
    if mtype == TMessageType.EXCEPTION:
2210 
      x = TApplicationException()
2211 
      x.read(self._iprot)
2212 
      self._iprot.readMessageEnd()
2213 
      raise x
3064 chandransh 2214 
    result = verifyOrder_result()
759 chandransh 2215 
    result.read(self._iprot)
2216 
    self._iprot.readMessageEnd()
3431 rajveer 2217 
    if result.success is not None:
759 chandransh 2218 
      return result.success
3431 rajveer 2219 
    if result.ex is not None:
759 chandransh 2220 
      raise result.ex
3064 chandransh 2221 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "verifyOrder failed: unknown result");
759 chandransh 2222 
 
3064 chandransh 2223 
  def acceptOrder(self, orderId):
1113 chandransh 2224 
    """
3064 chandransh 2225 
    Marks the given order as ACCEPTED and updates the accepted timestamp. If the
2226 
    given order is not a COD order, it also captures the payment if the same has
2227 
    not been captured.
2228 
    Throws an exception if no such order exists.
3431 rajveer 2229 
 
1113 chandransh 2230 
    Parameters:
3064 chandransh 2231 
     - orderId
1113 chandransh 2232 
    """
3064 chandransh 2233 
    self.send_acceptOrder(orderId)
2234 
    return self.recv_acceptOrder()
1113 chandransh 2235 
 
3064 chandransh 2236 
  def send_acceptOrder(self, orderId):
2237 
    self._oprot.writeMessageBegin('acceptOrder', TMessageType.CALL, self._seqid)
2238 
    args = acceptOrder_args()
2239 
    args.orderId = orderId
1113 chandransh 2240 
    args.write(self._oprot)
2241 
    self._oprot.writeMessageEnd()
2242 
    self._oprot.trans.flush()
2243 
 
3064 chandransh 2244 
  def recv_acceptOrder(self, ):
1113 chandransh 2245 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2246 
    if mtype == TMessageType.EXCEPTION:
2247 
      x = TApplicationException()
2248 
      x.read(self._iprot)
2249 
      self._iprot.readMessageEnd()
2250 
      raise x
3064 chandransh 2251 
    result = acceptOrder_result()
1113 chandransh 2252 
    result.read(self._iprot)
2253 
    self._iprot.readMessageEnd()
3431 rajveer 2254 
    if result.success is not None:
1113 chandransh 2255 
      return result.success
3431 rajveer 2256 
    if result.ex is not None:
1113 chandransh 2257 
      raise result.ex
3064 chandransh 2258 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "acceptOrder failed: unknown result");
1113 chandransh 2259 
 
4763 rajveer 2260 
  def addBillingDetails(self, orderId, invoice_number, serialNumber, itemNumber, billed_by, jacketNumber, billingType, vendorId, authorize):
1132 chandransh 2261 
    """
3064 chandransh 2262 
    Add billing details such as the bill number and the biller to the Order.
4658 mandeep.dh 2263 
    Adds jacket number, item number and Serial no. to the order. Doesn't update
4283 anupam.sin 2264 
    the IMEI no. if a -1 is supplied.
2265 
    Also, it generates an invoice number for the order, marks the order as
2266 
    BILLED and sets the billing timestamp.
2267 
    Returns false if it doesn't find the order with the given ID.
3431 rajveer 2268 
 
1135 chandransh 2269 
    Parameters:
3064 chandransh 2270 
     - orderId
2271 
     - invoice_number
4658 mandeep.dh 2272 
     - serialNumber
4283 anupam.sin 2273 
     - itemNumber
3064 chandransh 2274 
     - billed_by
4264 rajveer 2275 
     - jacketNumber
4283 anupam.sin 2276 
     - billingType
2277 
     - vendorId
4763 rajveer 2278 
     - authorize
1135 chandransh 2279 
    """
4763 rajveer 2280 
    self.send_addBillingDetails(orderId, invoice_number, serialNumber, itemNumber, billed_by, jacketNumber, billingType, vendorId, authorize)
3064 chandransh 2281 
    return self.recv_addBillingDetails()
1135 chandransh 2282 
 
4763 rajveer 2283 
  def send_addBillingDetails(self, orderId, invoice_number, serialNumber, itemNumber, billed_by, jacketNumber, billingType, vendorId, authorize):
3064 chandransh 2284 
    self._oprot.writeMessageBegin('addBillingDetails', TMessageType.CALL, self._seqid)
2285 
    args = addBillingDetails_args()
2286 
    args.orderId = orderId
2287 
    args.invoice_number = invoice_number
4658 mandeep.dh 2288 
    args.serialNumber = serialNumber
4283 anupam.sin 2289 
    args.itemNumber = itemNumber
3064 chandransh 2290 
    args.billed_by = billed_by
4264 rajveer 2291 
    args.jacketNumber = jacketNumber
4283 anupam.sin 2292 
    args.billingType = billingType
2293 
    args.vendorId = vendorId
4763 rajveer 2294 
    args.authorize = authorize
1135 chandransh 2295 
    args.write(self._oprot)
2296 
    self._oprot.writeMessageEnd()
2297 
    self._oprot.trans.flush()
2298 
 
3064 chandransh 2299 
  def recv_addBillingDetails(self, ):
1135 chandransh 2300 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2301 
    if mtype == TMessageType.EXCEPTION:
2302 
      x = TApplicationException()
2303 
      x.read(self._iprot)
2304 
      self._iprot.readMessageEnd()
2305 
      raise x
3064 chandransh 2306 
    result = addBillingDetails_result()
1135 chandransh 2307 
    result.read(self._iprot)
2308 
    self._iprot.readMessageEnd()
3431 rajveer 2309 
    if result.success is not None:
3064 chandransh 2310 
      return result.success
3431 rajveer 2311 
    if result.ex is not None:
1135 chandransh 2312 
      raise result.ex
3064 chandransh 2313 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "addBillingDetails failed: unknown result");
1135 chandransh 2314 
 
4763 rajveer 2315 
  def addInvoiceNumber(self, orderId, invoiceNumber, color):
4579 rajveer 2316 
    """
2317 
    Add the invoice number to the order.
2318 
 
2319 
    Parameters:
2320 
     - orderId
2321 
     - invoiceNumber
4763 rajveer 2322 
     - color
4579 rajveer 2323 
    """
4763 rajveer 2324 
    self.send_addInvoiceNumber(orderId, invoiceNumber, color)
4579 rajveer 2325 
    self.recv_addInvoiceNumber()
2326 
 
4763 rajveer 2327 
  def send_addInvoiceNumber(self, orderId, invoiceNumber, color):
4579 rajveer 2328 
    self._oprot.writeMessageBegin('addInvoiceNumber', TMessageType.CALL, self._seqid)
2329 
    args = addInvoiceNumber_args()
2330 
    args.orderId = orderId
2331 
    args.invoiceNumber = invoiceNumber
4763 rajveer 2332 
    args.color = color
4579 rajveer 2333 
    args.write(self._oprot)
2334 
    self._oprot.writeMessageEnd()
2335 
    self._oprot.trans.flush()
2336 
 
2337 
  def recv_addInvoiceNumber(self, ):
2338 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2339 
    if mtype == TMessageType.EXCEPTION:
2340 
      x = TApplicationException()
2341 
      x.read(self._iprot)
2342 
      self._iprot.readMessageEnd()
2343 
      raise x
2344 
    result = addInvoiceNumber_result()
2345 
    result.read(self._iprot)
2346 
    self._iprot.readMessageEnd()
2347 
    if result.ex is not None:
2348 
      raise result.ex
2349 
    return
2350 
 
4910 phani.kuma 2351 
  def markOrdersAsShippedFromWarehouse(self, warehouseId, providerId, cod, orderIds):
1408 ankur.sing 2352 
    """
3064 chandransh 2353 
    Depending on the third parameter, marks either all prepaid or all cod orders BILLED by the
4910 phani.kuma 2354 
    given warehouse and were picked up by the given provider as SHIPPED_FROM_WH.
3431 rajveer 2355 
 
1408 ankur.sing 2356 
    Parameters:
3064 chandransh 2357 
     - warehouseId
1408 ankur.sing 2358 
     - providerId
3064 chandransh 2359 
     - cod
4910 phani.kuma 2360 
     - orderIds
1408 ankur.sing 2361 
    """
4910 phani.kuma 2362 
    self.send_markOrdersAsShippedFromWarehouse(warehouseId, providerId, cod, orderIds)
2363 
    return self.recv_markOrdersAsShippedFromWarehouse()
1408 ankur.sing 2364 
 
4910 phani.kuma 2365 
  def send_markOrdersAsShippedFromWarehouse(self, warehouseId, providerId, cod, orderIds):
2366 
    self._oprot.writeMessageBegin('markOrdersAsShippedFromWarehouse', TMessageType.CALL, self._seqid)
2367 
    args = markOrdersAsShippedFromWarehouse_args()
3064 chandransh 2368 
    args.warehouseId = warehouseId
1408 ankur.sing 2369 
    args.providerId = providerId
3064 chandransh 2370 
    args.cod = cod
4910 phani.kuma 2371 
    args.orderIds = orderIds
1408 ankur.sing 2372 
    args.write(self._oprot)
2373 
    self._oprot.writeMessageEnd()
2374 
    self._oprot.trans.flush()
2375 
 
4910 phani.kuma 2376 
  def recv_markOrdersAsShippedFromWarehouse(self, ):
1408 ankur.sing 2377 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2378 
    if mtype == TMessageType.EXCEPTION:
2379 
      x = TApplicationException()
2380 
      x.read(self._iprot)
2381 
      self._iprot.readMessageEnd()
2382 
      raise x
4910 phani.kuma 2383 
    result = markOrdersAsShippedFromWarehouse_result()
1408 ankur.sing 2384 
    result.read(self._iprot)
2385 
    self._iprot.readMessageEnd()
3431 rajveer 2386 
    if result.success is not None:
1408 ankur.sing 2387 
      return result.success
3431 rajveer 2388 
    if result.ex is not None:
3064 chandransh 2389 
      raise result.ex
4910 phani.kuma 2390 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "markOrdersAsShippedFromWarehouse failed: unknown result");
1408 ankur.sing 2391 
 
4910 phani.kuma 2392 
  def markOrdersAsPickedUp(self, providerId, pickupDetails):
4410 rajveer 2393 
    """
4910 phani.kuma 2394 
    Marks all SHIPPED_FROM_WH orders of the previous day for a provider as SHIPPED_TO_LOGISTICS.
2395 
    Raises an exception if we encounter report for an AWB number that we did not ship.
4410 rajveer 2396 
 
2397 
    Parameters:
2398 
     - providerId
4910 phani.kuma 2399 
     - pickupDetails
4410 rajveer 2400 
    """
4910 phani.kuma 2401 
    self.send_markOrdersAsPickedUp(providerId, pickupDetails)
2402 
    self.recv_markOrdersAsPickedUp()
4410 rajveer 2403 
 
4910 phani.kuma 2404 
  def send_markOrdersAsPickedUp(self, providerId, pickupDetails):
2405 
    self._oprot.writeMessageBegin('markOrdersAsPickedUp', TMessageType.CALL, self._seqid)
2406 
    args = markOrdersAsPickedUp_args()
4410 rajveer 2407 
    args.providerId = providerId
4910 phani.kuma 2408 
    args.pickupDetails = pickupDetails
4410 rajveer 2409 
    args.write(self._oprot)
2410 
    self._oprot.writeMessageEnd()
2411 
    self._oprot.trans.flush()
2412 
 
4910 phani.kuma 2413 
  def recv_markOrdersAsPickedUp(self, ):
4410 rajveer 2414 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2415 
    if mtype == TMessageType.EXCEPTION:
2416 
      x = TApplicationException()
2417 
      x.read(self._iprot)
2418 
      self._iprot.readMessageEnd()
2419 
      raise x
4910 phani.kuma 2420 
    result = markOrdersAsPickedUp_result()
4410 rajveer 2421 
    result.read(self._iprot)
2422 
    self._iprot.readMessageEnd()
2423 
    if result.ex is not None:
2424 
      raise result.ex
4910 phani.kuma 2425 
    return
4410 rajveer 2426 
 
4910 phani.kuma 2427 
  def getOrdersNotPickedUp(self, providerId):
94 ashish 2428 
    """
3064 chandransh 2429 
    Returns a list of orders that were shipped from warehouse but did not appear in the pick-up report.
3431 rajveer 2430 
 
94 ashish 2431 
    Parameters:
3064 chandransh 2432 
     - providerId
304 ashish 2433 
    """
4910 phani.kuma 2434 
    self.send_getOrdersNotPickedUp(providerId)
2435 
    return self.recv_getOrdersNotPickedUp()
94 ashish 2436 
 
4910 phani.kuma 2437 
  def send_getOrdersNotPickedUp(self, providerId):
2438 
    self._oprot.writeMessageBegin('getOrdersNotPickedUp', TMessageType.CALL, self._seqid)
2439 
    args = getOrdersNotPickedUp_args()
3064 chandransh 2440 
    args.providerId = providerId
304 ashish 2441 
    args.write(self._oprot)
2442 
    self._oprot.writeMessageEnd()
2443 
    self._oprot.trans.flush()
2444 
 
4910 phani.kuma 2445 
  def recv_getOrdersNotPickedUp(self, ):
304 ashish 2446 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2447 
    if mtype == TMessageType.EXCEPTION:
2448 
      x = TApplicationException()
2449 
      x.read(self._iprot)
2450 
      self._iprot.readMessageEnd()
2451 
      raise x
4910 phani.kuma 2452 
    result = getOrdersNotPickedUp_result()
304 ashish 2453 
    result.read(self._iprot)
2454 
    self._iprot.readMessageEnd()
3431 rajveer 2455 
    if result.success is not None:
304 ashish 2456 
      return result.success
4910 phani.kuma 2457 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getOrdersNotPickedUp failed: unknown result");
304 ashish 2458 
 
3064 chandransh 2459 
  def markOrdersAsDelivered(self, providerId, deliveredOrders):
304 ashish 2460 
    """
3064 chandransh 2461 
    Marks all orders with AWBs in the given map as delivered. Also sets the delivery timestamp and
2462 
    the name of the receiver.
2463 
    Raises an exception if we encounter report for an AWB number that we did not ship.
3431 rajveer 2464 
 
304 ashish 2465 
    Parameters:
3064 chandransh 2466 
     - providerId
2467 
     - deliveredOrders
304 ashish 2468 
    """
3064 chandransh 2469 
    self.send_markOrdersAsDelivered(providerId, deliveredOrders)
2470 
    self.recv_markOrdersAsDelivered()
304 ashish 2471 
 
3064 chandransh 2472 
  def send_markOrdersAsDelivered(self, providerId, deliveredOrders):
2473 
    self._oprot.writeMessageBegin('markOrdersAsDelivered', TMessageType.CALL, self._seqid)
2474 
    args = markOrdersAsDelivered_args()
2475 
    args.providerId = providerId
2476 
    args.deliveredOrders = deliveredOrders
304 ashish 2477 
    args.write(self._oprot)
2478 
    self._oprot.writeMessageEnd()
2479 
    self._oprot.trans.flush()
2480 
 
3064 chandransh 2481 
  def recv_markOrdersAsDelivered(self, ):
304 ashish 2482 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2483 
    if mtype == TMessageType.EXCEPTION:
2484 
      x = TApplicationException()
2485 
      x.read(self._iprot)
2486 
      self._iprot.readMessageEnd()
2487 
      raise x
3064 chandransh 2488 
    result = markOrdersAsDelivered_result()
304 ashish 2489 
    result.read(self._iprot)
2490 
    self._iprot.readMessageEnd()
3431 rajveer 2491 
    if result.ex is not None:
3064 chandransh 2492 
      raise result.ex
304 ashish 2493 
    return
2494 
 
4910 phani.kuma 2495 
  def markAsRTOrders(self, providerId, returnedOrders):
1596 ankur.sing 2496 
    """
4910 phani.kuma 2497 
    Mark all orders with AWBs in the given map as RTO. Also sets the delivery timestamp.
3064 chandransh 2498 
    Raises an exception if we encounter report for an AWB number that we did not ship.
3431 rajveer 2499 
 
3064 chandransh 2500 
    Parameters:
2501 
     - providerId
2502 
     - returnedOrders
1596 ankur.sing 2503 
    """
4910 phani.kuma 2504 
    self.send_markAsRTOrders(providerId, returnedOrders)
2505 
    self.recv_markAsRTOrders()
304 ashish 2506 
 
4910 phani.kuma 2507 
  def send_markAsRTOrders(self, providerId, returnedOrders):
2508 
    self._oprot.writeMessageBegin('markAsRTOrders', TMessageType.CALL, self._seqid)
2509 
    args = markAsRTOrders_args()
3064 chandransh 2510 
    args.providerId = providerId
2511 
    args.returnedOrders = returnedOrders
1596 ankur.sing 2512 
    args.write(self._oprot)
2513 
    self._oprot.writeMessageEnd()
2514 
    self._oprot.trans.flush()
2515 
 
4910 phani.kuma 2516 
  def recv_markAsRTOrders(self, ):
1596 ankur.sing 2517 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2518 
    if mtype == TMessageType.EXCEPTION:
2519 
      x = TApplicationException()
2520 
      x.read(self._iprot)
2521 
      self._iprot.readMessageEnd()
2522 
      raise x
4910 phani.kuma 2523 
    result = markAsRTOrders_result()
1596 ankur.sing 2524 
    result.read(self._iprot)
2525 
    self._iprot.readMessageEnd()
3431 rajveer 2526 
    if result.ex is not None:
3064 chandransh 2527 
      raise result.ex
2528 
    return
1596 ankur.sing 2529 
 
4910 phani.kuma 2530 
  def getRTOrders(self, providerId):
2531 
    """
2532 
    Returns a list of orders that were returned by courier.
2533 
 
2534 
    Parameters:
2535 
     - providerId
2536 
    """
2537 
    self.send_getRTOrders(providerId)
2538 
    return self.recv_getRTOrders()
2539 
 
2540 
  def send_getRTOrders(self, providerId):
2541 
    self._oprot.writeMessageBegin('getRTOrders', TMessageType.CALL, self._seqid)
2542 
    args = getRTOrders_args()
2543 
    args.providerId = providerId
2544 
    args.write(self._oprot)
2545 
    self._oprot.writeMessageEnd()
2546 
    self._oprot.trans.flush()
2547 
 
2548 
  def recv_getRTOrders(self, ):
2549 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2550 
    if mtype == TMessageType.EXCEPTION:
2551 
      x = TApplicationException()
2552 
      x.read(self._iprot)
2553 
      self._iprot.readMessageEnd()
2554 
      raise x
2555 
    result = getRTOrders_result()
2556 
    result.read(self._iprot)
2557 
    self._iprot.readMessageEnd()
2558 
    if result.success is not None:
2559 
      return result.success
2560 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getRTOrders failed: unknown result");
2561 
 
3064 chandransh 2562 
  def updateNonDeliveryReason(self, providerId, undeliveredOrders):
1627 ankur.sing 2563 
    """
3064 chandransh 2564 
    Update the status description of orders whose AWB numbers are keys of the Map.
3431 rajveer 2565 
 
3064 chandransh 2566 
    Parameters:
2567 
     - providerId
2568 
     - undeliveredOrders
1627 ankur.sing 2569 
    """
3064 chandransh 2570 
    self.send_updateNonDeliveryReason(providerId, undeliveredOrders)
4910 phani.kuma 2571 
    self.recv_updateNonDeliveryReason()
1596 ankur.sing 2572 
 
3064 chandransh 2573 
  def send_updateNonDeliveryReason(self, providerId, undeliveredOrders):
2574 
    self._oprot.writeMessageBegin('updateNonDeliveryReason', TMessageType.CALL, self._seqid)
2575 
    args = updateNonDeliveryReason_args()
2576 
    args.providerId = providerId
2577 
    args.undeliveredOrders = undeliveredOrders
1627 ankur.sing 2578 
    args.write(self._oprot)
2579 
    self._oprot.writeMessageEnd()
2580 
    self._oprot.trans.flush()
2581 
 
3064 chandransh 2582 
  def recv_updateNonDeliveryReason(self, ):
1627 ankur.sing 2583 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2584 
    if mtype == TMessageType.EXCEPTION:
2585 
      x = TApplicationException()
2586 
      x.read(self._iprot)
2587 
      self._iprot.readMessageEnd()
2588 
      raise x
3064 chandransh 2589 
    result = updateNonDeliveryReason_result()
1627 ankur.sing 2590 
    result.read(self._iprot)
2591 
    self._iprot.readMessageEnd()
4910 phani.kuma 2592 
    if result.ex is not None:
2593 
      raise result.ex
2594 
    return
2595 
 
2596 
  def getNonDeliveredOrdersbyCourier(self, providerId):
2597 
    """
2598 
    Returns a list of orders that were picked up or shipped four days ago but did not get delivered.
2599 
 
2600 
    Parameters:
2601 
     - providerId
2602 
    """
2603 
    self.send_getNonDeliveredOrdersbyCourier(providerId)
2604 
    return self.recv_getNonDeliveredOrdersbyCourier()
2605 
 
2606 
  def send_getNonDeliveredOrdersbyCourier(self, providerId):
2607 
    self._oprot.writeMessageBegin('getNonDeliveredOrdersbyCourier', TMessageType.CALL, self._seqid)
2608 
    args = getNonDeliveredOrdersbyCourier_args()
2609 
    args.providerId = providerId
2610 
    args.write(self._oprot)
2611 
    self._oprot.writeMessageEnd()
2612 
    self._oprot.trans.flush()
2613 
 
2614 
  def recv_getNonDeliveredOrdersbyCourier(self, ):
2615 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2616 
    if mtype == TMessageType.EXCEPTION:
2617 
      x = TApplicationException()
2618 
      x.read(self._iprot)
2619 
      self._iprot.readMessageEnd()
2620 
      raise x
2621 
    result = getNonDeliveredOrdersbyCourier_result()
2622 
    result.read(self._iprot)
2623 
    self._iprot.readMessageEnd()
4581 phani.kuma 2624 
    if result.success is not None:
2625 
      return result.success
4910 phani.kuma 2626 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getNonDeliveredOrdersbyCourier failed: unknown result");
2627 
 
2628 
  def markOrdersAsLocalConnected(self, providerId, local_connected_orders):
2629 
    """
2630 
    Mark all orders with AWBs in the given map as local connected. Also sets the local connected timestamp.
2631 
 
2632 
    Parameters:
2633 
     - providerId
2634 
     - local_connected_orders
2635 
    """
2636 
    self.send_markOrdersAsLocalConnected(providerId, local_connected_orders)
2637 
    self.recv_markOrdersAsLocalConnected()
2638 
 
2639 
  def send_markOrdersAsLocalConnected(self, providerId, local_connected_orders):
2640 
    self._oprot.writeMessageBegin('markOrdersAsLocalConnected', TMessageType.CALL, self._seqid)
2641 
    args = markOrdersAsLocalConnected_args()
2642 
    args.providerId = providerId
2643 
    args.local_connected_orders = local_connected_orders
2644 
    args.write(self._oprot)
2645 
    self._oprot.writeMessageEnd()
2646 
    self._oprot.trans.flush()
2647 
 
2648 
  def recv_markOrdersAsLocalConnected(self, ):
2649 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2650 
    if mtype == TMessageType.EXCEPTION:
2651 
      x = TApplicationException()
2652 
      x.read(self._iprot)
2653 
      self._iprot.readMessageEnd()
2654 
      raise x
2655 
    result = markOrdersAsLocalConnected_result()
2656 
    result.read(self._iprot)
2657 
    self._iprot.readMessageEnd()
3431 rajveer 2658 
    if result.ex is not None:
3064 chandransh 2659 
      raise result.ex
4910 phani.kuma 2660 
    return
1627 ankur.sing 2661 
 
4910 phani.kuma 2662 
  def getOrdersNotLocalConnected(self, providerId):
2663 
    """
2664 
    Returns a list of orders that were picked up or shipped but pending local connection.
2665 
 
2666 
    Parameters:
2667 
     - providerId
2668 
    """
2669 
    self.send_getOrdersNotLocalConnected(providerId)
2670 
    return self.recv_getOrdersNotLocalConnected()
2671 
 
2672 
  def send_getOrdersNotLocalConnected(self, providerId):
2673 
    self._oprot.writeMessageBegin('getOrdersNotLocalConnected', TMessageType.CALL, self._seqid)
2674 
    args = getOrdersNotLocalConnected_args()
2675 
    args.providerId = providerId
2676 
    args.write(self._oprot)
2677 
    self._oprot.writeMessageEnd()
2678 
    self._oprot.trans.flush()
2679 
 
2680 
  def recv_getOrdersNotLocalConnected(self, ):
2681 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2682 
    if mtype == TMessageType.EXCEPTION:
2683 
      x = TApplicationException()
2684 
      x.read(self._iprot)
2685 
      self._iprot.readMessageEnd()
2686 
      raise x
2687 
    result = getOrdersNotLocalConnected_result()
2688 
    result.read(self._iprot)
2689 
    self._iprot.readMessageEnd()
2690 
    if result.success is not None:
2691 
      return result.success
2692 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getOrdersNotLocalConnected failed: unknown result");
2693 
 
2694 
  def markOrdersAsDestinationCityReached(self, providerId, destination_city_reached_orders):
2695 
    """
2696 
    Mark all orders with AWBs in the given map as reached destination city. Also sets the reached destination timestamp.
2697 
 
2698 
    Parameters:
2699 
     - providerId
2700 
     - destination_city_reached_orders
2701 
    """
2702 
    self.send_markOrdersAsDestinationCityReached(providerId, destination_city_reached_orders)
2703 
    self.recv_markOrdersAsDestinationCityReached()
2704 
 
2705 
  def send_markOrdersAsDestinationCityReached(self, providerId, destination_city_reached_orders):
2706 
    self._oprot.writeMessageBegin('markOrdersAsDestinationCityReached', TMessageType.CALL, self._seqid)
2707 
    args = markOrdersAsDestinationCityReached_args()
2708 
    args.providerId = providerId
2709 
    args.destination_city_reached_orders = destination_city_reached_orders
2710 
    args.write(self._oprot)
2711 
    self._oprot.writeMessageEnd()
2712 
    self._oprot.trans.flush()
2713 
 
2714 
  def recv_markOrdersAsDestinationCityReached(self, ):
2715 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2716 
    if mtype == TMessageType.EXCEPTION:
2717 
      x = TApplicationException()
2718 
      x.read(self._iprot)
2719 
      self._iprot.readMessageEnd()
2720 
      raise x
2721 
    result = markOrdersAsDestinationCityReached_result()
2722 
    result.read(self._iprot)
2723 
    self._iprot.readMessageEnd()
2724 
    if result.ex is not None:
2725 
      raise result.ex
2726 
    return
2727 
 
2728 
  def markOrdersAsFirstDeliveryAttempted(self, providerId, first_atdl_orders):
2729 
    """
2730 
    Mark all orders with AWBs in the given map as first delivery attempt made. Also sets the first delivery attempted timestamp.
2731 
 
2732 
    Parameters:
2733 
     - providerId
2734 
     - first_atdl_orders
2735 
    """
2736 
    self.send_markOrdersAsFirstDeliveryAttempted(providerId, first_atdl_orders)
2737 
    self.recv_markOrdersAsFirstDeliveryAttempted()
2738 
 
2739 
  def send_markOrdersAsFirstDeliveryAttempted(self, providerId, first_atdl_orders):
2740 
    self._oprot.writeMessageBegin('markOrdersAsFirstDeliveryAttempted', TMessageType.CALL, self._seqid)
2741 
    args = markOrdersAsFirstDeliveryAttempted_args()
2742 
    args.providerId = providerId
2743 
    args.first_atdl_orders = first_atdl_orders
2744 
    args.write(self._oprot)
2745 
    self._oprot.writeMessageEnd()
2746 
    self._oprot.trans.flush()
2747 
 
2748 
  def recv_markOrdersAsFirstDeliveryAttempted(self, ):
2749 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2750 
    if mtype == TMessageType.EXCEPTION:
2751 
      x = TApplicationException()
2752 
      x.read(self._iprot)
2753 
      self._iprot.readMessageEnd()
2754 
      raise x
2755 
    result = markOrdersAsFirstDeliveryAttempted_result()
2756 
    result.read(self._iprot)
2757 
    self._iprot.readMessageEnd()
2758 
    if result.ex is not None:
2759 
      raise result.ex
2760 
    return
2761 
 
3064 chandransh 2762 
  def getUndeliveredOrders(self, providerId, warehouseId):
1627 ankur.sing 2763 
    """
3064 chandransh 2764 
    Returns the list of orders whose delivery time has passed but have not been
2765 
    delivered yet for the given provider and warehouse. To get a complete list of
2766 
    undelivered orders, pass them as -1.
2767 
    Returns an empty list if no such orders exist.
3431 rajveer 2768 
 
1886 ankur.sing 2769 
    Parameters:
3064 chandransh 2770 
     - providerId
2771 
     - warehouseId
1886 ankur.sing 2772 
    """
3064 chandransh 2773 
    self.send_getUndeliveredOrders(providerId, warehouseId)
2774 
    return self.recv_getUndeliveredOrders()
1627 ankur.sing 2775 
 
3064 chandransh 2776 
  def send_getUndeliveredOrders(self, providerId, warehouseId):
2777 
    self._oprot.writeMessageBegin('getUndeliveredOrders', TMessageType.CALL, self._seqid)
2778 
    args = getUndeliveredOrders_args()
2779 
    args.providerId = providerId
2780 
    args.warehouseId = warehouseId
1886 ankur.sing 2781 
    args.write(self._oprot)
2782 
    self._oprot.writeMessageEnd()
2783 
    self._oprot.trans.flush()
2784 
 
3064 chandransh 2785 
  def recv_getUndeliveredOrders(self, ):
1886 ankur.sing 2786 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2787 
    if mtype == TMessageType.EXCEPTION:
2788 
      x = TApplicationException()
2789 
      x.read(self._iprot)
2790 
      self._iprot.readMessageEnd()
2791 
      raise x
3064 chandransh 2792 
    result = getUndeliveredOrders_result()
1886 ankur.sing 2793 
    result.read(self._iprot)
2794 
    self._iprot.readMessageEnd()
3431 rajveer 2795 
    if result.success is not None:
1886 ankur.sing 2796 
      return result.success
3064 chandransh 2797 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getUndeliveredOrders failed: unknown result");
1886 ankur.sing 2798 
 
4783 phani.kuma 2799 
  def getUndeliveredOrdersExpectedDeliveryDateNotMet(self, ):
2800 
    """
2801 
    Returns the list of orders whose expected delivery date has passed but have not been
2802 
    delivered yet.
2803 
    Returns an empty list if no such orders exist.
2804 
    """
2805 
    self.send_getUndeliveredOrdersExpectedDeliveryDateNotMet()
2806 
    return self.recv_getUndeliveredOrdersExpectedDeliveryDateNotMet()
2807 
 
2808 
  def send_getUndeliveredOrdersExpectedDeliveryDateNotMet(self, ):
2809 
    self._oprot.writeMessageBegin('getUndeliveredOrdersExpectedDeliveryDateNotMet', TMessageType.CALL, self._seqid)
2810 
    args = getUndeliveredOrdersExpectedDeliveryDateNotMet_args()
2811 
    args.write(self._oprot)
2812 
    self._oprot.writeMessageEnd()
2813 
    self._oprot.trans.flush()
2814 
 
2815 
  def recv_getUndeliveredOrdersExpectedDeliveryDateNotMet(self, ):
2816 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2817 
    if mtype == TMessageType.EXCEPTION:
2818 
      x = TApplicationException()
2819 
      x.read(self._iprot)
2820 
      self._iprot.readMessageEnd()
2821 
      raise x
2822 
    result = getUndeliveredOrdersExpectedDeliveryDateNotMet_result()
2823 
    result.read(self._iprot)
2824 
    self._iprot.readMessageEnd()
2825 
    if result.success is not None:
2826 
      return result.success
2827 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getUndeliveredOrdersExpectedDeliveryDateNotMet failed: unknown result");
2828 
 
2536 chandransh 2829 
  def toggleDOAFlag(self, orderId):
2830 
    """
2831 
    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.
2832 
    Returns the final flag status.
2833 
    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 2834 
 
2536 chandransh 2835 
    Parameters:
2836 
     - orderId
2837 
    """
2838 
    self.send_toggleDOAFlag(orderId)
2839 
    return self.recv_toggleDOAFlag()
1886 ankur.sing 2840 
 
2536 chandransh 2841 
  def send_toggleDOAFlag(self, orderId):
2842 
    self._oprot.writeMessageBegin('toggleDOAFlag', TMessageType.CALL, self._seqid)
2843 
    args = toggleDOAFlag_args()
2844 
    args.orderId = orderId
2845 
    args.write(self._oprot)
2846 
    self._oprot.writeMessageEnd()
2847 
    self._oprot.trans.flush()
2848 
 
2849 
  def recv_toggleDOAFlag(self, ):
2850 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2851 
    if mtype == TMessageType.EXCEPTION:
2852 
      x = TApplicationException()
2853 
      x.read(self._iprot)
2854 
      self._iprot.readMessageEnd()
2855 
      raise x
2856 
    result = toggleDOAFlag_result()
2857 
    result.read(self._iprot)
2858 
    self._iprot.readMessageEnd()
3431 rajveer 2859 
    if result.success is not None:
2536 chandransh 2860 
      return result.success
3431 rajveer 2861 
    if result.ex is not None:
2536 chandransh 2862 
      raise result.ex
2863 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "toggleDOAFlag failed: unknown result");
2864 
 
4712 rajveer 2865 
  def markOrderAsDelivered(self, orderId, deliveryTimestamp, receiver):
2866 
    """
2867 
    Parameters:
2868 
     - orderId
2869 
     - deliveryTimestamp
2870 
     - receiver
2871 
    """
2872 
    self.send_markOrderAsDelivered(orderId, deliveryTimestamp, receiver)
2873 
    self.recv_markOrderAsDelivered()
2874 
 
2875 
  def send_markOrderAsDelivered(self, orderId, deliveryTimestamp, receiver):
2876 
    self._oprot.writeMessageBegin('markOrderAsDelivered', TMessageType.CALL, self._seqid)
2877 
    args = markOrderAsDelivered_args()
2878 
    args.orderId = orderId
2879 
    args.deliveryTimestamp = deliveryTimestamp
2880 
    args.receiver = receiver
2881 
    args.write(self._oprot)
2882 
    self._oprot.writeMessageEnd()
2883 
    self._oprot.trans.flush()
2884 
 
2885 
  def recv_markOrderAsDelivered(self, ):
2886 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2887 
    if mtype == TMessageType.EXCEPTION:
2888 
      x = TApplicationException()
2889 
      x.read(self._iprot)
2890 
      self._iprot.readMessageEnd()
2891 
      raise x
2892 
    result = markOrderAsDelivered_result()
2893 
    result.read(self._iprot)
2894 
    self._iprot.readMessageEnd()
2895 
    if result.ex is not None:
2896 
      raise result.ex
2897 
    return
2898 
 
4454 rajveer 2899 
  def markOrderDoaRequestReceived(self, orderId):
2900 
    """
2901 
    Once user raise the request for a DOA, order status will be changed from DELVIERY_SUCCESS to DOA_REQUEST_RECEIVED
2902 
 
2903 
    Parameters:
2904 
     - orderId
2905 
    """
2906 
    self.send_markOrderDoaRequestReceived(orderId)
2907 
    return self.recv_markOrderDoaRequestReceived()
2908 
 
2909 
  def send_markOrderDoaRequestReceived(self, orderId):
2910 
    self._oprot.writeMessageBegin('markOrderDoaRequestReceived', TMessageType.CALL, self._seqid)
2911 
    args = markOrderDoaRequestReceived_args()
2912 
    args.orderId = orderId
2913 
    args.write(self._oprot)
2914 
    self._oprot.writeMessageEnd()
2915 
    self._oprot.trans.flush()
2916 
 
2917 
  def recv_markOrderDoaRequestReceived(self, ):
2918 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2919 
    if mtype == TMessageType.EXCEPTION:
2920 
      x = TApplicationException()
2921 
      x.read(self._iprot)
2922 
      self._iprot.readMessageEnd()
2923 
      raise x
2924 
    result = markOrderDoaRequestReceived_result()
2925 
    result.read(self._iprot)
2926 
    self._iprot.readMessageEnd()
2927 
    if result.success is not None:
2928 
      return result.success
2929 
    if result.ex is not None:
2930 
      raise result.ex
2931 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "markOrderDoaRequestReceived failed: unknown result");
2932 
 
2933 
  def markOrderDoaRequestAuthorized(self, orderId, isAuthorized):
2934 
    """
2935 
    CRM person can authorize or deny the request reised by customer. If he authorizes order will change from DOA_REQUEST_RECEIVED
2936 
    to DOA_REQUEST_AUTHORIZED. If he denies, status will be changed back to DELVIERY_SUCCESS.
2937 
 
2938 
    Parameters:
2939 
     - orderId
2940 
     - isAuthorized
2941 
    """
2942 
    self.send_markOrderDoaRequestAuthorized(orderId, isAuthorized)
2943 
    return self.recv_markOrderDoaRequestAuthorized()
2944 
 
2945 
  def send_markOrderDoaRequestAuthorized(self, orderId, isAuthorized):
2946 
    self._oprot.writeMessageBegin('markOrderDoaRequestAuthorized', TMessageType.CALL, self._seqid)
2947 
    args = markOrderDoaRequestAuthorized_args()
2948 
    args.orderId = orderId
2949 
    args.isAuthorized = isAuthorized
2950 
    args.write(self._oprot)
2951 
    self._oprot.writeMessageEnd()
2952 
    self._oprot.trans.flush()
2953 
 
2954 
  def recv_markOrderDoaRequestAuthorized(self, ):
2955 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2956 
    if mtype == TMessageType.EXCEPTION:
2957 
      x = TApplicationException()
2958 
      x.read(self._iprot)
2959 
      self._iprot.readMessageEnd()
2960 
      raise x
2961 
    result = markOrderDoaRequestAuthorized_result()
2962 
    result.read(self._iprot)
2963 
    self._iprot.readMessageEnd()
2964 
    if result.success is not None:
2965 
      return result.success
2966 
    if result.ex is not None:
2967 
      raise result.ex
2968 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "markOrderDoaRequestAuthorized failed: unknown result");
2969 
 
4488 rajveer 2970 
  def markOrderReturnRequestReceived(self, orderId):
2971 
    """
2972 
    Once user raise the request for a RET, order status will be changed from DELVIERY_SUCCESS to RET_REQUEST_RECEIVED
2973 
 
2974 
    Parameters:
2975 
     - orderId
2976 
    """
2977 
    self.send_markOrderReturnRequestReceived(orderId)
2978 
    return self.recv_markOrderReturnRequestReceived()
2979 
 
2980 
  def send_markOrderReturnRequestReceived(self, orderId):
2981 
    self._oprot.writeMessageBegin('markOrderReturnRequestReceived', TMessageType.CALL, self._seqid)
2982 
    args = markOrderReturnRequestReceived_args()
2983 
    args.orderId = orderId
2984 
    args.write(self._oprot)
2985 
    self._oprot.writeMessageEnd()
2986 
    self._oprot.trans.flush()
2987 
 
2988 
  def recv_markOrderReturnRequestReceived(self, ):
2989 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2990 
    if mtype == TMessageType.EXCEPTION:
2991 
      x = TApplicationException()
2992 
      x.read(self._iprot)
2993 
      self._iprot.readMessageEnd()
2994 
      raise x
2995 
    result = markOrderReturnRequestReceived_result()
2996 
    result.read(self._iprot)
2997 
    self._iprot.readMessageEnd()
2998 
    if result.success is not None:
2999 
      return result.success
3000 
    if result.ex is not None:
3001 
      raise result.ex
3002 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "markOrderReturnRequestReceived failed: unknown result");
3003 
 
3004 
  def markOrderReturnRequestAuthorized(self, orderId, isAuthorized):
3005 
    """
3006 
    CRM person can authorize or deny the request reised by customer. If he authorizes order will change from RET_REQUEST_RECEIVED
3007 
    to RET_REQUEST_AUTHORIZED. If he denies, status will be changed back to DELVIERY_SUCCESS.
3008 
 
3009 
    Parameters:
3010 
     - orderId
3011 
     - isAuthorized
3012 
    """
3013 
    self.send_markOrderReturnRequestAuthorized(orderId, isAuthorized)
3014 
    return self.recv_markOrderReturnRequestAuthorized()
3015 
 
3016 
  def send_markOrderReturnRequestAuthorized(self, orderId, isAuthorized):
3017 
    self._oprot.writeMessageBegin('markOrderReturnRequestAuthorized', TMessageType.CALL, self._seqid)
3018 
    args = markOrderReturnRequestAuthorized_args()
3019 
    args.orderId = orderId
3020 
    args.isAuthorized = isAuthorized
3021 
    args.write(self._oprot)
3022 
    self._oprot.writeMessageEnd()
3023 
    self._oprot.trans.flush()
3024 
 
3025 
  def recv_markOrderReturnRequestAuthorized(self, ):
3026 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3027 
    if mtype == TMessageType.EXCEPTION:
3028 
      x = TApplicationException()
3029 
      x.read(self._iprot)
3030 
      self._iprot.readMessageEnd()
3031 
      raise x
3032 
    result = markOrderReturnRequestAuthorized_result()
3033 
    result.read(self._iprot)
3034 
    self._iprot.readMessageEnd()
3035 
    if result.success is not None:
3036 
      return result.success
3037 
    if result.ex is not None:
3038 
      raise result.ex
3039 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "markOrderReturnRequestAuthorized failed: unknown result");
3040 
 
4579 rajveer 3041 
  def requestPickupNumber(self, orderId, providerId):
2536 chandransh 3042 
    """
3043 
    Sends out an email to the account manager of the original courier provider used to ship the order.
4452 rajveer 3044 
    If the order status was DELIVERY_SUCCESS, it is changed to be DOA_PICKUP_REQUEST_RAISED.
3045 
    If the order status was DOA_PICKUP_REQUEST_RAISED, it is left unchanged.
2536 chandransh 3046 
    For any other status, it returns false.
3047 
    Throws an exception if the order with the given id couldn't be found.
3431 rajveer 3048 
 
2536 chandransh 3049 
    Parameters:
3050 
     - orderId
4579 rajveer 3051 
     - providerId
2536 chandransh 3052 
    """
4579 rajveer 3053 
    self.send_requestPickupNumber(orderId, providerId)
2536 chandransh 3054 
    return self.recv_requestPickupNumber()
3055 
 
4579 rajveer 3056 
  def send_requestPickupNumber(self, orderId, providerId):
2536 chandransh 3057 
    self._oprot.writeMessageBegin('requestPickupNumber', TMessageType.CALL, self._seqid)
3058 
    args = requestPickupNumber_args()
3059 
    args.orderId = orderId
4579 rajveer 3060 
    args.providerId = providerId
2536 chandransh 3061 
    args.write(self._oprot)
3062 
    self._oprot.writeMessageEnd()
3063 
    self._oprot.trans.flush()
3064 
 
3065 
  def recv_requestPickupNumber(self, ):
3066 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3067 
    if mtype == TMessageType.EXCEPTION:
3068 
      x = TApplicationException()
3069 
      x.read(self._iprot)
3070 
      self._iprot.readMessageEnd()
3071 
      raise x
3072 
    result = requestPickupNumber_result()
3073 
    result.read(self._iprot)
3074 
    self._iprot.readMessageEnd()
3431 rajveer 3075 
    if result.success is not None:
2536 chandransh 3076 
      return result.success
3431 rajveer 3077 
    if result.ex is not None:
2536 chandransh 3078 
      raise result.ex
3079 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "requestPickupNumber failed: unknown result");
3080 
 
4602 rajveer 3081 
  def authorizePickup(self, orderId, pickupNumber, providerId):
2536 chandransh 3082 
    """
4452 rajveer 3083 
    If the order status is DOA_PICKUP_REQUEST_RAISED, it does the following
2536 chandransh 3084 
    	1. Sends out an email to the customer with the dispatch advice that he has to print as an attachment.
3085 
    	2. Changes order status to be DOA_PICKUP_AUTHORIZED.
3086 
    	3. Returns true
2591 chandransh 3087 
    If the order is in any other status, it returns false.
2536 chandransh 3088 
    Throws an exception if the order with the given id couldn't be found.
3431 rajveer 3089 
 
2536 chandransh 3090 
    Parameters:
3091 
     - orderId
3092 
     - pickupNumber
4602 rajveer 3093 
     - providerId
2536 chandransh 3094 
    """
4602 rajveer 3095 
    self.send_authorizePickup(orderId, pickupNumber, providerId)
2536 chandransh 3096 
    return self.recv_authorizePickup()
3097 
 
4602 rajveer 3098 
  def send_authorizePickup(self, orderId, pickupNumber, providerId):
2536 chandransh 3099 
    self._oprot.writeMessageBegin('authorizePickup', TMessageType.CALL, self._seqid)
3100 
    args = authorizePickup_args()
3101 
    args.orderId = orderId
3102 
    args.pickupNumber = pickupNumber
4602 rajveer 3103 
    args.providerId = providerId
2536 chandransh 3104 
    args.write(self._oprot)
3105 
    self._oprot.writeMessageEnd()
3106 
    self._oprot.trans.flush()
3107 
 
3108 
  def recv_authorizePickup(self, ):
3109 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3110 
    if mtype == TMessageType.EXCEPTION:
3111 
      x = TApplicationException()
3112 
      x.read(self._iprot)
3113 
      self._iprot.readMessageEnd()
3114 
      raise x
3115 
    result = authorizePickup_result()
3116 
    result.read(self._iprot)
3117 
    self._iprot.readMessageEnd()
3431 rajveer 3118 
    if result.success is not None:
2536 chandransh 3119 
      return result.success
3431 rajveer 3120 
    if result.ex is not None:
2536 chandransh 3121 
      raise result.ex
3122 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "authorizePickup failed: unknown result");
3123 
 
2764 chandransh 3124 
  def markDoasAsPickedUp(self, providerId, pickupDetails):
3125 
    """
3126 
    Marks all DOA_PICKUP_AUTHORIZED orders of the previous day for a provider as DOA_RETURN_IN_TRANSIT.
3431 rajveer 3127 
 
2764 chandransh 3128 
    Parameters:
3129 
     - providerId
3130 
     - pickupDetails
3131 
    """
3132 
    self.send_markDoasAsPickedUp(providerId, pickupDetails)
4910 phani.kuma 3133 
    self.recv_markDoasAsPickedUp()
2764 chandransh 3134 
 
3135 
  def send_markDoasAsPickedUp(self, providerId, pickupDetails):
3136 
    self._oprot.writeMessageBegin('markDoasAsPickedUp', TMessageType.CALL, self._seqid)
3137 
    args = markDoasAsPickedUp_args()
3138 
    args.providerId = providerId
3139 
    args.pickupDetails = pickupDetails
3140 
    args.write(self._oprot)
3141 
    self._oprot.writeMessageEnd()
3142 
    self._oprot.trans.flush()
3143 
 
3144 
  def recv_markDoasAsPickedUp(self, ):
3145 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3146 
    if mtype == TMessageType.EXCEPTION:
3147 
      x = TApplicationException()
3148 
      x.read(self._iprot)
3149 
      self._iprot.readMessageEnd()
3150 
      raise x
3151 
    result = markDoasAsPickedUp_result()
3152 
    result.read(self._iprot)
3153 
    self._iprot.readMessageEnd()
4910 phani.kuma 3154 
    return
3155 
 
3156 
  def getDoasNotPickedUp(self, providerId):
3157 
    """
3158 
    Returns a list of orders that were authorized for pickup but did not appear in the pick-up report.
3159 
 
3160 
    Parameters:
3161 
     - providerId
3162 
    """
3163 
    self.send_getDoasNotPickedUp(providerId)
3164 
    return self.recv_getDoasNotPickedUp()
3165 
 
3166 
  def send_getDoasNotPickedUp(self, providerId):
3167 
    self._oprot.writeMessageBegin('getDoasNotPickedUp', TMessageType.CALL, self._seqid)
3168 
    args = getDoasNotPickedUp_args()
3169 
    args.providerId = providerId
3170 
    args.write(self._oprot)
3171 
    self._oprot.writeMessageEnd()
3172 
    self._oprot.trans.flush()
3173 
 
3174 
  def recv_getDoasNotPickedUp(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 = getDoasNotPickedUp_result()
3182 
    result.read(self._iprot)
3183 
    self._iprot.readMessageEnd()
3431 rajveer 3184 
    if result.success is not None:
2764 chandransh 3185 
      return result.success
4910 phani.kuma 3186 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getDoasNotPickedUp failed: unknown result");
2764 chandransh 3187 
 
4741 phani.kuma 3188 
  def markReturnOrdersAsPickedUp(self, providerId, pickupDetails):
3189 
    """
3190 
    Marks all RET_PICKUP_CONFIRMED orders of the previous day for a provider as RET_RETURN_IN_TRANSIT.
3191 
 
3192 
    Parameters:
3193 
     - providerId
3194 
     - pickupDetails
3195 
    """
3196 
    self.send_markReturnOrdersAsPickedUp(providerId, pickupDetails)
4910 phani.kuma 3197 
    self.recv_markReturnOrdersAsPickedUp()
4741 phani.kuma 3198 
 
3199 
  def send_markReturnOrdersAsPickedUp(self, providerId, pickupDetails):
3200 
    self._oprot.writeMessageBegin('markReturnOrdersAsPickedUp', TMessageType.CALL, self._seqid)
3201 
    args = markReturnOrdersAsPickedUp_args()
3202 
    args.providerId = providerId
3203 
    args.pickupDetails = pickupDetails
3204 
    args.write(self._oprot)
3205 
    self._oprot.writeMessageEnd()
3206 
    self._oprot.trans.flush()
3207 
 
3208 
  def recv_markReturnOrdersAsPickedUp(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 = markReturnOrdersAsPickedUp_result()
3216 
    result.read(self._iprot)
3217 
    self._iprot.readMessageEnd()
4910 phani.kuma 3218 
    return
3219 
 
3220 
  def getReturnOrdersNotPickedUp(self, providerId):
3221 
    """
3222 
    Returns a list of orders that were authorized for pickup but did not appear in the pick-up report.
3223 
 
3224 
    Parameters:
3225 
     - providerId
3226 
    """
3227 
    self.send_getReturnOrdersNotPickedUp(providerId)
3228 
    return self.recv_getReturnOrdersNotPickedUp()
3229 
 
3230 
  def send_getReturnOrdersNotPickedUp(self, providerId):
3231 
    self._oprot.writeMessageBegin('getReturnOrdersNotPickedUp', TMessageType.CALL, self._seqid)
3232 
    args = getReturnOrdersNotPickedUp_args()
3233 
    args.providerId = providerId
3234 
    args.write(self._oprot)
3235 
    self._oprot.writeMessageEnd()
3236 
    self._oprot.trans.flush()
3237 
 
3238 
  def recv_getReturnOrdersNotPickedUp(self, ):
3239 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3240 
    if mtype == TMessageType.EXCEPTION:
3241 
      x = TApplicationException()
3242 
      x.read(self._iprot)
3243 
      self._iprot.readMessageEnd()
3244 
      raise x
3245 
    result = getReturnOrdersNotPickedUp_result()
3246 
    result.read(self._iprot)
3247 
    self._iprot.readMessageEnd()
4741 phani.kuma 3248 
    if result.success is not None:
3249 
      return result.success
4910 phani.kuma 3250 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getReturnOrdersNotPickedUp failed: unknown result");
4741 phani.kuma 3251 
 
4479 rajveer 3252 
  def receiveReturn(self, orderId, receiveCondition):
2591 chandransh 3253 
    """
4452 rajveer 3254 
    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 3255 
    If the order status is RTO_IN_TRANSIT, marks the order status as RTO_RECEIVED_PRESTINE and returns true.
2591 chandransh 3256 
    If the order is in any other state, it returns false.
3257 
    Throws an exception if the order with the given id couldn't be found.
3431 rajveer 3258 
 
2591 chandransh 3259 
    Parameters:
3260 
     - orderId
4479 rajveer 3261 
     - receiveCondition
2591 chandransh 3262 
    """
4479 rajveer 3263 
    self.send_receiveReturn(orderId, receiveCondition)
2616 chandransh 3264 
    return self.recv_receiveReturn()
2536 chandransh 3265 
 
4479 rajveer 3266 
  def send_receiveReturn(self, orderId, receiveCondition):
2616 chandransh 3267 
    self._oprot.writeMessageBegin('receiveReturn', TMessageType.CALL, self._seqid)
3268 
    args = receiveReturn_args()
2591 chandransh 3269 
    args.orderId = orderId
4479 rajveer 3270 
    args.receiveCondition = receiveCondition
2591 chandransh 3271 
    args.write(self._oprot)
3272 
    self._oprot.writeMessageEnd()
3273 
    self._oprot.trans.flush()
3274 
 
2616 chandransh 3275 
  def recv_receiveReturn(self, ):
2591 chandransh 3276 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3277 
    if mtype == TMessageType.EXCEPTION:
3278 
      x = TApplicationException()
3279 
      x.read(self._iprot)
3280 
      self._iprot.readMessageEnd()
3281 
      raise x
2616 chandransh 3282 
    result = receiveReturn_result()
2591 chandransh 3283 
    result.read(self._iprot)
3284 
    self._iprot.readMessageEnd()
3431 rajveer 3285 
    if result.success is not None:
2591 chandransh 3286 
      return result.success
3431 rajveer 3287 
    if result.ex is not None:
2591 chandransh 3288 
      raise result.ex
2616 chandransh 3289 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "receiveReturn failed: unknown result");
2591 chandransh 3290 
 
3291 
  def validateDoa(self, orderId, isValid):
3292 
    """
4452 rajveer 3293 
    Used to validate the DOA certificate for an order in the DOA_RECEIVED_PRESTINE state. If the certificate is valid,
2616 chandransh 3294 
    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 3295 
    If the order is in any other state, it returns false.
3296 
    Throws an exception if the order with the given id couldn't be found.
3431 rajveer 3297 
 
2591 chandransh 3298 
    Parameters:
3299 
     - orderId
3300 
     - isValid
3301 
    """
3302 
    self.send_validateDoa(orderId, isValid)
3303 
    return self.recv_validateDoa()
3304 
 
3305 
  def send_validateDoa(self, orderId, isValid):
3306 
    self._oprot.writeMessageBegin('validateDoa', TMessageType.CALL, self._seqid)
3307 
    args = validateDoa_args()
3308 
    args.orderId = orderId
3309 
    args.isValid = isValid
3310 
    args.write(self._oprot)
3311 
    self._oprot.writeMessageEnd()
3312 
    self._oprot.trans.flush()
3313 
 
3314 
  def recv_validateDoa(self, ):
3315 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3316 
    if mtype == TMessageType.EXCEPTION:
3317 
      x = TApplicationException()
3318 
      x.read(self._iprot)
3319 
      self._iprot.readMessageEnd()
3320 
      raise x
3321 
    result = validateDoa_result()
3322 
    result.read(self._iprot)
3323 
    self._iprot.readMessageEnd()
3431 rajveer 3324 
    if result.success is not None:
2591 chandransh 3325 
      return result.success
3431 rajveer 3326 
    if result.ex is not None:
2591 chandransh 3327 
      raise result.ex
3328 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "validateDoa failed: unknown result");
3329 
 
4495 rajveer 3330 
  def validateReturnProduct(self, orderId, isUsable):
3331 
    """
3332 
    Parameters:
3333 
     - orderId
3334 
     - isUsable
3335 
    """
3336 
    self.send_validateReturnProduct(orderId, isUsable)
3337 
    return self.recv_validateReturnProduct()
3338 
 
3339 
  def send_validateReturnProduct(self, orderId, isUsable):
3340 
    self._oprot.writeMessageBegin('validateReturnProduct', TMessageType.CALL, self._seqid)
3341 
    args = validateReturnProduct_args()
3342 
    args.orderId = orderId
3343 
    args.isUsable = isUsable
3344 
    args.write(self._oprot)
3345 
    self._oprot.writeMessageEnd()
3346 
    self._oprot.trans.flush()
3347 
 
3348 
  def recv_validateReturnProduct(self, ):
3349 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3350 
    if mtype == TMessageType.EXCEPTION:
3351 
      x = TApplicationException()
3352 
      x.read(self._iprot)
3353 
      self._iprot.readMessageEnd()
3354 
      raise x
3355 
    result = validateReturnProduct_result()
3356 
    result.read(self._iprot)
3357 
    self._iprot.readMessageEnd()
3358 
    if result.success is not None:
3359 
      return result.success
3360 
    if result.ex is not None:
3361 
      raise result.ex
3362 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "validateReturnProduct failed: unknown result");
3363 
 
2616 chandransh 3364 
  def reshipOrder(self, orderId):
3365 
    """
4484 rajveer 3366 
    If the order is in RTO_RECEIVED_PRESTINE or DOA_CERT_INVALID state, it does the following:
2616 chandransh 3367 
    	1. Creates a new order for processing in the BILLED state. All billing information is saved.
4484 rajveer 3368 
    	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 3369 
 
3370 
    If the order is in DOA_CERT_VALID state, it does the following:
3371 
    	1. Creates a new order for processing in the SUBMITTED_FOR_PROCESSING state.
3372 
    	2. Creates a return order for the warehouse executive to return the DOA material.
4452 rajveer 3373 
    	3. Marks the current order as the final DOA_VALID_RESHIPPED state.
3431 rajveer 3374 
 
2616 chandransh 3375 
    Returns the id of the newly created order.
3431 rajveer 3376 
 
2616 chandransh 3377 
    Throws an exception if the order with the given id couldn't be found.
3431 rajveer 3378 
 
2616 chandransh 3379 
    Parameters:
3380 
     - orderId
3381 
    """
3382 
    self.send_reshipOrder(orderId)
3383 
    return self.recv_reshipOrder()
2591 chandransh 3384 
 
2616 chandransh 3385 
  def send_reshipOrder(self, orderId):
3386 
    self._oprot.writeMessageBegin('reshipOrder', TMessageType.CALL, self._seqid)
3387 
    args = reshipOrder_args()
3388 
    args.orderId = orderId
3389 
    args.write(self._oprot)
3390 
    self._oprot.writeMessageEnd()
3391 
    self._oprot.trans.flush()
3392 
 
3393 
  def recv_reshipOrder(self, ):
3394 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3395 
    if mtype == TMessageType.EXCEPTION:
3396 
      x = TApplicationException()
3397 
      x.read(self._iprot)
3398 
      self._iprot.readMessageEnd()
3399 
      raise x
3400 
    result = reshipOrder_result()
3401 
    result.read(self._iprot)
3402 
    self._iprot.readMessageEnd()
3431 rajveer 3403 
    if result.success is not None:
2616 chandransh 3404 
      return result.success
3431 rajveer 3405 
    if result.ex is not None:
2616 chandransh 3406 
      raise result.ex
3407 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "reshipOrder failed: unknown result");
3408 
 
3226 chandransh 3409 
  def refundOrder(self, orderId, refundedBy, reason):
2616 chandransh 3410 
    """
4484 rajveer 3411 
    If the order is in RTO_RECEIVED_PRESTINE, DOA_CERT_VALID or DOA_CERT_INVALID state, it does the following:
2616 chandransh 3412 
    	1. Creates a refund request for batch processing.
3413 
    	2. Creates a return order for the warehouse executive to return the shipped material.
4484 rajveer 3414 
    	3. Marks the current order as RTO_REFUNDED, DOA_VALID_REFUNDED or DOA_INVALID_REFUNDED final states.
3431 rajveer 3415 
 
2616 chandransh 3416 
    If the order is in SUBMITTED_FOR_PROCESSING or INVENTORY_LOW state, it does the following:
3417 
    	1. Creates a refund request for batch processing.
3226 chandransh 3418 
    	2. Cancels the reservation of the item in the warehouse.
3419 
    	3. Marks the current order as the REFUNDED final state.
3431 rajveer 3420 
 
3226 chandransh 3421 
    For all COD orders, if the order is in INIT, SUBMITTED_FOR_PROCESSING or INVENTORY_LOW state, it does the following:
3422 
    	1. Cancels the reservation of the item in the warehouse.
3423 
    	2. Marks the current order as CANCELED.
3424 
 
3425 
    In all cases, it updates the reason for cancellation or refund and the person who performed the action.
3426 
 
2616 chandransh 3427 
    Returns True if it is successful, False otherwise.
3431 rajveer 3428 
 
2616 chandransh 3429 
    Throws an exception if the order with the given id couldn't be found.
3431 rajveer 3430 
 
2616 chandransh 3431 
    Parameters:
3432 
     - orderId
3226 chandransh 3433 
     - refundedBy
3434 
     - reason
2616 chandransh 3435 
    """
3226 chandransh 3436 
    self.send_refundOrder(orderId, refundedBy, reason)
2616 chandransh 3437 
    return self.recv_refundOrder()
3438 
 
3226 chandransh 3439 
  def send_refundOrder(self, orderId, refundedBy, reason):
2616 chandransh 3440 
    self._oprot.writeMessageBegin('refundOrder', TMessageType.CALL, self._seqid)
3441 
    args = refundOrder_args()
3442 
    args.orderId = orderId
3226 chandransh 3443 
    args.refundedBy = refundedBy
3444 
    args.reason = reason
2616 chandransh 3445 
    args.write(self._oprot)
3446 
    self._oprot.writeMessageEnd()
3447 
    self._oprot.trans.flush()
3448 
 
3449 
  def recv_refundOrder(self, ):
3450 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3451 
    if mtype == TMessageType.EXCEPTION:
3452 
      x = TApplicationException()
3453 
      x.read(self._iprot)
3454 
      self._iprot.readMessageEnd()
3455 
      raise x
3456 
    result = refundOrder_result()
3457 
    result.read(self._iprot)
3458 
    self._iprot.readMessageEnd()
3431 rajveer 3459 
    if result.success is not None:
2616 chandransh 3460 
      return result.success
3431 rajveer 3461 
    if result.ex is not None:
2616 chandransh 3462 
      raise result.ex
3463 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "refundOrder failed: unknown result");
3464 
 
2690 chandransh 3465 
  def getReturnOrders(self, warehouseId, fromDate, toDate):
3466 
    """
3467 
    Get all return orders created between the from and to dates for the given warehouse.
3468 
    Ignores the warehouse if it is passed as -1.
3431 rajveer 3469 
 
2690 chandransh 3470 
    Parameters:
3471 
     - warehouseId
3472 
     - fromDate
3473 
     - toDate
3474 
    """
3475 
    self.send_getReturnOrders(warehouseId, fromDate, toDate)
3476 
    return self.recv_getReturnOrders()
2616 chandransh 3477 
 
2690 chandransh 3478 
  def send_getReturnOrders(self, warehouseId, fromDate, toDate):
3479 
    self._oprot.writeMessageBegin('getReturnOrders', TMessageType.CALL, self._seqid)
3480 
    args = getReturnOrders_args()
3481 
    args.warehouseId = warehouseId
3482 
    args.fromDate = fromDate
3483 
    args.toDate = toDate
3484 
    args.write(self._oprot)
3485 
    self._oprot.writeMessageEnd()
3486 
    self._oprot.trans.flush()
3487 
 
3488 
  def recv_getReturnOrders(self, ):
3489 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3490 
    if mtype == TMessageType.EXCEPTION:
3491 
      x = TApplicationException()
3492 
      x.read(self._iprot)
3493 
      self._iprot.readMessageEnd()
3494 
      raise x
3495 
    result = getReturnOrders_result()
3496 
    result.read(self._iprot)
3497 
    self._iprot.readMessageEnd()
3431 rajveer 3498 
    if result.success is not None:
2690 chandransh 3499 
      return result.success
3500 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getReturnOrders failed: unknown result");
3501 
 
2700 chandransh 3502 
  def getReturnOrder(self, id):
3503 
    """
3504 
    Returns the ReturnOrder corresponding to the given id.
3505 
    Throws an exception if the return order with the given id couldn't be found.
3431 rajveer 3506 
 
2700 chandransh 3507 
    Parameters:
3508 
     - id
3509 
    """
3510 
    self.send_getReturnOrder(id)
3511 
    return self.recv_getReturnOrder()
3512 
 
3513 
  def send_getReturnOrder(self, id):
3514 
    self._oprot.writeMessageBegin('getReturnOrder', TMessageType.CALL, self._seqid)
3515 
    args = getReturnOrder_args()
3516 
    args.id = id
3517 
    args.write(self._oprot)
3518 
    self._oprot.writeMessageEnd()
3519 
    self._oprot.trans.flush()
3520 
 
3521 
  def recv_getReturnOrder(self, ):
3522 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3523 
    if mtype == TMessageType.EXCEPTION:
3524 
      x = TApplicationException()
3525 
      x.read(self._iprot)
3526 
      self._iprot.readMessageEnd()
3527 
      raise x
3528 
    result = getReturnOrder_result()
3529 
    result.read(self._iprot)
3530 
    self._iprot.readMessageEnd()
3431 rajveer 3531 
    if result.success is not None:
2700 chandransh 3532 
      return result.success
3431 rajveer 3533 
    if result.ex is not None:
2700 chandransh 3534 
      raise result.ex
3535 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getReturnOrder failed: unknown result");
3536 
 
2690 chandransh 3537 
  def processReturn(self, returnOrderId):
3538 
    """
3539 
    Marks the return order with the given id as processed. Raises an exception if no such return order exists.
3431 rajveer 3540 
 
2690 chandransh 3541 
    Parameters:
3542 
     - returnOrderId
3543 
    """
3544 
    self.send_processReturn(returnOrderId)
3545 
    self.recv_processReturn()
3546 
 
3547 
  def send_processReturn(self, returnOrderId):
3548 
    self._oprot.writeMessageBegin('processReturn', TMessageType.CALL, self._seqid)
3549 
    args = processReturn_args()
3550 
    args.returnOrderId = returnOrderId
3551 
    args.write(self._oprot)
3552 
    self._oprot.writeMessageEnd()
3553 
    self._oprot.trans.flush()
3554 
 
3555 
  def recv_processReturn(self, ):
3556 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3557 
    if mtype == TMessageType.EXCEPTION:
3558 
      x = TApplicationException()
3559 
      x.read(self._iprot)
3560 
      self._iprot.readMessageEnd()
3561 
      raise x
3562 
    result = processReturn_result()
3563 
    result.read(self._iprot)
3564 
    self._iprot.readMessageEnd()
3431 rajveer 3565 
    if result.ex is not None:
2690 chandransh 3566 
      raise result.ex
3567 
    return
3568 
 
3451 chandransh 3569 
  def updateWeight(self, orderId, weight):
3570 
    """
3571 
    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 3572 
 
3451 chandransh 3573 
    Parameters:
3574 
     - orderId
3575 
     - weight
3576 
    """
3577 
    self.send_updateWeight(orderId, weight)
3578 
    return self.recv_updateWeight()
3579 
 
3580 
  def send_updateWeight(self, orderId, weight):
3581 
    self._oprot.writeMessageBegin('updateWeight', TMessageType.CALL, self._seqid)
3582 
    args = updateWeight_args()
3583 
    args.orderId = orderId
3584 
    args.weight = weight
3585 
    args.write(self._oprot)
3586 
    self._oprot.writeMessageEnd()
3587 
    self._oprot.trans.flush()
3588 
 
3589 
  def recv_updateWeight(self, ):
3590 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3591 
    if mtype == TMessageType.EXCEPTION:
3592 
      x = TApplicationException()
3593 
      x.read(self._iprot)
3594 
      self._iprot.readMessageEnd()
3595 
      raise x
3596 
    result = updateWeight_result()
3597 
    result.read(self._iprot)
3598 
    self._iprot.readMessageEnd()
3599 
    if result.success is not None:
3600 
      return result.success
3601 
    if result.ex is not None:
3602 
      raise result.ex
3603 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "updateWeight failed: unknown result");
3604 
 
3469 chandransh 3605 
  def changeItem(self, orderId, itemId):
3606 
    """
3607 
    Change the item to be shipped for this order. Also adjusts the reservation in the inventory accordingly.
3608 
    Currently, it also ensures that only a different color of the given item is shipped.
3451 chandransh 3609 
 
3469 chandransh 3610 
    Parameters:
3611 
     - orderId
3612 
     - itemId
3613 
    """
3614 
    self.send_changeItem(orderId, itemId)
3615 
    return self.recv_changeItem()
3616 
 
3617 
  def send_changeItem(self, orderId, itemId):
3618 
    self._oprot.writeMessageBegin('changeItem', TMessageType.CALL, self._seqid)
3619 
    args = changeItem_args()
3620 
    args.orderId = orderId
3621 
    args.itemId = itemId
3622 
    args.write(self._oprot)
3623 
    self._oprot.writeMessageEnd()
3624 
    self._oprot.trans.flush()
3625 
 
3626 
  def recv_changeItem(self, ):
3627 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3628 
    if mtype == TMessageType.EXCEPTION:
3629 
      x = TApplicationException()
3630 
      x.read(self._iprot)
3631 
      self._iprot.readMessageEnd()
3632 
      raise x
3633 
    result = changeItem_result()
3634 
    result.read(self._iprot)
3635 
    self._iprot.readMessageEnd()
3636 
    if result.success is not None:
3637 
      return result.success
3638 
    if result.ex is not None:
3639 
      raise result.ex
3640 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "changeItem failed: unknown result");
3641 
 
3642 
  def shiftToWarehouse(self, orderId, warehouseId):
3643 
    """
3644 
    Moves the given order to the given warehouse. Also adjusts the inventory reservations accordingly.
3645 
 
3646 
    Parameters:
3647 
     - orderId
3648 
     - warehouseId
3649 
    """
3650 
    self.send_shiftToWarehouse(orderId, warehouseId)
3651 
    return self.recv_shiftToWarehouse()
3652 
 
3653 
  def send_shiftToWarehouse(self, orderId, warehouseId):
3654 
    self._oprot.writeMessageBegin('shiftToWarehouse', TMessageType.CALL, self._seqid)
3655 
    args = shiftToWarehouse_args()
3656 
    args.orderId = orderId
3657 
    args.warehouseId = warehouseId
3658 
    args.write(self._oprot)
3659 
    self._oprot.writeMessageEnd()
3660 
    self._oprot.trans.flush()
3661 
 
3662 
  def recv_shiftToWarehouse(self, ):
3663 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3664 
    if mtype == TMessageType.EXCEPTION:
3665 
      x = TApplicationException()
3666 
      x.read(self._iprot)
3667 
      self._iprot.readMessageEnd()
3668 
      raise x
3669 
    result = shiftToWarehouse_result()
3670 
    result.read(self._iprot)
3671 
    self._iprot.readMessageEnd()
3672 
    if result.success is not None:
3673 
      return result.success
3674 
    if result.ex is not None:
3675 
      raise result.ex
3676 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "shiftToWarehouse failed: unknown result");
3677 
 
4647 rajveer 3678 
  def addDelayReason(self, orderId, delayReason, furtherDelay, delayReasonText):
3553 chandransh 3679 
    """
3680 
    Adds the given delay reason to the given order.
3986 chandransh 3681 
    Increases the expected delivery time of the given order by the given no. of days.
3553 chandransh 3682 
    Raises an exception if no order with the given id can be found.
3469 chandransh 3683 
 
3553 chandransh 3684 
    Parameters:
3685 
     - orderId
3686 
     - delayReason
3986 chandransh 3687 
     - furtherDelay
4647 rajveer 3688 
     - delayReasonText
3553 chandransh 3689 
    """
4647 rajveer 3690 
    self.send_addDelayReason(orderId, delayReason, furtherDelay, delayReasonText)
3553 chandransh 3691 
    return self.recv_addDelayReason()
3692 
 
4647 rajveer 3693 
  def send_addDelayReason(self, orderId, delayReason, furtherDelay, delayReasonText):
3553 chandransh 3694 
    self._oprot.writeMessageBegin('addDelayReason', TMessageType.CALL, self._seqid)
3695 
    args = addDelayReason_args()
3696 
    args.orderId = orderId
3697 
    args.delayReason = delayReason
3986 chandransh 3698 
    args.furtherDelay = furtherDelay
4647 rajveer 3699 
    args.delayReasonText = delayReasonText
3553 chandransh 3700 
    args.write(self._oprot)
3701 
    self._oprot.writeMessageEnd()
3702 
    self._oprot.trans.flush()
3703 
 
3704 
  def recv_addDelayReason(self, ):
3705 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3706 
    if mtype == TMessageType.EXCEPTION:
3707 
      x = TApplicationException()
3708 
      x.read(self._iprot)
3709 
      self._iprot.readMessageEnd()
3710 
      raise x
3711 
    result = addDelayReason_result()
3712 
    result.read(self._iprot)
3713 
    self._iprot.readMessageEnd()
3714 
    if result.success is not None:
3715 
      return result.success
3716 
    if result.ex is not None:
3717 
      raise result.ex
3718 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "addDelayReason failed: unknown result");
3719 
 
3956 chandransh 3720 
  def reconcileCodCollection(self, collectedAmountMap, xferBy, xferTxnId, xferDate):
3721 
    """
3722 
    Marks the COD orders with given AWB nos. as having been processed.
3723 
    Updates the captured amount for the corresponding payment.
3553 chandransh 3724 
 
3956 chandransh 3725 
    Returns a map of AWBs which were not processed and the associated reason. An AWB is not processed if:
3726 
    1. There is no order corresponding to an AWB number.
3727 
    2. The captured amount for a payment exceeds the total payment.
3728 
    3. The order corresponding to an AWB no. is in a state prior to DELIVERY_SUCCESS.
3729 
 
3730 
    Parameters:
3731 
     - collectedAmountMap
3732 
     - xferBy
3733 
     - xferTxnId
3734 
     - xferDate
3735 
    """
3736 
    self.send_reconcileCodCollection(collectedAmountMap, xferBy, xferTxnId, xferDate)
3737 
    return self.recv_reconcileCodCollection()
3738 
 
3739 
  def send_reconcileCodCollection(self, collectedAmountMap, xferBy, xferTxnId, xferDate):
3740 
    self._oprot.writeMessageBegin('reconcileCodCollection', TMessageType.CALL, self._seqid)
3741 
    args = reconcileCodCollection_args()
3742 
    args.collectedAmountMap = collectedAmountMap
3743 
    args.xferBy = xferBy
3744 
    args.xferTxnId = xferTxnId
3745 
    args.xferDate = xferDate
3746 
    args.write(self._oprot)
3747 
    self._oprot.writeMessageEnd()
3748 
    self._oprot.trans.flush()
3749 
 
3750 
  def recv_reconcileCodCollection(self, ):
3751 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3752 
    if mtype == TMessageType.EXCEPTION:
3753 
      x = TApplicationException()
3754 
      x.read(self._iprot)
3755 
      self._iprot.readMessageEnd()
3756 
      raise x
3757 
    result = reconcileCodCollection_result()
3758 
    result.read(self._iprot)
3759 
    self._iprot.readMessageEnd()
3760 
    if result.success is not None:
3761 
      return result.success
3762 
    if result.ex is not None:
3763 
      raise result.ex
3764 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "reconcileCodCollection failed: unknown result");
3765 
 
4008 mandeep.dh 3766 
  def getTransactionsRequiringExtraProcessing(self, category):
3767 
    """
4065 mandeep.dh 3768 
    Returns the list of transaction ids that require some extra processing and
4008 mandeep.dh 3769 
    which belong to a particular category. This is currently used by CRM
4065 mandeep.dh 3770 
    application. If no such transaction ids are present, it returns an empty list.
3956 chandransh 3771 
 
4008 mandeep.dh 3772 
    Parameters:
3773 
     - category
3774 
    """
3775 
    self.send_getTransactionsRequiringExtraProcessing(category)
3776 
    return self.recv_getTransactionsRequiringExtraProcessing()
3777 
 
3778 
  def send_getTransactionsRequiringExtraProcessing(self, category):
3779 
    self._oprot.writeMessageBegin('getTransactionsRequiringExtraProcessing', TMessageType.CALL, self._seqid)
3780 
    args = getTransactionsRequiringExtraProcessing_args()
3781 
    args.category = category
3782 
    args.write(self._oprot)
3783 
    self._oprot.writeMessageEnd()
3784 
    self._oprot.trans.flush()
3785 
 
3786 
  def recv_getTransactionsRequiringExtraProcessing(self, ):
3787 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3788 
    if mtype == TMessageType.EXCEPTION:
3789 
      x = TApplicationException()
3790 
      x.read(self._iprot)
3791 
      self._iprot.readMessageEnd()
3792 
      raise x
3793 
    result = getTransactionsRequiringExtraProcessing_result()
3794 
    result.read(self._iprot)
3795 
    self._iprot.readMessageEnd()
3796 
    if result.success is not None:
3797 
      return result.success
3798 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getTransactionsRequiringExtraProcessing failed: unknown result");
3799 
 
3800 
  def markTransactionAsProcessed(self, transactionId, category):
3801 
    """
3802 
    Marks a particular transaction as processed for a particular cateogory.
4065 mandeep.dh 3803 
    It essentially deletes the transaction id record for a particular
3804 
    processing type category (if present) from DB.
3805 
    This is currently used by CRM application.
4008 mandeep.dh 3806 
 
3807 
    Parameters:
3808 
     - transactionId
3809 
     - category
3810 
    """
3811 
    self.send_markTransactionAsProcessed(transactionId, category)
3812 
    self.recv_markTransactionAsProcessed()
3813 
 
3814 
  def send_markTransactionAsProcessed(self, transactionId, category):
3815 
    self._oprot.writeMessageBegin('markTransactionAsProcessed', TMessageType.CALL, self._seqid)
3816 
    args = markTransactionAsProcessed_args()
3817 
    args.transactionId = transactionId
3818 
    args.category = category
3819 
    args.write(self._oprot)
3820 
    self._oprot.writeMessageEnd()
3821 
    self._oprot.trans.flush()
3822 
 
3823 
  def recv_markTransactionAsProcessed(self, ):
3824 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3825 
    if mtype == TMessageType.EXCEPTION:
3826 
      x = TApplicationException()
3827 
      x.read(self._iprot)
3828 
      self._iprot.readMessageEnd()
3829 
      raise x
3830 
    result = markTransactionAsProcessed_result()
3831 
    result.read(self._iprot)
3832 
    self._iprot.readMessageEnd()
3833 
    return
3834 
 
4018 chandransh 3835 
  def getItemWiseRiskyOrdersCount(self, ):
3836 
    """
3837 
    Returns a map containing the number of risky orders keyed by item id. A risky order
3838 
    is defined as one whose shipping date is about to expire.
3839 
    """
3840 
    self.send_getItemWiseRiskyOrdersCount()
3841 
    return self.recv_getItemWiseRiskyOrdersCount()
4008 mandeep.dh 3842 
 
4018 chandransh 3843 
  def send_getItemWiseRiskyOrdersCount(self, ):
3844 
    self._oprot.writeMessageBegin('getItemWiseRiskyOrdersCount', TMessageType.CALL, self._seqid)
3845 
    args = getItemWiseRiskyOrdersCount_args()
3846 
    args.write(self._oprot)
3847 
    self._oprot.writeMessageEnd()
3848 
    self._oprot.trans.flush()
3849 
 
3850 
  def recv_getItemWiseRiskyOrdersCount(self, ):
3851 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3852 
    if mtype == TMessageType.EXCEPTION:
3853 
      x = TApplicationException()
3854 
      x.read(self._iprot)
3855 
      self._iprot.readMessageEnd()
3856 
      raise x
3857 
    result = getItemWiseRiskyOrdersCount_result()
3858 
    result.read(self._iprot)
3859 
    self._iprot.readMessageEnd()
3860 
    if result.success is not None:
3861 
      return result.success
3862 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getItemWiseRiskyOrdersCount failed: unknown result");
3863 
 
4295 varun.gupt 3864 
  def getOrdersForItemIds(self, itemIds):
3865 
    """
3866 
    Returns a list of all orders which have items with given id
3867 
 
3868 
    Parameters:
3869 
     - itemIds
3870 
    """
3871 
    self.send_getOrdersForItemIds(itemIds)
3872 
    return self.recv_getOrdersForItemIds()
3873 
 
3874 
  def send_getOrdersForItemIds(self, itemIds):
3875 
    self._oprot.writeMessageBegin('getOrdersForItemIds', TMessageType.CALL, self._seqid)
3876 
    args = getOrdersForItemIds_args()
3877 
    args.itemIds = itemIds
3878 
    args.write(self._oprot)
3879 
    self._oprot.writeMessageEnd()
3880 
    self._oprot.trans.flush()
3881 
 
3882 
  def recv_getOrdersForItemIds(self, ):
3883 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3884 
    if mtype == TMessageType.EXCEPTION:
3885 
      x = TApplicationException()
3886 
      x.read(self._iprot)
3887 
      self._iprot.readMessageEnd()
3888 
      raise x
3889 
    result = getOrdersForItemIds_result()
3890 
    result.read(self._iprot)
3891 
    self._iprot.readMessageEnd()
3892 
    if result.success is not None:
3893 
      return result.success
3894 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getOrdersForItemIds failed: unknown result");
3895 
 
4247 rajveer 3896 
  def markOrderCancellationRequestReceived(self, orderId):
3897 
    """
3898 
    Mark order as cancellation request received. If customer sends request of cancellation of
3899 
    a particular order, this method will be called. It will just change status of the order
3900 
    depending on its current status. It also records the previous status, so that we can move
3901 
    back to that status if cancellation request is denied.
4018 chandransh 3902 
 
4247 rajveer 3903 
    Parameters:
3904 
     - orderId
3905 
    """
3906 
    self.send_markOrderCancellationRequestReceived(orderId)
3907 
    self.recv_markOrderCancellationRequestReceived()
3908 
 
3909 
  def send_markOrderCancellationRequestReceived(self, orderId):
3910 
    self._oprot.writeMessageBegin('markOrderCancellationRequestReceived', TMessageType.CALL, self._seqid)
3911 
    args = markOrderCancellationRequestReceived_args()
3912 
    args.orderId = orderId
3913 
    args.write(self._oprot)
3914 
    self._oprot.writeMessageEnd()
3915 
    self._oprot.trans.flush()
3916 
 
3917 
  def recv_markOrderCancellationRequestReceived(self, ):
3918 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3919 
    if mtype == TMessageType.EXCEPTION:
3920 
      x = TApplicationException()
3921 
      x.read(self._iprot)
3922 
      self._iprot.readMessageEnd()
3923 
      raise x
3924 
    result = markOrderCancellationRequestReceived_result()
3925 
    result.read(self._iprot)
3926 
    self._iprot.readMessageEnd()
3927 
    if result.ex is not None:
3928 
      raise result.ex
3929 
    return
3930 
 
3931 
  def markOrderCancellationRequestConfirmed(self, orderId):
3932 
    """
3933 
    If we decide to to cancel order, CRM will call this method to move the status of order to
3934 
    cancellation request confirmed. After this OM will be able to cancel the order.
3935 
 
3936 
    Parameters:
3937 
     - orderId
3938 
    """
3939 
    self.send_markOrderCancellationRequestConfirmed(orderId)
3940 
    self.recv_markOrderCancellationRequestConfirmed()
3941 
 
3942 
  def send_markOrderCancellationRequestConfirmed(self, orderId):
3943 
    self._oprot.writeMessageBegin('markOrderCancellationRequestConfirmed', TMessageType.CALL, self._seqid)
3944 
    args = markOrderCancellationRequestConfirmed_args()
3945 
    args.orderId = orderId
3946 
    args.write(self._oprot)
3947 
    self._oprot.writeMessageEnd()
3948 
    self._oprot.trans.flush()
3949 
 
3950 
  def recv_markOrderCancellationRequestConfirmed(self, ):
3951 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3952 
    if mtype == TMessageType.EXCEPTION:
3953 
      x = TApplicationException()
3954 
      x.read(self._iprot)
3955 
      self._iprot.readMessageEnd()
3956 
      raise x
3957 
    result = markOrderCancellationRequestConfirmed_result()
3958 
    result.read(self._iprot)
3959 
    self._iprot.readMessageEnd()
3960 
    if result.ex is not None:
3961 
      raise result.ex
3962 
    return
3963 
 
3964 
  def markOrderCancellationRequestDenied(self, orderId):
3965 
    """
3966 
    If we decide to not to cancel order, we will move the order ro previous status.
3967 
 
3968 
    Parameters:
3969 
     - orderId
3970 
    """
3971 
    self.send_markOrderCancellationRequestDenied(orderId)
3972 
    self.recv_markOrderCancellationRequestDenied()
3973 
 
3974 
  def send_markOrderCancellationRequestDenied(self, orderId):
3975 
    self._oprot.writeMessageBegin('markOrderCancellationRequestDenied', TMessageType.CALL, self._seqid)
3976 
    args = markOrderCancellationRequestDenied_args()
3977 
    args.orderId = orderId
3978 
    args.write(self._oprot)
3979 
    self._oprot.writeMessageEnd()
3980 
    self._oprot.trans.flush()
3981 
 
3982 
  def recv_markOrderCancellationRequestDenied(self, ):
3983 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3984 
    if mtype == TMessageType.EXCEPTION:
3985 
      x = TApplicationException()
3986 
      x.read(self._iprot)
3987 
      self._iprot.readMessageEnd()
3988 
      raise x
3989 
    result = markOrderCancellationRequestDenied_result()
3990 
    result.read(self._iprot)
3991 
    self._iprot.readMessageEnd()
3992 
    if result.ex is not None:
3993 
      raise result.ex
3994 
    return
3995 
 
4258 rajveer 3996 
  def markTransactionAsPaymentFlagRemoved(self, transactionId):
4247 rajveer 3997 
    """
4258 rajveer 3998 
    If we and/or payment gateway has decided to accept the payment, this method needs to be called.
3999 
    Changed transaction and all orders status to payment accepted.
4247 rajveer 4000 
 
4001 
    Parameters:
4258 rajveer 4002 
     - transactionId
4247 rajveer 4003 
    """
4258 rajveer 4004 
    self.send_markTransactionAsPaymentFlagRemoved(transactionId)
4005 
    self.recv_markTransactionAsPaymentFlagRemoved()
4247 rajveer 4006 
 
4258 rajveer 4007 
  def send_markTransactionAsPaymentFlagRemoved(self, transactionId):
4008 
    self._oprot.writeMessageBegin('markTransactionAsPaymentFlagRemoved', TMessageType.CALL, self._seqid)
4009 
    args = markTransactionAsPaymentFlagRemoved_args()
4010 
    args.transactionId = transactionId
4247 rajveer 4011 
    args.write(self._oprot)
4012 
    self._oprot.writeMessageEnd()
4013 
    self._oprot.trans.flush()
4014 
 
4258 rajveer 4015 
  def recv_markTransactionAsPaymentFlagRemoved(self, ):
4247 rajveer 4016 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4017 
    if mtype == TMessageType.EXCEPTION:
4018 
      x = TApplicationException()
4019 
      x.read(self._iprot)
4020 
      self._iprot.readMessageEnd()
4021 
      raise x
4258 rajveer 4022 
    result = markTransactionAsPaymentFlagRemoved_result()
4247 rajveer 4023 
    result.read(self._iprot)
4024 
    self._iprot.readMessageEnd()
4025 
    if result.ex is not None:
4026 
      raise result.ex
4027 
    return
4028 
 
4259 anupam.sin 4029 
  def refundTransaction(self, transactionId, refundedBy, reason):
4030 
    """
4031 
    This method is called when a flagged payment is deemed unserviceable and the corresponding orders
4032 
    need to be cancelled
4247 rajveer 4033 
 
4259 anupam.sin 4034 
    Parameters:
4035 
     - transactionId
4036 
     - refundedBy
4037 
     - reason
4038 
    """
4039 
    self.send_refundTransaction(transactionId, refundedBy, reason)
4040 
    self.recv_refundTransaction()
4041 
 
4042 
  def send_refundTransaction(self, transactionId, refundedBy, reason):
4043 
    self._oprot.writeMessageBegin('refundTransaction', TMessageType.CALL, self._seqid)
4044 
    args = refundTransaction_args()
4045 
    args.transactionId = transactionId
4046 
    args.refundedBy = refundedBy
4047 
    args.reason = reason
4048 
    args.write(self._oprot)
4049 
    self._oprot.writeMessageEnd()
4050 
    self._oprot.trans.flush()
4051 
 
4052 
  def recv_refundTransaction(self, ):
4053 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4054 
    if mtype == TMessageType.EXCEPTION:
4055 
      x = TApplicationException()
4056 
      x.read(self._iprot)
4057 
      self._iprot.readMessageEnd()
4058 
      raise x
4059 
    result = refundTransaction_result()
4060 
    result.read(self._iprot)
4061 
    self._iprot.readMessageEnd()
4062 
    if result.ex is not None:
4063 
      raise result.ex
4064 
    return
4065 
 
4324 mandeep.dh 4066 
  def updateShipmentAddress(self, orderId, addressId):
4067 
    """
4068 
    Updates shipment address of an order. Delivery and shipping date estimates
4069 
    etc. are also updated here.
4070 
 
4071 
    Throws TransactionServiceException in case address change is not
4072 
    possible due to certain reasons such as new pincode in address is
4073 
    not serviceable etc.
4074 
 
4075 
    Parameters:
4076 
     - orderId
4077 
     - addressId
4078 
    """
4079 
    self.send_updateShipmentAddress(orderId, addressId)
4080 
    self.recv_updateShipmentAddress()
4081 
 
4082 
  def send_updateShipmentAddress(self, orderId, addressId):
4083 
    self._oprot.writeMessageBegin('updateShipmentAddress', TMessageType.CALL, self._seqid)
4084 
    args = updateShipmentAddress_args()
4085 
    args.orderId = orderId
4086 
    args.addressId = addressId
4087 
    args.write(self._oprot)
4088 
    self._oprot.writeMessageEnd()
4089 
    self._oprot.trans.flush()
4090 
 
4091 
  def recv_updateShipmentAddress(self, ):
4092 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4093 
    if mtype == TMessageType.EXCEPTION:
4094 
      x = TApplicationException()
4095 
      x.read(self._iprot)
4096 
      self._iprot.readMessageEnd()
4097 
      raise x
4098 
    result = updateShipmentAddress_result()
4099 
    result.read(self._iprot)
4100 
    self._iprot.readMessageEnd()
4101 
    if result.ex is not None:
4102 
      raise result.ex
4103 
    return
4104 
 
4285 rajveer 4105 
  def acceptOrdersForItemId(self, itemId, inventory):
4106 
    """
4107 
    Marks the orders as ACCEPTED for the given itemId and inventory. It also updates the accepted timestamp. If the
4108 
    given order is not a COD order, it also captures the payment if the same has not been captured.
4259 anupam.sin 4109 
 
4285 rajveer 4110 
    Parameters:
4111 
     - itemId
4112 
     - inventory
4113 
    """
4114 
    self.send_acceptOrdersForItemId(itemId, inventory)
4115 
    return self.recv_acceptOrdersForItemId()
4116 
 
4117 
  def send_acceptOrdersForItemId(self, itemId, inventory):
4118 
    self._oprot.writeMessageBegin('acceptOrdersForItemId', TMessageType.CALL, self._seqid)
4119 
    args = acceptOrdersForItemId_args()
4120 
    args.itemId = itemId
4121 
    args.inventory = inventory
4122 
    args.write(self._oprot)
4123 
    self._oprot.writeMessageEnd()
4124 
    self._oprot.trans.flush()
4125 
 
4126 
  def recv_acceptOrdersForItemId(self, ):
4127 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4128 
    if mtype == TMessageType.EXCEPTION:
4129 
      x = TApplicationException()
4130 
      x.read(self._iprot)
4131 
      self._iprot.readMessageEnd()
4132 
      raise x
4133 
    result = acceptOrdersForItemId_result()
4134 
    result.read(self._iprot)
4135 
    self._iprot.readMessageEnd()
4136 
    if result.success is not None:
4137 
      return result.success
4138 
    if result.ex is not None:
4139 
      raise result.ex
4140 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "acceptOrdersForItemId failed: unknown result");
4141 
 
4369 rajveer 4142 
  def markOrdersAsPORaised(self, vendorId, itemId, quantity, estimate, isReminder):
4303 rajveer 4143 
    """
4144 
    Parameters:
4145 
     - vendorId
4146 
     - itemId
4147 
     - quantity
4148 
     - estimate
4369 rajveer 4149 
     - isReminder
4303 rajveer 4150 
    """
4369 rajveer 4151 
    self.send_markOrdersAsPORaised(vendorId, itemId, quantity, estimate, isReminder)
4303 rajveer 4152 
    self.recv_markOrdersAsPORaised()
4285 rajveer 4153 
 
4369 rajveer 4154 
  def send_markOrdersAsPORaised(self, vendorId, itemId, quantity, estimate, isReminder):
4303 rajveer 4155 
    self._oprot.writeMessageBegin('markOrdersAsPORaised', TMessageType.CALL, self._seqid)
4156 
    args = markOrdersAsPORaised_args()
4157 
    args.vendorId = vendorId
4158 
    args.itemId = itemId
4159 
    args.quantity = quantity
4160 
    args.estimate = estimate
4369 rajveer 4161 
    args.isReminder = isReminder
4303 rajveer 4162 
    args.write(self._oprot)
4163 
    self._oprot.writeMessageEnd()
4164 
    self._oprot.trans.flush()
4165 
 
4166 
  def recv_markOrdersAsPORaised(self, ):
4167 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4168 
    if mtype == TMessageType.EXCEPTION:
4169 
      x = TApplicationException()
4170 
      x.read(self._iprot)
4171 
      self._iprot.readMessageEnd()
4172 
      raise x
4173 
    result = markOrdersAsPORaised_result()
4174 
    result.read(self._iprot)
4175 
    self._iprot.readMessageEnd()
4176 
    if result.ex is not None:
4177 
      raise result.ex
4178 
    return
4179 
 
4369 rajveer 4180 
  def markOrdersAsReversalInitiated(self, vendorId, itemId, quantity, estimate, isReminder):
4303 rajveer 4181 
    """
4182 
    Parameters:
4183 
     - vendorId
4184 
     - itemId
4185 
     - quantity
4186 
     - estimate
4369 rajveer 4187 
     - isReminder
4303 rajveer 4188 
    """
4369 rajveer 4189 
    self.send_markOrdersAsReversalInitiated(vendorId, itemId, quantity, estimate, isReminder)
4303 rajveer 4190 
    self.recv_markOrdersAsReversalInitiated()
4191 
 
4369 rajveer 4192 
  def send_markOrdersAsReversalInitiated(self, vendorId, itemId, quantity, estimate, isReminder):
4303 rajveer 4193 
    self._oprot.writeMessageBegin('markOrdersAsReversalInitiated', TMessageType.CALL, self._seqid)
4194 
    args = markOrdersAsReversalInitiated_args()
4195 
    args.vendorId = vendorId
4196 
    args.itemId = itemId
4197 
    args.quantity = quantity
4198 
    args.estimate = estimate
4369 rajveer 4199 
    args.isReminder = isReminder
4303 rajveer 4200 
    args.write(self._oprot)
4201 
    self._oprot.writeMessageEnd()
4202 
    self._oprot.trans.flush()
4203 
 
4204 
  def recv_markOrdersAsReversalInitiated(self, ):
4205 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4206 
    if mtype == TMessageType.EXCEPTION:
4207 
      x = TApplicationException()
4208 
      x.read(self._iprot)
4209 
      self._iprot.readMessageEnd()
4210 
      raise x
4211 
    result = markOrdersAsReversalInitiated_result()
4212 
    result.read(self._iprot)
4213 
    self._iprot.readMessageEnd()
4214 
    if result.ex is not None:
4215 
      raise result.ex
4216 
    return
4217 
 
4369 rajveer 4218 
  def markOrdersAsNotAvailabke(self, vendorId, itemId, quantity, estimate, isReminder):
4303 rajveer 4219 
    """
4220 
    Parameters:
4221 
     - vendorId
4222 
     - itemId
4223 
     - quantity
4224 
     - estimate
4369 rajveer 4225 
     - isReminder
4303 rajveer 4226 
    """
4369 rajveer 4227 
    self.send_markOrdersAsNotAvailabke(vendorId, itemId, quantity, estimate, isReminder)
4303 rajveer 4228 
    self.recv_markOrdersAsNotAvailabke()
4229 
 
4369 rajveer 4230 
  def send_markOrdersAsNotAvailabke(self, vendorId, itemId, quantity, estimate, isReminder):
4303 rajveer 4231 
    self._oprot.writeMessageBegin('markOrdersAsNotAvailabke', TMessageType.CALL, self._seqid)
4232 
    args = markOrdersAsNotAvailabke_args()
4233 
    args.vendorId = vendorId
4234 
    args.itemId = itemId
4235 
    args.quantity = quantity
4236 
    args.estimate = estimate
4369 rajveer 4237 
    args.isReminder = isReminder
4303 rajveer 4238 
    args.write(self._oprot)
4239 
    self._oprot.writeMessageEnd()
4240 
    self._oprot.trans.flush()
4241 
 
4242 
  def recv_markOrdersAsNotAvailabke(self, ):
4243 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4244 
    if mtype == TMessageType.EXCEPTION:
4245 
      x = TApplicationException()
4246 
      x.read(self._iprot)
4247 
      self._iprot.readMessageEnd()
4248 
      raise x
4249 
    result = markOrdersAsNotAvailabke_result()
4250 
    result.read(self._iprot)
4251 
    self._iprot.readMessageEnd()
4252 
    if result.ex is not None:
4253 
      raise result.ex
4254 
    return
4255 
 
4369 rajveer 4256 
  def markOrdersAsTimeout(self, vendorId):
4257 
    """
4258 
    Parameters:
4259 
     - vendorId
4260 
    """
4261 
    self.send_markOrdersAsTimeout(vendorId)
4262 
    return self.recv_markOrdersAsTimeout()
4303 rajveer 4263 
 
4369 rajveer 4264 
  def send_markOrdersAsTimeout(self, vendorId):
4265 
    self._oprot.writeMessageBegin('markOrdersAsTimeout', TMessageType.CALL, self._seqid)
4266 
    args = markOrdersAsTimeout_args()
4267 
    args.vendorId = vendorId
4268 
    args.write(self._oprot)
4269 
    self._oprot.writeMessageEnd()
4270 
    self._oprot.trans.flush()
4271 
 
4272 
  def recv_markOrdersAsTimeout(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 = markOrdersAsTimeout_result()
4280 
    result.read(self._iprot)
4281 
    self._iprot.readMessageEnd()
4282 
    if result.success is not None:
4283 
      return result.success
4284 
    if result.ex is not None:
4285 
      raise result.ex
4286 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "markOrdersAsTimeout failed: unknown result");
4287 
 
4662 rajveer 4288 
  def markOrderAsLostInTransit(self, orderId):
4289 
    """
4290 
    Mark order as LOST_IN_TRANSIT
4291 
 
4292 
    Parameters:
4293 
     - orderId
4294 
    """
4295 
    self.send_markOrderAsLostInTransit(orderId)
4296 
    return self.recv_markOrderAsLostInTransit()
4297 
 
4298 
  def send_markOrderAsLostInTransit(self, orderId):
4299 
    self._oprot.writeMessageBegin('markOrderAsLostInTransit', TMessageType.CALL, self._seqid)
4300 
    args = markOrderAsLostInTransit_args()
4301 
    args.orderId = orderId
4302 
    args.write(self._oprot)
4303 
    self._oprot.writeMessageEnd()
4304 
    self._oprot.trans.flush()
4305 
 
4306 
  def recv_markOrderAsLostInTransit(self, ):
4307 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4308 
    if mtype == TMessageType.EXCEPTION:
4309 
      x = TApplicationException()
4310 
      x.read(self._iprot)
4311 
      self._iprot.readMessageEnd()
4312 
      raise x
4313 
    result = markOrderAsLostInTransit_result()
4314 
    result.read(self._iprot)
4315 
    self._iprot.readMessageEnd()
4316 
    if result.success is not None:
4317 
      return result.success
4318 
    if result.ex is not None:
4319 
      raise result.ex
4320 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "markOrderAsLostInTransit failed: unknown result");
4321 
 
4386 anupam.sin 4322 
  def getOrderForAwb(self, awb):
4323 
    """
4324 
    Returns the order corresponding to an AWB number
4369 rajveer 4325 
 
4386 anupam.sin 4326 
    Parameters:
4327 
     - awb
4328 
    """
4329 
    self.send_getOrderForAwb(awb)
4330 
    return self.recv_getOrderForAwb()
4331 
 
4332 
  def send_getOrderForAwb(self, awb):
4333 
    self._oprot.writeMessageBegin('getOrderForAwb', TMessageType.CALL, self._seqid)
4334 
    args = getOrderForAwb_args()
4335 
    args.awb = awb
4336 
    args.write(self._oprot)
4337 
    self._oprot.writeMessageEnd()
4338 
    self._oprot.trans.flush()
4339 
 
4340 
  def recv_getOrderForAwb(self, ):
4341 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4342 
    if mtype == TMessageType.EXCEPTION:
4343 
      x = TApplicationException()
4344 
      x.read(self._iprot)
4345 
      self._iprot.readMessageEnd()
4346 
      raise x
4347 
    result = getOrderForAwb_result()
4348 
    result.read(self._iprot)
4349 
    self._iprot.readMessageEnd()
4350 
    if result.success is not None:
4351 
      return result.success
4352 
    if result.ex is not None:
4353 
      raise result.ex
4354 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getOrderForAwb failed: unknown result");
4355 
 
4910 phani.kuma 4356 
  def getOrdersForProviderForStatus(self, logistics_provider_id, order_status_list):
4506 phani.kuma 4357 
    """
4910 phani.kuma 4358 
    Returns the order corresponding to a logistics provider id for a given list of order status
4386 anupam.sin 4359 
 
4506 phani.kuma 4360 
    Parameters:
4361 
     - logistics_provider_id
4910 phani.kuma 4362 
     - order_status_list
4506 phani.kuma 4363 
    """
4910 phani.kuma 4364 
    self.send_getOrdersForProviderForStatus(logistics_provider_id, order_status_list)
4506 phani.kuma 4365 
    return self.recv_getOrdersForProviderForStatus()
4366 
 
4910 phani.kuma 4367 
  def send_getOrdersForProviderForStatus(self, logistics_provider_id, order_status_list):
4506 phani.kuma 4368 
    self._oprot.writeMessageBegin('getOrdersForProviderForStatus', TMessageType.CALL, self._seqid)
4369 
    args = getOrdersForProviderForStatus_args()
4370 
    args.logistics_provider_id = logistics_provider_id
4910 phani.kuma 4371 
    args.order_status_list = order_status_list
4506 phani.kuma 4372 
    args.write(self._oprot)
4373 
    self._oprot.writeMessageEnd()
4374 
    self._oprot.trans.flush()
4375 
 
4376 
  def recv_getOrdersForProviderForStatus(self, ):
4377 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4378 
    if mtype == TMessageType.EXCEPTION:
4379 
      x = TApplicationException()
4380 
      x.read(self._iprot)
4381 
      self._iprot.readMessageEnd()
4382 
      raise x
4383 
    result = getOrdersForProviderForStatus_result()
4384 
    result.read(self._iprot)
4385 
    self._iprot.readMessageEnd()
4386 
    if result.success is not None:
4387 
      return result.success
4388 
    if result.ex is not None:
4389 
      raise result.ex
4390 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getOrdersForProviderForStatus failed: unknown result");
4391 
 
4600 varun.gupt 4392 
  def getBilledOrdersForVendor(self, vendorId, billingDateFrom, billingDateTo):
4393 
    """
4394 
    Returns list of orders fullfiled from a certain vendor and billed in a given date range
4506 phani.kuma 4395 
 
4600 varun.gupt 4396 
    Parameters:
4397 
     - vendorId
4398 
     - billingDateFrom
4399 
     - billingDateTo
4400 
    """
4401 
    self.send_getBilledOrdersForVendor(vendorId, billingDateFrom, billingDateTo)
4402 
    return self.recv_getBilledOrdersForVendor()
4403 
 
4404 
  def send_getBilledOrdersForVendor(self, vendorId, billingDateFrom, billingDateTo):
4405 
    self._oprot.writeMessageBegin('getBilledOrdersForVendor', TMessageType.CALL, self._seqid)
4406 
    args = getBilledOrdersForVendor_args()
4407 
    args.vendorId = vendorId
4408 
    args.billingDateFrom = billingDateFrom
4409 
    args.billingDateTo = billingDateTo
4410 
    args.write(self._oprot)
4411 
    self._oprot.writeMessageEnd()
4412 
    self._oprot.trans.flush()
4413 
 
4414 
  def recv_getBilledOrdersForVendor(self, ):
4415 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4416 
    if mtype == TMessageType.EXCEPTION:
4417 
      x = TApplicationException()
4418 
      x.read(self._iprot)
4419 
      self._iprot.readMessageEnd()
4420 
      raise x
4421 
    result = getBilledOrdersForVendor_result()
4422 
    result.read(self._iprot)
4423 
    self._iprot.readMessageEnd()
4424 
    if result.success is not None:
4425 
      return result.success
4426 
    if result.ex is not None:
4427 
      raise result.ex
4428 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getBilledOrdersForVendor failed: unknown result");
4429 
 
4607 rajveer 4430 
  def getSlippedSippingDateOrders(self, ):
4431 
    self.send_getSlippedSippingDateOrders()
4432 
    return self.recv_getSlippedSippingDateOrders()
4433 
 
4434 
  def send_getSlippedSippingDateOrders(self, ):
4435 
    self._oprot.writeMessageBegin('getSlippedSippingDateOrders', TMessageType.CALL, self._seqid)
4436 
    args = getSlippedSippingDateOrders_args()
4437 
    args.write(self._oprot)
4438 
    self._oprot.writeMessageEnd()
4439 
    self._oprot.trans.flush()
4440 
 
4441 
  def recv_getSlippedSippingDateOrders(self, ):
4442 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4443 
    if mtype == TMessageType.EXCEPTION:
4444 
      x = TApplicationException()
4445 
      x.read(self._iprot)
4446 
      self._iprot.readMessageEnd()
4447 
      raise x
4448 
    result = getSlippedSippingDateOrders_result()
4449 
    result.read(self._iprot)
4450 
    self._iprot.readMessageEnd()
4451 
    if result.success is not None:
4452 
      return result.success
4453 
    if result.ex is not None:
4454 
      raise result.ex
4455 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getSlippedSippingDateOrders failed: unknown result");
4456 
 
4709 rajveer 4457 
  def getCancelledOrders(self, cancelDateFrom, cancelDateTo):
4458 
    """
4459 
    Parameters:
4460 
     - cancelDateFrom
4461 
     - cancelDateTo
4462 
    """
4463 
    self.send_getCancelledOrders(cancelDateFrom, cancelDateTo)
4464 
    return self.recv_getCancelledOrders()
4465 
 
4466 
  def send_getCancelledOrders(self, cancelDateFrom, cancelDateTo):
4467 
    self._oprot.writeMessageBegin('getCancelledOrders', TMessageType.CALL, self._seqid)
4468 
    args = getCancelledOrders_args()
4469 
    args.cancelDateFrom = cancelDateFrom
4470 
    args.cancelDateTo = cancelDateTo
4471 
    args.write(self._oprot)
4472 
    self._oprot.writeMessageEnd()
4473 
    self._oprot.trans.flush()
4474 
 
4475 
  def recv_getCancelledOrders(self, ):
4476 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4477 
    if mtype == TMessageType.EXCEPTION:
4478 
      x = TApplicationException()
4479 
      x.read(self._iprot)
4480 
      self._iprot.readMessageEnd()
4481 
      raise x
4482 
    result = getCancelledOrders_result()
4483 
    result.read(self._iprot)
4484 
    self._iprot.readMessageEnd()
4485 
    if result.success is not None:
4486 
      return result.success
4487 
    if result.ex is not None:
4488 
      raise result.ex
4489 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getCancelledOrders failed: unknown result");
4490 
 
4600 varun.gupt 4491 
  def saveBluedartSettlements(self, mapAWBAndAmount):
4492 
    """
4493 
    Parameters:
4494 
     - mapAWBAndAmount
4495 
    """
4496 
    self.send_saveBluedartSettlements(mapAWBAndAmount)
4497 
    self.recv_saveBluedartSettlements()
4498 
 
4499 
  def send_saveBluedartSettlements(self, mapAWBAndAmount):
4500 
    self._oprot.writeMessageBegin('saveBluedartSettlements', TMessageType.CALL, self._seqid)
4501 
    args = saveBluedartSettlements_args()
4502 
    args.mapAWBAndAmount = mapAWBAndAmount
4503 
    args.write(self._oprot)
4504 
    self._oprot.writeMessageEnd()
4505 
    self._oprot.trans.flush()
4506 
 
4507 
  def recv_saveBluedartSettlements(self, ):
4508 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4509 
    if mtype == TMessageType.EXCEPTION:
4510 
      x = TApplicationException()
4511 
      x.read(self._iprot)
4512 
      self._iprot.readMessageEnd()
4513 
      raise x
4514 
    result = saveBluedartSettlements_result()
4515 
    result.read(self._iprot)
4516 
    self._iprot.readMessageEnd()
4517 
    if result.ex is not None:
4518 
      raise result.ex
4519 
    return
4520 
 
4905 varun.gupt 4521 
  def savePaymentSettlements(self, settlementDate, paymentGatewayId, referenceId, serviceTax, otherCharges, netCollection):
4600 varun.gupt 4522 
    """
4523 
    Parameters:
4524 
     - settlementDate
4525 
     - paymentGatewayId
4905 varun.gupt 4526 
     - referenceId
4600 varun.gupt 4527 
     - serviceTax
4528 
     - otherCharges
4529 
     - netCollection
4530 
    """
4905 varun.gupt 4531 
    self.send_savePaymentSettlements(settlementDate, paymentGatewayId, referenceId, serviceTax, otherCharges, netCollection)
4600 varun.gupt 4532 
    self.recv_savePaymentSettlements()
4533 
 
4905 varun.gupt 4534 
  def send_savePaymentSettlements(self, settlementDate, paymentGatewayId, referenceId, serviceTax, otherCharges, netCollection):
4600 varun.gupt 4535 
    self._oprot.writeMessageBegin('savePaymentSettlements', TMessageType.CALL, self._seqid)
4536 
    args = savePaymentSettlements_args()
4537 
    args.settlementDate = settlementDate
4538 
    args.paymentGatewayId = paymentGatewayId
4905 varun.gupt 4539 
    args.referenceId = referenceId
4600 varun.gupt 4540 
    args.serviceTax = serviceTax
4541 
    args.otherCharges = otherCharges
4542 
    args.netCollection = netCollection
4543 
    args.write(self._oprot)
4544 
    self._oprot.writeMessageEnd()
4545 
    self._oprot.trans.flush()
4546 
 
4547 
  def recv_savePaymentSettlements(self, ):
4548 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4549 
    if mtype == TMessageType.EXCEPTION:
4550 
      x = TApplicationException()
4551 
      x.read(self._iprot)
4552 
      self._iprot.readMessageEnd()
4553 
      raise x
4554 
    result = savePaymentSettlements_result()
4555 
    result.read(self._iprot)
4556 
    self._iprot.readMessageEnd()
4557 
    if result.ex is not None:
4558 
      raise result.ex
4559 
    return
4560 
 
4561 
  def saveEBSSettlementSummary(self, settlementId, settlementDate, transactionDateFrom, transactionDateTo, amount):
4562 
    """
4563 
    Parameters:
4564 
     - settlementId
4565 
     - settlementDate
4566 
     - transactionDateFrom
4567 
     - transactionDateTo
4568 
     - amount
4569 
    """
4570 
    self.send_saveEBSSettlementSummary(settlementId, settlementDate, transactionDateFrom, transactionDateTo, amount)
4571 
    self.recv_saveEBSSettlementSummary()
4572 
 
4573 
  def send_saveEBSSettlementSummary(self, settlementId, settlementDate, transactionDateFrom, transactionDateTo, amount):
4574 
    self._oprot.writeMessageBegin('saveEBSSettlementSummary', TMessageType.CALL, self._seqid)
4575 
    args = saveEBSSettlementSummary_args()
4576 
    args.settlementId = settlementId
4577 
    args.settlementDate = settlementDate
4578 
    args.transactionDateFrom = transactionDateFrom
4579 
    args.transactionDateTo = transactionDateTo
4580 
    args.amount = amount
4581 
    args.write(self._oprot)
4582 
    self._oprot.writeMessageEnd()
4583 
    self._oprot.trans.flush()
4584 
 
4585 
  def recv_saveEBSSettlementSummary(self, ):
4586 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4587 
    if mtype == TMessageType.EXCEPTION:
4588 
      x = TApplicationException()
4589 
      x.read(self._iprot)
4590 
      self._iprot.readMessageEnd()
4591 
      raise x
4592 
    result = saveEBSSettlementSummary_result()
4593 
    result.read(self._iprot)
4594 
    self._iprot.readMessageEnd()
4595 
    if result.ex is not None:
4596 
      raise result.ex
4597 
    return
4598 
 
4599 
  def getSettlementForPaymentId(self, paymentId):
4600 
    """
4601 
    Parameters:
4602 
     - paymentId
4603 
    """
4604 
    self.send_getSettlementForPaymentId(paymentId)
4605 
    return self.recv_getSettlementForPaymentId()
4606 
 
4607 
  def send_getSettlementForPaymentId(self, paymentId):
4608 
    self._oprot.writeMessageBegin('getSettlementForPaymentId', TMessageType.CALL, self._seqid)
4609 
    args = getSettlementForPaymentId_args()
4610 
    args.paymentId = paymentId
4611 
    args.write(self._oprot)
4612 
    self._oprot.writeMessageEnd()
4613 
    self._oprot.trans.flush()
4614 
 
4615 
  def recv_getSettlementForPaymentId(self, ):
4616 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4617 
    if mtype == TMessageType.EXCEPTION:
4618 
      x = TApplicationException()
4619 
      x.read(self._iprot)
4620 
      self._iprot.readMessageEnd()
4621 
      raise x
4622 
    result = getSettlementForPaymentId_result()
4623 
    result.read(self._iprot)
4624 
    self._iprot.readMessageEnd()
4625 
    if result.success is not None:
4626 
      return result.success
4627 
    if result.ex is not None:
4628 
      raise result.ex
4629 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getSettlementForPaymentId failed: unknown result");
4630 
 
4631 
  def getEBSSettlementSummaries(self, ):
4632 
    self.send_getEBSSettlementSummaries()
4633 
    return self.recv_getEBSSettlementSummaries()
4634 
 
4635 
  def send_getEBSSettlementSummaries(self, ):
4636 
    self._oprot.writeMessageBegin('getEBSSettlementSummaries', TMessageType.CALL, self._seqid)
4637 
    args = getEBSSettlementSummaries_args()
4638 
    args.write(self._oprot)
4639 
    self._oprot.writeMessageEnd()
4640 
    self._oprot.trans.flush()
4641 
 
4642 
  def recv_getEBSSettlementSummaries(self, ):
4643 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4644 
    if mtype == TMessageType.EXCEPTION:
4645 
      x = TApplicationException()
4646 
      x.read(self._iprot)
4647 
      self._iprot.readMessageEnd()
4648 
      raise x
4649 
    result = getEBSSettlementSummaries_result()
4650 
    result.read(self._iprot)
4651 
    self._iprot.readMessageEnd()
4652 
    if result.success is not None:
4653 
      return result.success
4654 
    if result.ex is not None:
4655 
      raise result.ex
4656 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getEBSSettlementSummaries failed: unknown result");
4657 
 
4658 
  def markEBSSettlementUploaded(self, settlementId):
4659 
    """
4660 
    Parameters:
4661 
     - settlementId
4662 
    """
4663 
    self.send_markEBSSettlementUploaded(settlementId)
4664 
    self.recv_markEBSSettlementUploaded()
4665 
 
4666 
  def send_markEBSSettlementUploaded(self, settlementId):
4667 
    self._oprot.writeMessageBegin('markEBSSettlementUploaded', TMessageType.CALL, self._seqid)
4668 
    args = markEBSSettlementUploaded_args()
4669 
    args.settlementId = settlementId
4670 
    args.write(self._oprot)
4671 
    self._oprot.writeMessageEnd()
4672 
    self._oprot.trans.flush()
4673 
 
4674 
  def recv_markEBSSettlementUploaded(self, ):
4675 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4676 
    if mtype == TMessageType.EXCEPTION:
4677 
      x = TApplicationException()
4678 
      x.read(self._iprot)
4679 
      self._iprot.readMessageEnd()
4680 
      raise x
4681 
    result = markEBSSettlementUploaded_result()
4682 
    result.read(self._iprot)
4683 
    self._iprot.readMessageEnd()
4684 
    if result.ex is not None:
4685 
      raise result.ex
4686 
    return
4687 
 
4688 
  def getEBSSettlementDate(self, settlementId):
4689 
    """
4690 
    Parameters:
4691 
     - settlementId
4692 
    """
4693 
    self.send_getEBSSettlementDate(settlementId)
4694 
    return self.recv_getEBSSettlementDate()
4695 
 
4696 
  def send_getEBSSettlementDate(self, settlementId):
4697 
    self._oprot.writeMessageBegin('getEBSSettlementDate', TMessageType.CALL, self._seqid)
4698 
    args = getEBSSettlementDate_args()
4699 
    args.settlementId = settlementId
4700 
    args.write(self._oprot)
4701 
    self._oprot.writeMessageEnd()
4702 
    self._oprot.trans.flush()
4703 
 
4704 
  def recv_getEBSSettlementDate(self, ):
4705 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4706 
    if mtype == TMessageType.EXCEPTION:
4707 
      x = TApplicationException()
4708 
      x.read(self._iprot)
4709 
      self._iprot.readMessageEnd()
4710 
      raise x
4711 
    result = getEBSSettlementDate_result()
4712 
    result.read(self._iprot)
4713 
    self._iprot.readMessageEnd()
4714 
    if result.success is not None:
4715 
      return result.success
4716 
    if result.ex is not None:
4717 
      raise result.ex
4718 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getEBSSettlementDate failed: unknown result");
4719 
 
4715 varun.gupt 4720 
  def getSettlementsByDate(self, settlementDateFrom, settlementDateTo, isRefund):
4721 
    """
4722 
    Parameters:
4723 
     - settlementDateFrom
4724 
     - settlementDateTo
4725 
     - isRefund
4726 
    """
4727 
    self.send_getSettlementsByDate(settlementDateFrom, settlementDateTo, isRefund)
4728 
    return self.recv_getSettlementsByDate()
4600 varun.gupt 4729 
 
4715 varun.gupt 4730 
  def send_getSettlementsByDate(self, settlementDateFrom, settlementDateTo, isRefund):
4731 
    self._oprot.writeMessageBegin('getSettlementsByDate', TMessageType.CALL, self._seqid)
4732 
    args = getSettlementsByDate_args()
4733 
    args.settlementDateFrom = settlementDateFrom
4734 
    args.settlementDateTo = settlementDateTo
4735 
    args.isRefund = isRefund
4736 
    args.write(self._oprot)
4737 
    self._oprot.writeMessageEnd()
4738 
    self._oprot.trans.flush()
4739 
 
4740 
  def recv_getSettlementsByDate(self, ):
4741 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4742 
    if mtype == TMessageType.EXCEPTION:
4743 
      x = TApplicationException()
4744 
      x.read(self._iprot)
4745 
      self._iprot.readMessageEnd()
4746 
      raise x
4747 
    result = getSettlementsByDate_result()
4748 
    result.read(self._iprot)
4749 
    self._iprot.readMessageEnd()
4750 
    if result.success is not None:
4751 
      return result.success
4752 
    if result.ex is not None:
4753 
      raise result.ex
4754 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getSettlementsByDate failed: unknown result");
4755 
 
4756 
  def getReshippedOrderIds(self, orderIds):
4757 
    """
4758 
    Returns list of Order Ids, which belong to reshiped orders, shortlisted from a given list of Order Ids
4759 
 
4760 
    Parameters:
4761 
     - orderIds
4762 
    """
4763 
    self.send_getReshippedOrderIds(orderIds)
4764 
    return self.recv_getReshippedOrderIds()
4765 
 
4766 
  def send_getReshippedOrderIds(self, orderIds):
4767 
    self._oprot.writeMessageBegin('getReshippedOrderIds', TMessageType.CALL, self._seqid)
4768 
    args = getReshippedOrderIds_args()
4769 
    args.orderIds = orderIds
4770 
    args.write(self._oprot)
4771 
    self._oprot.writeMessageEnd()
4772 
    self._oprot.trans.flush()
4773 
 
4774 
  def recv_getReshippedOrderIds(self, ):
4775 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4776 
    if mtype == TMessageType.EXCEPTION:
4777 
      x = TApplicationException()
4778 
      x.read(self._iprot)
4779 
      self._iprot.readMessageEnd()
4780 
      raise x
4781 
    result = getReshippedOrderIds_result()
4782 
    result.read(self._iprot)
4783 
    self._iprot.readMessageEnd()
4784 
    if result.success is not None:
4785 
      return result.success
4786 
    if result.ex is not None:
4787 
      raise result.ex
4788 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getReshippedOrderIds failed: unknown result");
4789 
 
4757 mandeep.dh 4790 
  def updateOrdersAsPORaised(self, itemIdQuantityMap, purchaseOrderId, warehouseId):
4791 
    """
4792 
    Updates orders as PO raised. Also updates purchase order id in orders. Pass a map of items mapped to
4793 
    the quantities for which the PO is raised.
4715 varun.gupt 4794 
 
4757 mandeep.dh 4795 
    Parameters:
4796 
     - itemIdQuantityMap
4797 
     - purchaseOrderId
4798 
     - warehouseId
4799 
    """
4800 
    self.send_updateOrdersAsPORaised(itemIdQuantityMap, purchaseOrderId, warehouseId)
4801 
    self.recv_updateOrdersAsPORaised()
4802 
 
4803 
  def send_updateOrdersAsPORaised(self, itemIdQuantityMap, purchaseOrderId, warehouseId):
4804 
    self._oprot.writeMessageBegin('updateOrdersAsPORaised', TMessageType.CALL, self._seqid)
4805 
    args = updateOrdersAsPORaised_args()
4806 
    args.itemIdQuantityMap = itemIdQuantityMap
4807 
    args.purchaseOrderId = purchaseOrderId
4808 
    args.warehouseId = warehouseId
4809 
    args.write(self._oprot)
4810 
    self._oprot.writeMessageEnd()
4811 
    self._oprot.trans.flush()
4812 
 
4813 
  def recv_updateOrdersAsPORaised(self, ):
4814 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4815 
    if mtype == TMessageType.EXCEPTION:
4816 
      x = TApplicationException()
4817 
      x.read(self._iprot)
4818 
      self._iprot.readMessageEnd()
4819 
      raise x
4820 
    result = updateOrdersAsPORaised_result()
4821 
    result.read(self._iprot)
4822 
    self._iprot.readMessageEnd()
4823 
    if result.ex is not None:
4824 
      raise result.ex
4825 
    return
4826 
 
4875 varun.gupt 4827 
  def getOrdersWhereVendorNotPaid(self, vendorId):
4828 
    """
4829 
    Parameters:
4830 
     - vendorId
4831 
    """
4832 
    self.send_getOrdersWhereVendorNotPaid(vendorId)
4833 
    return self.recv_getOrdersWhereVendorNotPaid()
4757 mandeep.dh 4834 
 
4875 varun.gupt 4835 
  def send_getOrdersWhereVendorNotPaid(self, vendorId):
4836 
    self._oprot.writeMessageBegin('getOrdersWhereVendorNotPaid', TMessageType.CALL, self._seqid)
4837 
    args = getOrdersWhereVendorNotPaid_args()
4838 
    args.vendorId = vendorId
4839 
    args.write(self._oprot)
4840 
    self._oprot.writeMessageEnd()
4841 
    self._oprot.trans.flush()
4842 
 
4843 
  def recv_getOrdersWhereVendorNotPaid(self, ):
4844 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4845 
    if mtype == TMessageType.EXCEPTION:
4846 
      x = TApplicationException()
4847 
      x.read(self._iprot)
4848 
      self._iprot.readMessageEnd()
4849 
      raise x
4850 
    result = getOrdersWhereVendorNotPaid_result()
4851 
    result.read(self._iprot)
4852 
    self._iprot.readMessageEnd()
4853 
    if result.success is not None:
4854 
      return result.success
4855 
    if result.ex is not None:
4856 
      raise result.ex
4857 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getOrdersWhereVendorNotPaid failed: unknown result");
4858 
 
5031 varun.gupt 4859 
  def getStatusDistributionOfOrders(self, startDate, endDate):
4860 
    """
4861 
    Parameters:
4862 
     - startDate
4863 
     - endDate
4864 
    """
4865 
    self.send_getStatusDistributionOfOrders(startDate, endDate)
4866 
    return self.recv_getStatusDistributionOfOrders()
4875 varun.gupt 4867 
 
5031 varun.gupt 4868 
  def send_getStatusDistributionOfOrders(self, startDate, endDate):
4869 
    self._oprot.writeMessageBegin('getStatusDistributionOfOrders', TMessageType.CALL, self._seqid)
4870 
    args = getStatusDistributionOfOrders_args()
4871 
    args.startDate = startDate
4872 
    args.endDate = endDate
4873 
    args.write(self._oprot)
4874 
    self._oprot.writeMessageEnd()
4875 
    self._oprot.trans.flush()
4876 
 
4877 
  def recv_getStatusDistributionOfOrders(self, ):
4878 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4879 
    if mtype == TMessageType.EXCEPTION:
4880 
      x = TApplicationException()
4881 
      x.read(self._iprot)
4882 
      self._iprot.readMessageEnd()
4883 
      raise x
4884 
    result = getStatusDistributionOfOrders_result()
4885 
    result.read(self._iprot)
4886 
    self._iprot.readMessageEnd()
4887 
    if result.success is not None:
4888 
      return result.success
4889 
    if result.ex is not None:
4890 
      raise result.ex
4891 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getStatusDistributionOfOrders failed: unknown result");
4892 
 
4893 
 
3376 rajveer 4894 
class Processor(shop2020.thriftpy.generic.GenericService.Processor, Iface, TProcessor):
94 ashish 4895 
  def __init__(self, handler):
3376 rajveer 4896 
    shop2020.thriftpy.generic.GenericService.Processor.__init__(self, handler)
94 ashish 4897 
    self._processMap["createTransaction"] = Processor.process_createTransaction
4898 
    self._processMap["getTransaction"] = Processor.process_getTransaction
4899 
    self._processMap["getTransactionsForCustomer"] = Processor.process_getTransactionsForCustomer
132 ashish 4900 
    self._processMap["getTransactionsForShoppingCartId"] = Processor.process_getTransactionsForShoppingCartId
94 ashish 4901 
    self._processMap["getTransactionStatus"] = Processor.process_getTransactionStatus
4902 
    self._processMap["changeTransactionStatus"] = Processor.process_changeTransactionStatus
1398 varun.gupt 4903 
    self._processMap["enqueueTransactionInfoEmail"] = Processor.process_enqueueTransactionInfoEmail
483 rajveer 4904 
    self._processMap["getAllOrders"] = Processor.process_getAllOrders
4133 chandransh 4905 
    self._processMap["getOrdersInBatch"] = Processor.process_getOrdersInBatch
4906 
    self._processMap["getOrderCount"] = Processor.process_getOrderCount
999 varun.gupt 4907 
    self._processMap["getOrdersByBillingDate"] = Processor.process_getOrdersByBillingDate
3427 chandransh 4908 
    self._processMap["getOrdersByShippingDate"] = Processor.process_getOrdersByShippingDate
1382 varun.gupt 4909 
    self._processMap["getReturnableOrdersForCustomer"] = Processor.process_getReturnableOrdersForCustomer
4910 
    self._processMap["getCancellableOrdersForCustomer"] = Processor.process_getCancellableOrdersForCustomer
483 rajveer 4911 
    self._processMap["changeOrderStatus"] = Processor.process_changeOrderStatus
4912 
    self._processMap["getOrdersForTransaction"] = Processor.process_getOrdersForTransaction
4913 
    self._processMap["getOrdersForCustomer"] = Processor.process_getOrdersForCustomer
4914 
    self._processMap["createOrder"] = Processor.process_createOrder
4915 
    self._processMap["getOrder"] = Processor.process_getOrder
4916 
    self._processMap["getLineItemsForOrder"] = Processor.process_getLineItemsForOrder
4999 phani.kuma 4917 
    self._processMap["getOrderList"] = Processor.process_getOrderList
1528 ankur.sing 4918 
    self._processMap["getOrderForCustomer"] = Processor.process_getOrderForCustomer
3064 chandransh 4919 
    self._processMap["getAlerts"] = Processor.process_getAlerts
4394 rajveer 4920 
    self._processMap["addAlert"] = Processor.process_addAlert
4444 rajveer 4921 
    self._processMap["markAlertsAsSeen"] = Processor.process_markAlertsAsSeen
3064 chandransh 4922 
    self._processMap["getValidOrderCount"] = Processor.process_getValidOrderCount
4923 
    self._processMap["getNoOfCustomersWithSuccessfulTransaction"] = Processor.process_getNoOfCustomersWithSuccessfulTransaction
4924 
    self._processMap["getValidOrdersAmountRange"] = Processor.process_getValidOrdersAmountRange
4925 
    self._processMap["getValidOrders"] = Processor.process_getValidOrders
1220 chandransh 4926 
    self._processMap["batchOrders"] = Processor.process_batchOrders
1208 chandransh 4927 
    self._processMap["markOrderAsOutOfStock"] = Processor.process_markOrderAsOutOfStock
3064 chandransh 4928 
    self._processMap["verifyOrder"] = Processor.process_verifyOrder
4929 
    self._processMap["acceptOrder"] = Processor.process_acceptOrder
4930 
    self._processMap["addBillingDetails"] = Processor.process_addBillingDetails
4579 rajveer 4931 
    self._processMap["addInvoiceNumber"] = Processor.process_addInvoiceNumber
4410 rajveer 4932 
    self._processMap["markOrdersAsShippedFromWarehouse"] = Processor.process_markOrdersAsShippedFromWarehouse
1113 chandransh 4933 
    self._processMap["markOrdersAsPickedUp"] = Processor.process_markOrdersAsPickedUp
4910 phani.kuma 4934 
    self._processMap["getOrdersNotPickedUp"] = Processor.process_getOrdersNotPickedUp
1132 chandransh 4935 
    self._processMap["markOrdersAsDelivered"] = Processor.process_markOrdersAsDelivered
4910 phani.kuma 4936 
    self._processMap["markAsRTOrders"] = Processor.process_markAsRTOrders
4937 
    self._processMap["getRTOrders"] = Processor.process_getRTOrders
1246 chandransh 4938 
    self._processMap["updateNonDeliveryReason"] = Processor.process_updateNonDeliveryReason
4910 phani.kuma 4939 
    self._processMap["getNonDeliveredOrdersbyCourier"] = Processor.process_getNonDeliveredOrdersbyCourier
4940 
    self._processMap["markOrdersAsLocalConnected"] = Processor.process_markOrdersAsLocalConnected
4941 
    self._processMap["getOrdersNotLocalConnected"] = Processor.process_getOrdersNotLocalConnected
4942 
    self._processMap["markOrdersAsDestinationCityReached"] = Processor.process_markOrdersAsDestinationCityReached
4943 
    self._processMap["markOrdersAsFirstDeliveryAttempted"] = Processor.process_markOrdersAsFirstDeliveryAttempted
1408 ankur.sing 4944 
    self._processMap["getUndeliveredOrders"] = Processor.process_getUndeliveredOrders
4783 phani.kuma 4945 
    self._processMap["getUndeliveredOrdersExpectedDeliveryDateNotMet"] = Processor.process_getUndeliveredOrdersExpectedDeliveryDateNotMet
2536 chandransh 4946 
    self._processMap["toggleDOAFlag"] = Processor.process_toggleDOAFlag
4712 rajveer 4947 
    self._processMap["markOrderAsDelivered"] = Processor.process_markOrderAsDelivered
4454 rajveer 4948 
    self._processMap["markOrderDoaRequestReceived"] = Processor.process_markOrderDoaRequestReceived
4949 
    self._processMap["markOrderDoaRequestAuthorized"] = Processor.process_markOrderDoaRequestAuthorized
4488 rajveer 4950 
    self._processMap["markOrderReturnRequestReceived"] = Processor.process_markOrderReturnRequestReceived
4951 
    self._processMap["markOrderReturnRequestAuthorized"] = Processor.process_markOrderReturnRequestAuthorized
2536 chandransh 4952 
    self._processMap["requestPickupNumber"] = Processor.process_requestPickupNumber
4953 
    self._processMap["authorizePickup"] = Processor.process_authorizePickup
2764 chandransh 4954 
    self._processMap["markDoasAsPickedUp"] = Processor.process_markDoasAsPickedUp
4910 phani.kuma 4955 
    self._processMap["getDoasNotPickedUp"] = Processor.process_getDoasNotPickedUp
4741 phani.kuma 4956 
    self._processMap["markReturnOrdersAsPickedUp"] = Processor.process_markReturnOrdersAsPickedUp
4910 phani.kuma 4957 
    self._processMap["getReturnOrdersNotPickedUp"] = Processor.process_getReturnOrdersNotPickedUp
2616 chandransh 4958 
    self._processMap["receiveReturn"] = Processor.process_receiveReturn
2591 chandransh 4959 
    self._processMap["validateDoa"] = Processor.process_validateDoa
4495 rajveer 4960 
    self._processMap["validateReturnProduct"] = Processor.process_validateReturnProduct
2616 chandransh 4961 
    self._processMap["reshipOrder"] = Processor.process_reshipOrder
4962 
    self._processMap["refundOrder"] = Processor.process_refundOrder
2690 chandransh 4963 
    self._processMap["getReturnOrders"] = Processor.process_getReturnOrders
2700 chandransh 4964 
    self._processMap["getReturnOrder"] = Processor.process_getReturnOrder
2690 chandransh 4965 
    self._processMap["processReturn"] = Processor.process_processReturn
3451 chandransh 4966 
    self._processMap["updateWeight"] = Processor.process_updateWeight
3469 chandransh 4967 
    self._processMap["changeItem"] = Processor.process_changeItem
4968 
    self._processMap["shiftToWarehouse"] = Processor.process_shiftToWarehouse
3553 chandransh 4969 
    self._processMap["addDelayReason"] = Processor.process_addDelayReason
3956 chandransh 4970 
    self._processMap["reconcileCodCollection"] = Processor.process_reconcileCodCollection
4008 mandeep.dh 4971 
    self._processMap["getTransactionsRequiringExtraProcessing"] = Processor.process_getTransactionsRequiringExtraProcessing
4972 
    self._processMap["markTransactionAsProcessed"] = Processor.process_markTransactionAsProcessed
4018 chandransh 4973 
    self._processMap["getItemWiseRiskyOrdersCount"] = Processor.process_getItemWiseRiskyOrdersCount
4295 varun.gupt 4974 
    self._processMap["getOrdersForItemIds"] = Processor.process_getOrdersForItemIds
4247 rajveer 4975 
    self._processMap["markOrderCancellationRequestReceived"] = Processor.process_markOrderCancellationRequestReceived
4976 
    self._processMap["markOrderCancellationRequestConfirmed"] = Processor.process_markOrderCancellationRequestConfirmed
4977 
    self._processMap["markOrderCancellationRequestDenied"] = Processor.process_markOrderCancellationRequestDenied
4258 rajveer 4978 
    self._processMap["markTransactionAsPaymentFlagRemoved"] = Processor.process_markTransactionAsPaymentFlagRemoved
4259 anupam.sin 4979 
    self._processMap["refundTransaction"] = Processor.process_refundTransaction
4324 mandeep.dh 4980 
    self._processMap["updateShipmentAddress"] = Processor.process_updateShipmentAddress
4285 rajveer 4981 
    self._processMap["acceptOrdersForItemId"] = Processor.process_acceptOrdersForItemId
4303 rajveer 4982 
    self._processMap["markOrdersAsPORaised"] = Processor.process_markOrdersAsPORaised
4983 
    self._processMap["markOrdersAsReversalInitiated"] = Processor.process_markOrdersAsReversalInitiated
4984 
    self._processMap["markOrdersAsNotAvailabke"] = Processor.process_markOrdersAsNotAvailabke
4369 rajveer 4985 
    self._processMap["markOrdersAsTimeout"] = Processor.process_markOrdersAsTimeout
4662 rajveer 4986 
    self._processMap["markOrderAsLostInTransit"] = Processor.process_markOrderAsLostInTransit
4386 anupam.sin 4987 
    self._processMap["getOrderForAwb"] = Processor.process_getOrderForAwb
4506 phani.kuma 4988 
    self._processMap["getOrdersForProviderForStatus"] = Processor.process_getOrdersForProviderForStatus
4600 varun.gupt 4989 
    self._processMap["getBilledOrdersForVendor"] = Processor.process_getBilledOrdersForVendor
4607 rajveer 4990 
    self._processMap["getSlippedSippingDateOrders"] = Processor.process_getSlippedSippingDateOrders
4709 rajveer 4991 
    self._processMap["getCancelledOrders"] = Processor.process_getCancelledOrders
4600 varun.gupt 4992 
    self._processMap["saveBluedartSettlements"] = Processor.process_saveBluedartSettlements
4993 
    self._processMap["savePaymentSettlements"] = Processor.process_savePaymentSettlements
4994 
    self._processMap["saveEBSSettlementSummary"] = Processor.process_saveEBSSettlementSummary
4995 
    self._processMap["getSettlementForPaymentId"] = Processor.process_getSettlementForPaymentId
4996 
    self._processMap["getEBSSettlementSummaries"] = Processor.process_getEBSSettlementSummaries
4997 
    self._processMap["markEBSSettlementUploaded"] = Processor.process_markEBSSettlementUploaded
4998 
    self._processMap["getEBSSettlementDate"] = Processor.process_getEBSSettlementDate
4715 varun.gupt 4999 
    self._processMap["getSettlementsByDate"] = Processor.process_getSettlementsByDate
5000 
    self._processMap["getReshippedOrderIds"] = Processor.process_getReshippedOrderIds
4757 mandeep.dh 5001 
    self._processMap["updateOrdersAsPORaised"] = Processor.process_updateOrdersAsPORaised
4875 varun.gupt 5002 
    self._processMap["getOrdersWhereVendorNotPaid"] = Processor.process_getOrdersWhereVendorNotPaid
5031 varun.gupt 5003 
    self._processMap["getStatusDistributionOfOrders"] = Processor.process_getStatusDistributionOfOrders
94 ashish 5004 
 
5005 
  def process(self, iprot, oprot):
5006 
    (name, type, seqid) = iprot.readMessageBegin()
5007 
    if name not in self._processMap:
5008 
      iprot.skip(TType.STRUCT)
5009 
      iprot.readMessageEnd()
5010 
      x = TApplicationException(TApplicationException.UNKNOWN_METHOD, 'Unknown function %s' % (name))
5011 
      oprot.writeMessageBegin(name, TMessageType.EXCEPTION, seqid)
5012 
      x.write(oprot)
5013 
      oprot.writeMessageEnd()
5014 
      oprot.trans.flush()
5015 
      return
5016 
    else:
5017 
      self._processMap[name](self, seqid, iprot, oprot)
5018 
    return True
5019 
 
5020 
  def process_createTransaction(self, seqid, iprot, oprot):
5021 
    args = createTransaction_args()
5022 
    args.read(iprot)
5023 
    iprot.readMessageEnd()
5024 
    result = createTransaction_result()
5025 
    try:
132 ashish 5026 
      result.success = self._handler.createTransaction(args.transaction)
94 ashish 5027 
    except TransactionServiceException, ex:
5028 
      result.ex = ex
5029 
    oprot.writeMessageBegin("createTransaction", TMessageType.REPLY, seqid)
5030 
    result.write(oprot)
5031 
    oprot.writeMessageEnd()
5032 
    oprot.trans.flush()
5033 
 
5034 
  def process_getTransaction(self, seqid, iprot, oprot):
5035 
    args = getTransaction_args()
5036 
    args.read(iprot)
5037 
    iprot.readMessageEnd()
5038 
    result = getTransaction_result()
5039 
    try:
5040 
      result.success = self._handler.getTransaction(args.id)
5041 
    except TransactionServiceException, ex:
5042 
      result.ex = ex
5043 
    oprot.writeMessageBegin("getTransaction", TMessageType.REPLY, seqid)
5044 
    result.write(oprot)
5045 
    oprot.writeMessageEnd()
5046 
    oprot.trans.flush()
5047 
 
5048 
  def process_getTransactionsForCustomer(self, seqid, iprot, oprot):
5049 
    args = getTransactionsForCustomer_args()
5050 
    args.read(iprot)
5051 
    iprot.readMessageEnd()
5052 
    result = getTransactionsForCustomer_result()
5053 
    try:
5054 
      result.success = self._handler.getTransactionsForCustomer(args.customerId, args.from_date, args.to_date, args.status)
5055 
    except TransactionServiceException, ex:
5056 
      result.ex = ex
5057 
    oprot.writeMessageBegin("getTransactionsForCustomer", TMessageType.REPLY, seqid)
5058 
    result.write(oprot)
5059 
    oprot.writeMessageEnd()
5060 
    oprot.trans.flush()
5061 
 
132 ashish 5062 
  def process_getTransactionsForShoppingCartId(self, seqid, iprot, oprot):
5063 
    args = getTransactionsForShoppingCartId_args()
5064 
    args.read(iprot)
5065 
    iprot.readMessageEnd()
5066 
    result = getTransactionsForShoppingCartId_result()
5067 
    try:
5068 
      result.success = self._handler.getTransactionsForShoppingCartId(args.shoppingCartId)
5069 
    except TransactionServiceException, ex:
5070 
      result.ex = ex
5071 
    oprot.writeMessageBegin("getTransactionsForShoppingCartId", TMessageType.REPLY, seqid)
5072 
    result.write(oprot)
5073 
    oprot.writeMessageEnd()
5074 
    oprot.trans.flush()
5075 
 
94 ashish 5076 
  def process_getTransactionStatus(self, seqid, iprot, oprot):
5077 
    args = getTransactionStatus_args()
5078 
    args.read(iprot)
5079 
    iprot.readMessageEnd()
5080 
    result = getTransactionStatus_result()
5081 
    try:
5082 
      result.success = self._handler.getTransactionStatus(args.transactionId)
5083 
    except TransactionServiceException, ex:
5084 
      result.ex = ex
5085 
    oprot.writeMessageBegin("getTransactionStatus", TMessageType.REPLY, seqid)
5086 
    result.write(oprot)
5087 
    oprot.writeMessageEnd()
5088 
    oprot.trans.flush()
5089 
 
5090 
  def process_changeTransactionStatus(self, seqid, iprot, oprot):
5091 
    args = changeTransactionStatus_args()
5092 
    args.read(iprot)
5093 
    iprot.readMessageEnd()
5094 
    result = changeTransactionStatus_result()
5095 
    try:
5096 
      result.success = self._handler.changeTransactionStatus(args.transactionId, args.status, args.description)
5097 
    except TransactionServiceException, ex:
5098 
      result.ex = ex
5099 
    oprot.writeMessageBegin("changeTransactionStatus", TMessageType.REPLY, seqid)
5100 
    result.write(oprot)
5101 
    oprot.writeMessageEnd()
5102 
    oprot.trans.flush()
5103 
 
1398 varun.gupt 5104 
  def process_enqueueTransactionInfoEmail(self, seqid, iprot, oprot):
5105 
    args = enqueueTransactionInfoEmail_args()
1382 varun.gupt 5106 
    args.read(iprot)
5107 
    iprot.readMessageEnd()
1398 varun.gupt 5108 
    result = enqueueTransactionInfoEmail_result()
1382 varun.gupt 5109 
    try:
1398 varun.gupt 5110 
      result.success = self._handler.enqueueTransactionInfoEmail(args.transactionId)
1382 varun.gupt 5111 
    except TransactionServiceException, ex:
5112 
      result.ex = ex
1398 varun.gupt 5113 
    oprot.writeMessageBegin("enqueueTransactionInfoEmail", TMessageType.REPLY, seqid)
1382 varun.gupt 5114 
    result.write(oprot)
5115 
    oprot.writeMessageEnd()
5116 
    oprot.trans.flush()
5117 
 
483 rajveer 5118 
  def process_getAllOrders(self, seqid, iprot, oprot):
5119 
    args = getAllOrders_args()
94 ashish 5120 
    args.read(iprot)
5121 
    iprot.readMessageEnd()
483 rajveer 5122 
    result = getAllOrders_result()
94 ashish 5123 
    try:
4801 anupam.sin 5124 
      result.success = self._handler.getAllOrders(args.statuses, args.from_date, args.to_date, args.warehouse_id)
94 ashish 5125 
    except TransactionServiceException, ex:
5126 
      result.ex = ex
483 rajveer 5127 
    oprot.writeMessageBegin("getAllOrders", TMessageType.REPLY, seqid)
94 ashish 5128 
    result.write(oprot)
5129 
    oprot.writeMessageEnd()
5130 
    oprot.trans.flush()
5131 
 
4133 chandransh 5132 
  def process_getOrdersInBatch(self, seqid, iprot, oprot):
5133 
    args = getOrdersInBatch_args()
5134 
    args.read(iprot)
5135 
    iprot.readMessageEnd()
5136 
    result = getOrdersInBatch_result()
5137 
    try:
5138 
      result.success = self._handler.getOrdersInBatch(args.statuses, args.offset, args.limit, args.warehouse_id)
5139 
    except TransactionServiceException, ex:
5140 
      result.ex = ex
5141 
    oprot.writeMessageBegin("getOrdersInBatch", TMessageType.REPLY, seqid)
5142 
    result.write(oprot)
5143 
    oprot.writeMessageEnd()
5144 
    oprot.trans.flush()
5145 
 
5146 
  def process_getOrderCount(self, seqid, iprot, oprot):
5147 
    args = getOrderCount_args()
5148 
    args.read(iprot)
5149 
    iprot.readMessageEnd()
5150 
    result = getOrderCount_result()
5151 
    try:
5152 
      result.success = self._handler.getOrderCount(args.statuses, args.warehouseId)
5153 
    except TransactionServiceException, ex:
5154 
      result.ex = ex
5155 
    oprot.writeMessageBegin("getOrderCount", TMessageType.REPLY, seqid)
5156 
    result.write(oprot)
5157 
    oprot.writeMessageEnd()
5158 
    oprot.trans.flush()
5159 
 
999 varun.gupt 5160 
  def process_getOrdersByBillingDate(self, seqid, iprot, oprot):
5161 
    args = getOrdersByBillingDate_args()
5162 
    args.read(iprot)
5163 
    iprot.readMessageEnd()
5164 
    result = getOrdersByBillingDate_result()
5165 
    try:
5166 
      result.success = self._handler.getOrdersByBillingDate(args.status, args.start_billing_date, args.end_billing_date, args.warehouse_id)
5167 
    except TransactionServiceException, ex:
5168 
      result.ex = ex
5169 
    oprot.writeMessageBegin("getOrdersByBillingDate", TMessageType.REPLY, seqid)
5170 
    result.write(oprot)
5171 
    oprot.writeMessageEnd()
5172 
    oprot.trans.flush()
5173 
 
3427 chandransh 5174 
  def process_getOrdersByShippingDate(self, seqid, iprot, oprot):
5175 
    args = getOrdersByShippingDate_args()
5176 
    args.read(iprot)
5177 
    iprot.readMessageEnd()
5178 
    result = getOrdersByShippingDate_result()
5179 
    try:
3451 chandransh 5180 
      result.success = self._handler.getOrdersByShippingDate(args.fromShippingDate, args.toShippingDate, args.providerId, args.warehouseId, args.cod)
3427 chandransh 5181 
    except TransactionServiceException, ex:
5182 
      result.ex = ex
5183 
    oprot.writeMessageBegin("getOrdersByShippingDate", TMessageType.REPLY, seqid)
5184 
    result.write(oprot)
5185 
    oprot.writeMessageEnd()
5186 
    oprot.trans.flush()
5187 
 
1382 varun.gupt 5188 
  def process_getReturnableOrdersForCustomer(self, seqid, iprot, oprot):
5189 
    args = getReturnableOrdersForCustomer_args()
5190 
    args.read(iprot)
5191 
    iprot.readMessageEnd()
5192 
    result = getReturnableOrdersForCustomer_result()
5193 
    try:
5194 
      result.success = self._handler.getReturnableOrdersForCustomer(args.customer_id, args.limit)
5195 
    except TransactionServiceException, ex:
5196 
      result.ex = ex
5197 
    oprot.writeMessageBegin("getReturnableOrdersForCustomer", TMessageType.REPLY, seqid)
5198 
    result.write(oprot)
5199 
    oprot.writeMessageEnd()
5200 
    oprot.trans.flush()
5201 
 
5202 
  def process_getCancellableOrdersForCustomer(self, seqid, iprot, oprot):
5203 
    args = getCancellableOrdersForCustomer_args()
5204 
    args.read(iprot)
5205 
    iprot.readMessageEnd()
5206 
    result = getCancellableOrdersForCustomer_result()
5207 
    try:
5208 
      result.success = self._handler.getCancellableOrdersForCustomer(args.customer_id, args.limit)
5209 
    except TransactionServiceException, ex:
5210 
      result.ex = ex
5211 
    oprot.writeMessageBegin("getCancellableOrdersForCustomer", TMessageType.REPLY, seqid)
5212 
    result.write(oprot)
5213 
    oprot.writeMessageEnd()
5214 
    oprot.trans.flush()
5215 
 
483 rajveer 5216 
  def process_changeOrderStatus(self, seqid, iprot, oprot):
5217 
    args = changeOrderStatus_args()
94 ashish 5218 
    args.read(iprot)
5219 
    iprot.readMessageEnd()
483 rajveer 5220 
    result = changeOrderStatus_result()
94 ashish 5221 
    try:
483 rajveer 5222 
      result.success = self._handler.changeOrderStatus(args.orderId, args.status, args.description)
94 ashish 5223 
    except TransactionServiceException, ex:
5224 
      result.ex = ex
483 rajveer 5225 
    oprot.writeMessageBegin("changeOrderStatus", TMessageType.REPLY, seqid)
94 ashish 5226 
    result.write(oprot)
5227 
    oprot.writeMessageEnd()
5228 
    oprot.trans.flush()
5229 
 
483 rajveer 5230 
  def process_getOrdersForTransaction(self, seqid, iprot, oprot):
5231 
    args = getOrdersForTransaction_args()
94 ashish 5232 
    args.read(iprot)
5233 
    iprot.readMessageEnd()
483 rajveer 5234 
    result = getOrdersForTransaction_result()
94 ashish 5235 
    try:
1528 ankur.sing 5236 
      result.success = self._handler.getOrdersForTransaction(args.transactionId, args.customerId)
94 ashish 5237 
    except TransactionServiceException, ex:
5238 
      result.ex = ex
483 rajveer 5239 
    oprot.writeMessageBegin("getOrdersForTransaction", TMessageType.REPLY, seqid)
94 ashish 5240 
    result.write(oprot)
5241 
    oprot.writeMessageEnd()
5242 
    oprot.trans.flush()
5243 
 
483 rajveer 5244 
  def process_getOrdersForCustomer(self, seqid, iprot, oprot):
5245 
    args = getOrdersForCustomer_args()
94 ashish 5246 
    args.read(iprot)
5247 
    iprot.readMessageEnd()
483 rajveer 5248 
    result = getOrdersForCustomer_result()
94 ashish 5249 
    try:
3014 chandransh 5250 
      result.success = self._handler.getOrdersForCustomer(args.customerId, args.from_date, args.to_date, args.statuses)
94 ashish 5251 
    except TransactionServiceException, ex:
5252 
      result.ex = ex
483 rajveer 5253 
    oprot.writeMessageBegin("getOrdersForCustomer", TMessageType.REPLY, seqid)
94 ashish 5254 
    result.write(oprot)
5255 
    oprot.writeMessageEnd()
5256 
    oprot.trans.flush()
5257 
 
483 rajveer 5258 
  def process_createOrder(self, seqid, iprot, oprot):
5259 
    args = createOrder_args()
94 ashish 5260 
    args.read(iprot)
5261 
    iprot.readMessageEnd()
483 rajveer 5262 
    result = createOrder_result()
94 ashish 5263 
    try:
483 rajveer 5264 
      result.success = self._handler.createOrder(args.order)
94 ashish 5265 
    except TransactionServiceException, ex:
5266 
      result.ex = ex
483 rajveer 5267 
    oprot.writeMessageBegin("createOrder", TMessageType.REPLY, seqid)
94 ashish 5268 
    result.write(oprot)
5269 
    oprot.writeMessageEnd()
5270 
    oprot.trans.flush()
5271 
 
483 rajveer 5272 
  def process_getOrder(self, seqid, iprot, oprot):
5273 
    args = getOrder_args()
94 ashish 5274 
    args.read(iprot)
5275 
    iprot.readMessageEnd()
483 rajveer 5276 
    result = getOrder_result()
94 ashish 5277 
    try:
483 rajveer 5278 
      result.success = self._handler.getOrder(args.id)
94 ashish 5279 
    except TransactionServiceException, ex:
5280 
      result.ex = ex
483 rajveer 5281 
    oprot.writeMessageBegin("getOrder", TMessageType.REPLY, seqid)
94 ashish 5282 
    result.write(oprot)
5283 
    oprot.writeMessageEnd()
5284 
    oprot.trans.flush()
5285 
 
483 rajveer 5286 
  def process_getLineItemsForOrder(self, seqid, iprot, oprot):
5287 
    args = getLineItemsForOrder_args()
94 ashish 5288 
    args.read(iprot)
5289 
    iprot.readMessageEnd()
483 rajveer 5290 
    result = getLineItemsForOrder_result()
94 ashish 5291 
    try:
483 rajveer 5292 
      result.success = self._handler.getLineItemsForOrder(args.orderId)
94 ashish 5293 
    except TransactionServiceException, ex:
5294 
      result.ex = ex
483 rajveer 5295 
    oprot.writeMessageBegin("getLineItemsForOrder", TMessageType.REPLY, seqid)
94 ashish 5296 
    result.write(oprot)
5297 
    oprot.writeMessageEnd()
5298 
    oprot.trans.flush()
5299 
 
4999 phani.kuma 5300 
  def process_getOrderList(self, seqid, iprot, oprot):
5301 
    args = getOrderList_args()
5302 
    args.read(iprot)
5303 
    iprot.readMessageEnd()
5304 
    result = getOrderList_result()
5305 
    result.success = self._handler.getOrderList(args.order_ids)
5306 
    oprot.writeMessageBegin("getOrderList", TMessageType.REPLY, seqid)
5307 
    result.write(oprot)
5308 
    oprot.writeMessageEnd()
5309 
    oprot.trans.flush()
5310 
 
1528 ankur.sing 5311 
  def process_getOrderForCustomer(self, seqid, iprot, oprot):
5312 
    args = getOrderForCustomer_args()
5313 
    args.read(iprot)
5314 
    iprot.readMessageEnd()
5315 
    result = getOrderForCustomer_result()
5316 
    try:
5317 
      result.success = self._handler.getOrderForCustomer(args.orderId, args.customerId)
5318 
    except TransactionServiceException, ex:
5319 
      result.ex = ex
5320 
    oprot.writeMessageBegin("getOrderForCustomer", TMessageType.REPLY, seqid)
5321 
    result.write(oprot)
5322 
    oprot.writeMessageEnd()
5323 
    oprot.trans.flush()
5324 
 
3064 chandransh 5325 
  def process_getAlerts(self, seqid, iprot, oprot):
5326 
    args = getAlerts_args()
5327 
    args.read(iprot)
5328 
    iprot.readMessageEnd()
5329 
    result = getAlerts_result()
4444 rajveer 5330 
    result.success = self._handler.getAlerts(args.type, args.warehouseId, args.status, args.timestamp)
3064 chandransh 5331 
    oprot.writeMessageBegin("getAlerts", TMessageType.REPLY, seqid)
5332 
    result.write(oprot)
5333 
    oprot.writeMessageEnd()
5334 
    oprot.trans.flush()
5335 
 
4394 rajveer 5336 
  def process_addAlert(self, seqid, iprot, oprot):
5337 
    args = addAlert_args()
3064 chandransh 5338 
    args.read(iprot)
5339 
    iprot.readMessageEnd()
4394 rajveer 5340 
    result = addAlert_result()
4444 rajveer 5341 
    self._handler.addAlert(args.type, args.warehouseId, args.description)
4394 rajveer 5342 
    oprot.writeMessageBegin("addAlert", TMessageType.REPLY, seqid)
3064 chandransh 5343 
    result.write(oprot)
5344 
    oprot.writeMessageEnd()
5345 
    oprot.trans.flush()
5346 
 
4444 rajveer 5347 
  def process_markAlertsAsSeen(self, seqid, iprot, oprot):
5348 
    args = markAlertsAsSeen_args()
5349 
    args.read(iprot)
5350 
    iprot.readMessageEnd()
5351 
    result = markAlertsAsSeen_result()
5352 
    self._handler.markAlertsAsSeen(args.warehouseId)
5353 
    oprot.writeMessageBegin("markAlertsAsSeen", TMessageType.REPLY, seqid)
5354 
    result.write(oprot)
5355 
    oprot.writeMessageEnd()
5356 
    oprot.trans.flush()
5357 
 
3064 chandransh 5358 
  def process_getValidOrderCount(self, seqid, iprot, oprot):
5359 
    args = getValidOrderCount_args()
5360 
    args.read(iprot)
5361 
    iprot.readMessageEnd()
5362 
    result = getValidOrderCount_result()
5363 
    result.success = self._handler.getValidOrderCount()
5364 
    oprot.writeMessageBegin("getValidOrderCount", TMessageType.REPLY, seqid)
5365 
    result.write(oprot)
5366 
    oprot.writeMessageEnd()
5367 
    oprot.trans.flush()
5368 
 
5369 
  def process_getNoOfCustomersWithSuccessfulTransaction(self, seqid, iprot, oprot):
5370 
    args = getNoOfCustomersWithSuccessfulTransaction_args()
5371 
    args.read(iprot)
5372 
    iprot.readMessageEnd()
5373 
    result = getNoOfCustomersWithSuccessfulTransaction_result()
5374 
    result.success = self._handler.getNoOfCustomersWithSuccessfulTransaction()
5375 
    oprot.writeMessageBegin("getNoOfCustomersWithSuccessfulTransaction", TMessageType.REPLY, seqid)
5376 
    result.write(oprot)
5377 
    oprot.writeMessageEnd()
5378 
    oprot.trans.flush()
5379 
 
5380 
  def process_getValidOrdersAmountRange(self, seqid, iprot, oprot):
5381 
    args = getValidOrdersAmountRange_args()
5382 
    args.read(iprot)
5383 
    iprot.readMessageEnd()
5384 
    result = getValidOrdersAmountRange_result()
5385 
    result.success = self._handler.getValidOrdersAmountRange()
5386 
    oprot.writeMessageBegin("getValidOrdersAmountRange", TMessageType.REPLY, seqid)
5387 
    result.write(oprot)
5388 
    oprot.writeMessageEnd()
5389 
    oprot.trans.flush()
5390 
 
5391 
  def process_getValidOrders(self, seqid, iprot, oprot):
5392 
    args = getValidOrders_args()
5393 
    args.read(iprot)
5394 
    iprot.readMessageEnd()
5395 
    result = getValidOrders_result()
5396 
    result.success = self._handler.getValidOrders(args.limit)
5397 
    oprot.writeMessageBegin("getValidOrders", TMessageType.REPLY, seqid)
5398 
    result.write(oprot)
5399 
    oprot.writeMessageEnd()
5400 
    oprot.trans.flush()
5401 
 
1220 chandransh 5402 
  def process_batchOrders(self, seqid, iprot, oprot):
5403 
    args = batchOrders_args()
5404 
    args.read(iprot)
5405 
    iprot.readMessageEnd()
5406 
    result = batchOrders_result()
5407 
    try:
5408 
      result.success = self._handler.batchOrders(args.warehouseId)
5409 
    except TransactionServiceException, ex:
5410 
      result.ex = ex
5411 
    oprot.writeMessageBegin("batchOrders", TMessageType.REPLY, seqid)
5412 
    result.write(oprot)
5413 
    oprot.writeMessageEnd()
5414 
    oprot.trans.flush()
5415 
 
1208 chandransh 5416 
  def process_markOrderAsOutOfStock(self, seqid, iprot, oprot):
5417 
    args = markOrderAsOutOfStock_args()
5418 
    args.read(iprot)
5419 
    iprot.readMessageEnd()
5420 
    result = markOrderAsOutOfStock_result()
5421 
    try:
5422 
      result.success = self._handler.markOrderAsOutOfStock(args.orderId)
5423 
    except TransactionServiceException, ex:
5424 
      result.ex = ex
5425 
    oprot.writeMessageBegin("markOrderAsOutOfStock", TMessageType.REPLY, seqid)
5426 
    result.write(oprot)
5427 
    oprot.writeMessageEnd()
5428 
    oprot.trans.flush()
5429 
 
3064 chandransh 5430 
  def process_verifyOrder(self, seqid, iprot, oprot):
5431 
    args = verifyOrder_args()
759 chandransh 5432 
    args.read(iprot)
5433 
    iprot.readMessageEnd()
3064 chandransh 5434 
    result = verifyOrder_result()
759 chandransh 5435 
    try:
3064 chandransh 5436 
      result.success = self._handler.verifyOrder(args.orderId)
759 chandransh 5437 
    except TransactionServiceException, ex:
5438 
      result.ex = ex
3064 chandransh 5439 
    oprot.writeMessageBegin("verifyOrder", TMessageType.REPLY, seqid)
759 chandransh 5440 
    result.write(oprot)
5441 
    oprot.writeMessageEnd()
5442 
    oprot.trans.flush()
5443 
 
3064 chandransh 5444 
  def process_acceptOrder(self, seqid, iprot, oprot):
5445 
    args = acceptOrder_args()
1113 chandransh 5446 
    args.read(iprot)
5447 
    iprot.readMessageEnd()
3064 chandransh 5448 
    result = acceptOrder_result()
1113 chandransh 5449 
    try:
3064 chandransh 5450 
      result.success = self._handler.acceptOrder(args.orderId)
1113 chandransh 5451 
    except TransactionServiceException, ex:
5452 
      result.ex = ex
3064 chandransh 5453 
    oprot.writeMessageBegin("acceptOrder", TMessageType.REPLY, seqid)
1113 chandransh 5454 
    result.write(oprot)
5455 
    oprot.writeMessageEnd()
5456 
    oprot.trans.flush()
5457 
 
3064 chandransh 5458 
  def process_addBillingDetails(self, seqid, iprot, oprot):
5459 
    args = addBillingDetails_args()
1135 chandransh 5460 
    args.read(iprot)
5461 
    iprot.readMessageEnd()
3064 chandransh 5462 
    result = addBillingDetails_result()
1135 chandransh 5463 
    try:
4763 rajveer 5464 
      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 5465 
    except TransactionServiceException, ex:
5466 
      result.ex = ex
3064 chandransh 5467 
    oprot.writeMessageBegin("addBillingDetails", TMessageType.REPLY, seqid)
1135 chandransh 5468 
    result.write(oprot)
5469 
    oprot.writeMessageEnd()
5470 
    oprot.trans.flush()
5471 
 
4579 rajveer 5472 
  def process_addInvoiceNumber(self, seqid, iprot, oprot):
5473 
    args = addInvoiceNumber_args()
5474 
    args.read(iprot)
5475 
    iprot.readMessageEnd()
5476 
    result = addInvoiceNumber_result()
5477 
    try:
4763 rajveer 5478 
      self._handler.addInvoiceNumber(args.orderId, args.invoiceNumber, args.color)
4579 rajveer 5479 
    except TransactionServiceException, ex:
5480 
      result.ex = ex
5481 
    oprot.writeMessageBegin("addInvoiceNumber", TMessageType.REPLY, seqid)
5482 
    result.write(oprot)
5483 
    oprot.writeMessageEnd()
5484 
    oprot.trans.flush()
5485 
 
4410 rajveer 5486 
  def process_markOrdersAsShippedFromWarehouse(self, seqid, iprot, oprot):
5487 
    args = markOrdersAsShippedFromWarehouse_args()
5488 
    args.read(iprot)
5489 
    iprot.readMessageEnd()
5490 
    result = markOrdersAsShippedFromWarehouse_result()
5491 
    try:
4789 rajveer 5492 
      result.success = self._handler.markOrdersAsShippedFromWarehouse(args.warehouseId, args.providerId, args.cod, args.orderIds)
4410 rajveer 5493 
    except TransactionServiceException, ex:
5494 
      result.ex = ex
5495 
    oprot.writeMessageBegin("markOrdersAsShippedFromWarehouse", TMessageType.REPLY, seqid)
5496 
    result.write(oprot)
5497 
    oprot.writeMessageEnd()
5498 
    oprot.trans.flush()
5499 
 
3064 chandransh 5500 
  def process_markOrdersAsPickedUp(self, seqid, iprot, oprot):
5501 
    args = markOrdersAsPickedUp_args()
304 ashish 5502 
    args.read(iprot)
5503 
    iprot.readMessageEnd()
3064 chandransh 5504 
    result = markOrdersAsPickedUp_result()
5505 
    try:
4910 phani.kuma 5506 
      self._handler.markOrdersAsPickedUp(args.providerId, args.pickupDetails)
3064 chandransh 5507 
    except TransactionServiceException, ex:
5508 
      result.ex = ex
5509 
    oprot.writeMessageBegin("markOrdersAsPickedUp", TMessageType.REPLY, seqid)
304 ashish 5510 
    result.write(oprot)
5511 
    oprot.writeMessageEnd()
5512 
    oprot.trans.flush()
94 ashish 5513 
 
4910 phani.kuma 5514 
  def process_getOrdersNotPickedUp(self, seqid, iprot, oprot):
5515 
    args = getOrdersNotPickedUp_args()
5516 
    args.read(iprot)
5517 
    iprot.readMessageEnd()
5518 
    result = getOrdersNotPickedUp_result()
5519 
    result.success = self._handler.getOrdersNotPickedUp(args.providerId)
5520 
    oprot.writeMessageBegin("getOrdersNotPickedUp", TMessageType.REPLY, seqid)
5521 
    result.write(oprot)
5522 
    oprot.writeMessageEnd()
5523 
    oprot.trans.flush()
5524 
 
3064 chandransh 5525 
  def process_markOrdersAsDelivered(self, seqid, iprot, oprot):
5526 
    args = markOrdersAsDelivered_args()
304 ashish 5527 
    args.read(iprot)
5528 
    iprot.readMessageEnd()
3064 chandransh 5529 
    result = markOrdersAsDelivered_result()
5530 
    try:
5531 
      self._handler.markOrdersAsDelivered(args.providerId, args.deliveredOrders)
5532 
    except TransactionServiceException, ex:
5533 
      result.ex = ex
5534 
    oprot.writeMessageBegin("markOrdersAsDelivered", TMessageType.REPLY, seqid)
304 ashish 5535 
    result.write(oprot)
5536 
    oprot.writeMessageEnd()
5537 
    oprot.trans.flush()
5538 
 
4910 phani.kuma 5539 
  def process_markAsRTOrders(self, seqid, iprot, oprot):
5540 
    args = markAsRTOrders_args()
1596 ankur.sing 5541 
    args.read(iprot)
5542 
    iprot.readMessageEnd()
4910 phani.kuma 5543 
    result = markAsRTOrders_result()
3064 chandransh 5544 
    try:
4910 phani.kuma 5545 
      self._handler.markAsRTOrders(args.providerId, args.returnedOrders)
3064 chandransh 5546 
    except TransactionServiceException, ex:
5547 
      result.ex = ex
4910 phani.kuma 5548 
    oprot.writeMessageBegin("markAsRTOrders", TMessageType.REPLY, seqid)
1596 ankur.sing 5549 
    result.write(oprot)
5550 
    oprot.writeMessageEnd()
5551 
    oprot.trans.flush()
304 ashish 5552 
 
4910 phani.kuma 5553 
  def process_getRTOrders(self, seqid, iprot, oprot):
5554 
    args = getRTOrders_args()
5555 
    args.read(iprot)
5556 
    iprot.readMessageEnd()
5557 
    result = getRTOrders_result()
5558 
    result.success = self._handler.getRTOrders(args.providerId)
5559 
    oprot.writeMessageBegin("getRTOrders", TMessageType.REPLY, seqid)
5560 
    result.write(oprot)
5561 
    oprot.writeMessageEnd()
5562 
    oprot.trans.flush()
5563 
 
3064 chandransh 5564 
  def process_updateNonDeliveryReason(self, seqid, iprot, oprot):
5565 
    args = updateNonDeliveryReason_args()
1627 ankur.sing 5566 
    args.read(iprot)
5567 
    iprot.readMessageEnd()
3064 chandransh 5568 
    result = updateNonDeliveryReason_result()
5569 
    try:
4910 phani.kuma 5570 
      self._handler.updateNonDeliveryReason(args.providerId, args.undeliveredOrders)
3064 chandransh 5571 
    except TransactionServiceException, ex:
5572 
      result.ex = ex
5573 
    oprot.writeMessageBegin("updateNonDeliveryReason", TMessageType.REPLY, seqid)
1627 ankur.sing 5574 
    result.write(oprot)
5575 
    oprot.writeMessageEnd()
5576 
    oprot.trans.flush()
1596 ankur.sing 5577 
 
4910 phani.kuma 5578 
  def process_getNonDeliveredOrdersbyCourier(self, seqid, iprot, oprot):
5579 
    args = getNonDeliveredOrdersbyCourier_args()
5580 
    args.read(iprot)
5581 
    iprot.readMessageEnd()
5582 
    result = getNonDeliveredOrdersbyCourier_result()
5583 
    result.success = self._handler.getNonDeliveredOrdersbyCourier(args.providerId)
5584 
    oprot.writeMessageBegin("getNonDeliveredOrdersbyCourier", TMessageType.REPLY, seqid)
5585 
    result.write(oprot)
5586 
    oprot.writeMessageEnd()
5587 
    oprot.trans.flush()
5588 
 
5589 
  def process_markOrdersAsLocalConnected(self, seqid, iprot, oprot):
5590 
    args = markOrdersAsLocalConnected_args()
5591 
    args.read(iprot)
5592 
    iprot.readMessageEnd()
5593 
    result = markOrdersAsLocalConnected_result()
5594 
    try:
5595 
      self._handler.markOrdersAsLocalConnected(args.providerId, args.local_connected_orders)
5596 
    except TransactionServiceException, ex:
5597 
      result.ex = ex
5598 
    oprot.writeMessageBegin("markOrdersAsLocalConnected", TMessageType.REPLY, seqid)
5599 
    result.write(oprot)
5600 
    oprot.writeMessageEnd()
5601 
    oprot.trans.flush()
5602 
 
5603 
  def process_getOrdersNotLocalConnected(self, seqid, iprot, oprot):
5604 
    args = getOrdersNotLocalConnected_args()
5605 
    args.read(iprot)
5606 
    iprot.readMessageEnd()
5607 
    result = getOrdersNotLocalConnected_result()
5608 
    result.success = self._handler.getOrdersNotLocalConnected(args.providerId)
5609 
    oprot.writeMessageBegin("getOrdersNotLocalConnected", TMessageType.REPLY, seqid)
5610 
    result.write(oprot)
5611 
    oprot.writeMessageEnd()
5612 
    oprot.trans.flush()
5613 
 
5614 
  def process_markOrdersAsDestinationCityReached(self, seqid, iprot, oprot):
5615 
    args = markOrdersAsDestinationCityReached_args()
5616 
    args.read(iprot)
5617 
    iprot.readMessageEnd()
5618 
    result = markOrdersAsDestinationCityReached_result()
5619 
    try:
5620 
      self._handler.markOrdersAsDestinationCityReached(args.providerId, args.destination_city_reached_orders)
5621 
    except TransactionServiceException, ex:
5622 
      result.ex = ex
5623 
    oprot.writeMessageBegin("markOrdersAsDestinationCityReached", TMessageType.REPLY, seqid)
5624 
    result.write(oprot)
5625 
    oprot.writeMessageEnd()
5626 
    oprot.trans.flush()
5627 
 
5628 
  def process_markOrdersAsFirstDeliveryAttempted(self, seqid, iprot, oprot):
5629 
    args = markOrdersAsFirstDeliveryAttempted_args()
5630 
    args.read(iprot)
5631 
    iprot.readMessageEnd()
5632 
    result = markOrdersAsFirstDeliveryAttempted_result()
5633 
    try:
5634 
      self._handler.markOrdersAsFirstDeliveryAttempted(args.providerId, args.first_atdl_orders)
5635 
    except TransactionServiceException, ex:
5636 
      result.ex = ex
5637 
    oprot.writeMessageBegin("markOrdersAsFirstDeliveryAttempted", TMessageType.REPLY, seqid)
5638 
    result.write(oprot)
5639 
    oprot.writeMessageEnd()
5640 
    oprot.trans.flush()
5641 
 
3064 chandransh 5642 
  def process_getUndeliveredOrders(self, seqid, iprot, oprot):
5643 
    args = getUndeliveredOrders_args()
1627 ankur.sing 5644 
    args.read(iprot)
5645 
    iprot.readMessageEnd()
3064 chandransh 5646 
    result = getUndeliveredOrders_result()
5647 
    result.success = self._handler.getUndeliveredOrders(args.providerId, args.warehouseId)
5648 
    oprot.writeMessageBegin("getUndeliveredOrders", TMessageType.REPLY, seqid)
1627 ankur.sing 5649 
    result.write(oprot)
5650 
    oprot.writeMessageEnd()
5651 
    oprot.trans.flush()
5652 
 
4783 phani.kuma 5653 
  def process_getUndeliveredOrdersExpectedDeliveryDateNotMet(self, seqid, iprot, oprot):
5654 
    args = getUndeliveredOrdersExpectedDeliveryDateNotMet_args()
5655 
    args.read(iprot)
5656 
    iprot.readMessageEnd()
5657 
    result = getUndeliveredOrdersExpectedDeliveryDateNotMet_result()
5658 
    result.success = self._handler.getUndeliveredOrdersExpectedDeliveryDateNotMet()
5659 
    oprot.writeMessageBegin("getUndeliveredOrdersExpectedDeliveryDateNotMet", TMessageType.REPLY, seqid)
5660 
    result.write(oprot)
5661 
    oprot.writeMessageEnd()
5662 
    oprot.trans.flush()
5663 
 
2536 chandransh 5664 
  def process_toggleDOAFlag(self, seqid, iprot, oprot):
5665 
    args = toggleDOAFlag_args()
5666 
    args.read(iprot)
5667 
    iprot.readMessageEnd()
5668 
    result = toggleDOAFlag_result()
5669 
    try:
5670 
      result.success = self._handler.toggleDOAFlag(args.orderId)
5671 
    except TransactionServiceException, ex:
5672 
      result.ex = ex
5673 
    oprot.writeMessageBegin("toggleDOAFlag", TMessageType.REPLY, seqid)
5674 
    result.write(oprot)
5675 
    oprot.writeMessageEnd()
5676 
    oprot.trans.flush()
1886 ankur.sing 5677 
 
4712 rajveer 5678 
  def process_markOrderAsDelivered(self, seqid, iprot, oprot):
5679 
    args = markOrderAsDelivered_args()
5680 
    args.read(iprot)
5681 
    iprot.readMessageEnd()
5682 
    result = markOrderAsDelivered_result()
5683 
    try:
5684 
      self._handler.markOrderAsDelivered(args.orderId, args.deliveryTimestamp, args.receiver)
5685 
    except TransactionServiceException, ex:
5686 
      result.ex = ex
5687 
    oprot.writeMessageBegin("markOrderAsDelivered", TMessageType.REPLY, seqid)
5688 
    result.write(oprot)
5689 
    oprot.writeMessageEnd()
5690 
    oprot.trans.flush()
5691 
 
4454 rajveer 5692 
  def process_markOrderDoaRequestReceived(self, seqid, iprot, oprot):
5693 
    args = markOrderDoaRequestReceived_args()
5694 
    args.read(iprot)
5695 
    iprot.readMessageEnd()
5696 
    result = markOrderDoaRequestReceived_result()
5697 
    try:
5698 
      result.success = self._handler.markOrderDoaRequestReceived(args.orderId)
5699 
    except TransactionServiceException, ex:
5700 
      result.ex = ex
5701 
    oprot.writeMessageBegin("markOrderDoaRequestReceived", TMessageType.REPLY, seqid)
5702 
    result.write(oprot)
5703 
    oprot.writeMessageEnd()
5704 
    oprot.trans.flush()
5705 
 
5706 
  def process_markOrderDoaRequestAuthorized(self, seqid, iprot, oprot):
5707 
    args = markOrderDoaRequestAuthorized_args()
5708 
    args.read(iprot)
5709 
    iprot.readMessageEnd()
5710 
    result = markOrderDoaRequestAuthorized_result()
5711 
    try:
5712 
      result.success = self._handler.markOrderDoaRequestAuthorized(args.orderId, args.isAuthorized)
5713 
    except TransactionServiceException, ex:
5714 
      result.ex = ex
5715 
    oprot.writeMessageBegin("markOrderDoaRequestAuthorized", TMessageType.REPLY, seqid)
5716 
    result.write(oprot)
5717 
    oprot.writeMessageEnd()
5718 
    oprot.trans.flush()
5719 
 
4488 rajveer 5720 
  def process_markOrderReturnRequestReceived(self, seqid, iprot, oprot):
5721 
    args = markOrderReturnRequestReceived_args()
5722 
    args.read(iprot)
5723 
    iprot.readMessageEnd()
5724 
    result = markOrderReturnRequestReceived_result()
5725 
    try:
5726 
      result.success = self._handler.markOrderReturnRequestReceived(args.orderId)
5727 
    except TransactionServiceException, ex:
5728 
      result.ex = ex
5729 
    oprot.writeMessageBegin("markOrderReturnRequestReceived", TMessageType.REPLY, seqid)
5730 
    result.write(oprot)
5731 
    oprot.writeMessageEnd()
5732 
    oprot.trans.flush()
5733 
 
5734 
  def process_markOrderReturnRequestAuthorized(self, seqid, iprot, oprot):
5735 
    args = markOrderReturnRequestAuthorized_args()
5736 
    args.read(iprot)
5737 
    iprot.readMessageEnd()
5738 
    result = markOrderReturnRequestAuthorized_result()
5739 
    try:
5740 
      result.success = self._handler.markOrderReturnRequestAuthorized(args.orderId, args.isAuthorized)
5741 
    except TransactionServiceException, ex:
5742 
      result.ex = ex
5743 
    oprot.writeMessageBegin("markOrderReturnRequestAuthorized", TMessageType.REPLY, seqid)
5744 
    result.write(oprot)
5745 
    oprot.writeMessageEnd()
5746 
    oprot.trans.flush()
5747 
 
2536 chandransh 5748 
  def process_requestPickupNumber(self, seqid, iprot, oprot):
5749 
    args = requestPickupNumber_args()
5750 
    args.read(iprot)
5751 
    iprot.readMessageEnd()
5752 
    result = requestPickupNumber_result()
5753 
    try:
4579 rajveer 5754 
      result.success = self._handler.requestPickupNumber(args.orderId, args.providerId)
2536 chandransh 5755 
    except TransactionServiceException, ex:
5756 
      result.ex = ex
5757 
    oprot.writeMessageBegin("requestPickupNumber", TMessageType.REPLY, seqid)
5758 
    result.write(oprot)
5759 
    oprot.writeMessageEnd()
5760 
    oprot.trans.flush()
5761 
 
5762 
  def process_authorizePickup(self, seqid, iprot, oprot):
5763 
    args = authorizePickup_args()
5764 
    args.read(iprot)
5765 
    iprot.readMessageEnd()
5766 
    result = authorizePickup_result()
5767 
    try:
4602 rajveer 5768 
      result.success = self._handler.authorizePickup(args.orderId, args.pickupNumber, args.providerId)
2536 chandransh 5769 
    except TransactionServiceException, ex:
5770 
      result.ex = ex
5771 
    oprot.writeMessageBegin("authorizePickup", TMessageType.REPLY, seqid)
5772 
    result.write(oprot)
5773 
    oprot.writeMessageEnd()
5774 
    oprot.trans.flush()
5775 
 
2764 chandransh 5776 
  def process_markDoasAsPickedUp(self, seqid, iprot, oprot):
5777 
    args = markDoasAsPickedUp_args()
5778 
    args.read(iprot)
5779 
    iprot.readMessageEnd()
5780 
    result = markDoasAsPickedUp_result()
4910 phani.kuma 5781 
    self._handler.markDoasAsPickedUp(args.providerId, args.pickupDetails)
2764 chandransh 5782 
    oprot.writeMessageBegin("markDoasAsPickedUp", TMessageType.REPLY, seqid)
5783 
    result.write(oprot)
5784 
    oprot.writeMessageEnd()
5785 
    oprot.trans.flush()
5786 
 
4910 phani.kuma 5787 
  def process_getDoasNotPickedUp(self, seqid, iprot, oprot):
5788 
    args = getDoasNotPickedUp_args()
5789 
    args.read(iprot)
5790 
    iprot.readMessageEnd()
5791 
    result = getDoasNotPickedUp_result()
5792 
    result.success = self._handler.getDoasNotPickedUp(args.providerId)
5793 
    oprot.writeMessageBegin("getDoasNotPickedUp", TMessageType.REPLY, seqid)
5794 
    result.write(oprot)
5795 
    oprot.writeMessageEnd()
5796 
    oprot.trans.flush()
5797 
 
4741 phani.kuma 5798 
  def process_markReturnOrdersAsPickedUp(self, seqid, iprot, oprot):
5799 
    args = markReturnOrdersAsPickedUp_args()
5800 
    args.read(iprot)
5801 
    iprot.readMessageEnd()
5802 
    result = markReturnOrdersAsPickedUp_result()
4910 phani.kuma 5803 
    self._handler.markReturnOrdersAsPickedUp(args.providerId, args.pickupDetails)
4741 phani.kuma 5804 
    oprot.writeMessageBegin("markReturnOrdersAsPickedUp", TMessageType.REPLY, seqid)
5805 
    result.write(oprot)
5806 
    oprot.writeMessageEnd()
5807 
    oprot.trans.flush()
5808 
 
4910 phani.kuma 5809 
  def process_getReturnOrdersNotPickedUp(self, seqid, iprot, oprot):
5810 
    args = getReturnOrdersNotPickedUp_args()
5811 
    args.read(iprot)
5812 
    iprot.readMessageEnd()
5813 
    result = getReturnOrdersNotPickedUp_result()
5814 
    result.success = self._handler.getReturnOrdersNotPickedUp(args.providerId)
5815 
    oprot.writeMessageBegin("getReturnOrdersNotPickedUp", TMessageType.REPLY, seqid)
5816 
    result.write(oprot)
5817 
    oprot.writeMessageEnd()
5818 
    oprot.trans.flush()
5819 
 
2616 chandransh 5820 
  def process_receiveReturn(self, seqid, iprot, oprot):
5821 
    args = receiveReturn_args()
2591 chandransh 5822 
    args.read(iprot)
5823 
    iprot.readMessageEnd()
2616 chandransh 5824 
    result = receiveReturn_result()
2591 chandransh 5825 
    try:
4479 rajveer 5826 
      result.success = self._handler.receiveReturn(args.orderId, args.receiveCondition)
2591 chandransh 5827 
    except TransactionServiceException, ex:
5828 
      result.ex = ex
2616 chandransh 5829 
    oprot.writeMessageBegin("receiveReturn", TMessageType.REPLY, seqid)
2591 chandransh 5830 
    result.write(oprot)
5831 
    oprot.writeMessageEnd()
5832 
    oprot.trans.flush()
2536 chandransh 5833 
 
2591 chandransh 5834 
  def process_validateDoa(self, seqid, iprot, oprot):
5835 
    args = validateDoa_args()
5836 
    args.read(iprot)
5837 
    iprot.readMessageEnd()
5838 
    result = validateDoa_result()
5839 
    try:
5840 
      result.success = self._handler.validateDoa(args.orderId, args.isValid)
5841 
    except TransactionServiceException, ex:
5842 
      result.ex = ex
5843 
    oprot.writeMessageBegin("validateDoa", TMessageType.REPLY, seqid)
5844 
    result.write(oprot)
5845 
    oprot.writeMessageEnd()
5846 
    oprot.trans.flush()
5847 
 
4495 rajveer 5848 
  def process_validateReturnProduct(self, seqid, iprot, oprot):
5849 
    args = validateReturnProduct_args()
5850 
    args.read(iprot)
5851 
    iprot.readMessageEnd()
5852 
    result = validateReturnProduct_result()
5853 
    try:
5854 
      result.success = self._handler.validateReturnProduct(args.orderId, args.isUsable)
5855 
    except TransactionServiceException, ex:
5856 
      result.ex = ex
5857 
    oprot.writeMessageBegin("validateReturnProduct", TMessageType.REPLY, seqid)
5858 
    result.write(oprot)
5859 
    oprot.writeMessageEnd()
5860 
    oprot.trans.flush()
5861 
 
2616 chandransh 5862 
  def process_reshipOrder(self, seqid, iprot, oprot):
5863 
    args = reshipOrder_args()
5864 
    args.read(iprot)
5865 
    iprot.readMessageEnd()
5866 
    result = reshipOrder_result()
5867 
    try:
5868 
      result.success = self._handler.reshipOrder(args.orderId)
5869 
    except TransactionServiceException, ex:
5870 
      result.ex = ex
5871 
    oprot.writeMessageBegin("reshipOrder", TMessageType.REPLY, seqid)
5872 
    result.write(oprot)
5873 
    oprot.writeMessageEnd()
5874 
    oprot.trans.flush()
2591 chandransh 5875 
 
2616 chandransh 5876 
  def process_refundOrder(self, seqid, iprot, oprot):
5877 
    args = refundOrder_args()
5878 
    args.read(iprot)
5879 
    iprot.readMessageEnd()
5880 
    result = refundOrder_result()
5881 
    try:
3226 chandransh 5882 
      result.success = self._handler.refundOrder(args.orderId, args.refundedBy, args.reason)
2616 chandransh 5883 
    except TransactionServiceException, ex:
5884 
      result.ex = ex
5885 
    oprot.writeMessageBegin("refundOrder", TMessageType.REPLY, seqid)
5886 
    result.write(oprot)
5887 
    oprot.writeMessageEnd()
5888 
    oprot.trans.flush()
5889 
 
2690 chandransh 5890 
  def process_getReturnOrders(self, seqid, iprot, oprot):
5891 
    args = getReturnOrders_args()
5892 
    args.read(iprot)
5893 
    iprot.readMessageEnd()
5894 
    result = getReturnOrders_result()
5895 
    result.success = self._handler.getReturnOrders(args.warehouseId, args.fromDate, args.toDate)
5896 
    oprot.writeMessageBegin("getReturnOrders", TMessageType.REPLY, seqid)
5897 
    result.write(oprot)
5898 
    oprot.writeMessageEnd()
5899 
    oprot.trans.flush()
2616 chandransh 5900 
 
2700 chandransh 5901 
  def process_getReturnOrder(self, seqid, iprot, oprot):
5902 
    args = getReturnOrder_args()
5903 
    args.read(iprot)
5904 
    iprot.readMessageEnd()
5905 
    result = getReturnOrder_result()
5906 
    try:
5907 
      result.success = self._handler.getReturnOrder(args.id)
5908 
    except TransactionServiceException, ex:
5909 
      result.ex = ex
5910 
    oprot.writeMessageBegin("getReturnOrder", TMessageType.REPLY, seqid)
5911 
    result.write(oprot)
5912 
    oprot.writeMessageEnd()
5913 
    oprot.trans.flush()
5914 
 
2690 chandransh 5915 
  def process_processReturn(self, seqid, iprot, oprot):
5916 
    args = processReturn_args()
5917 
    args.read(iprot)
5918 
    iprot.readMessageEnd()
5919 
    result = processReturn_result()
5920 
    try:
5921 
      self._handler.processReturn(args.returnOrderId)
5922 
    except TransactionServiceException, ex:
5923 
      result.ex = ex
5924 
    oprot.writeMessageBegin("processReturn", TMessageType.REPLY, seqid)
5925 
    result.write(oprot)
5926 
    oprot.writeMessageEnd()
5927 
    oprot.trans.flush()
5928 
 
3451 chandransh 5929 
  def process_updateWeight(self, seqid, iprot, oprot):
5930 
    args = updateWeight_args()
5931 
    args.read(iprot)
5932 
    iprot.readMessageEnd()
5933 
    result = updateWeight_result()
5934 
    try:
5935 
      result.success = self._handler.updateWeight(args.orderId, args.weight)
5936 
    except TransactionServiceException, ex:
5937 
      result.ex = ex
5938 
    oprot.writeMessageBegin("updateWeight", TMessageType.REPLY, seqid)
5939 
    result.write(oprot)
5940 
    oprot.writeMessageEnd()
5941 
    oprot.trans.flush()
2819 chandransh 5942 
 
3469 chandransh 5943 
  def process_changeItem(self, seqid, iprot, oprot):
5944 
    args = changeItem_args()
5945 
    args.read(iprot)
5946 
    iprot.readMessageEnd()
5947 
    result = changeItem_result()
5948 
    try:
5949 
      result.success = self._handler.changeItem(args.orderId, args.itemId)
5950 
    except TransactionServiceException, ex:
5951 
      result.ex = ex
5952 
    oprot.writeMessageBegin("changeItem", TMessageType.REPLY, seqid)
5953 
    result.write(oprot)
5954 
    oprot.writeMessageEnd()
5955 
    oprot.trans.flush()
3451 chandransh 5956 
 
3469 chandransh 5957 
  def process_shiftToWarehouse(self, seqid, iprot, oprot):
5958 
    args = shiftToWarehouse_args()
5959 
    args.read(iprot)
5960 
    iprot.readMessageEnd()
5961 
    result = shiftToWarehouse_result()
5962 
    try:
5963 
      result.success = self._handler.shiftToWarehouse(args.orderId, args.warehouseId)
5964 
    except TransactionServiceException, ex:
5965 
      result.ex = ex
5966 
    oprot.writeMessageBegin("shiftToWarehouse", TMessageType.REPLY, seqid)
5967 
    result.write(oprot)
5968 
    oprot.writeMessageEnd()
5969 
    oprot.trans.flush()
5970 
 
3553 chandransh 5971 
  def process_addDelayReason(self, seqid, iprot, oprot):
5972 
    args = addDelayReason_args()
5973 
    args.read(iprot)
5974 
    iprot.readMessageEnd()
5975 
    result = addDelayReason_result()
5976 
    try:
4647 rajveer 5977 
      result.success = self._handler.addDelayReason(args.orderId, args.delayReason, args.furtherDelay, args.delayReasonText)
3553 chandransh 5978 
    except TransactionServiceException, ex:
5979 
      result.ex = ex
5980 
    oprot.writeMessageBegin("addDelayReason", TMessageType.REPLY, seqid)
5981 
    result.write(oprot)
5982 
    oprot.writeMessageEnd()
5983 
    oprot.trans.flush()
3469 chandransh 5984 
 
3956 chandransh 5985 
  def process_reconcileCodCollection(self, seqid, iprot, oprot):
5986 
    args = reconcileCodCollection_args()
5987 
    args.read(iprot)
5988 
    iprot.readMessageEnd()
5989 
    result = reconcileCodCollection_result()
5990 
    try:
5991 
      result.success = self._handler.reconcileCodCollection(args.collectedAmountMap, args.xferBy, args.xferTxnId, args.xferDate)
5992 
    except TransactionServiceException, ex:
5993 
      result.ex = ex
5994 
    oprot.writeMessageBegin("reconcileCodCollection", TMessageType.REPLY, seqid)
5995 
    result.write(oprot)
5996 
    oprot.writeMessageEnd()
5997 
    oprot.trans.flush()
3553 chandransh 5998 
 
4008 mandeep.dh 5999 
  def process_getTransactionsRequiringExtraProcessing(self, seqid, iprot, oprot):
6000 
    args = getTransactionsRequiringExtraProcessing_args()
6001 
    args.read(iprot)
6002 
    iprot.readMessageEnd()
6003 
    result = getTransactionsRequiringExtraProcessing_result()
6004 
    result.success = self._handler.getTransactionsRequiringExtraProcessing(args.category)
6005 
    oprot.writeMessageBegin("getTransactionsRequiringExtraProcessing", TMessageType.REPLY, seqid)
6006 
    result.write(oprot)
6007 
    oprot.writeMessageEnd()
6008 
    oprot.trans.flush()
3956 chandransh 6009 
 
4008 mandeep.dh 6010 
  def process_markTransactionAsProcessed(self, seqid, iprot, oprot):
6011 
    args = markTransactionAsProcessed_args()
6012 
    args.read(iprot)
6013 
    iprot.readMessageEnd()
6014 
    result = markTransactionAsProcessed_result()
6015 
    self._handler.markTransactionAsProcessed(args.transactionId, args.category)
6016 
    oprot.writeMessageBegin("markTransactionAsProcessed", TMessageType.REPLY, seqid)
6017 
    result.write(oprot)
6018 
    oprot.writeMessageEnd()
6019 
    oprot.trans.flush()
6020 
 
4018 chandransh 6021 
  def process_getItemWiseRiskyOrdersCount(self, seqid, iprot, oprot):
6022 
    args = getItemWiseRiskyOrdersCount_args()
6023 
    args.read(iprot)
6024 
    iprot.readMessageEnd()
6025 
    result = getItemWiseRiskyOrdersCount_result()
6026 
    result.success = self._handler.getItemWiseRiskyOrdersCount()
6027 
    oprot.writeMessageBegin("getItemWiseRiskyOrdersCount", TMessageType.REPLY, seqid)
6028 
    result.write(oprot)
6029 
    oprot.writeMessageEnd()
6030 
    oprot.trans.flush()
4008 mandeep.dh 6031 
 
4295 varun.gupt 6032 
  def process_getOrdersForItemIds(self, seqid, iprot, oprot):
6033 
    args = getOrdersForItemIds_args()
6034 
    args.read(iprot)
6035 
    iprot.readMessageEnd()
6036 
    result = getOrdersForItemIds_result()
6037 
    result.success = self._handler.getOrdersForItemIds(args.itemIds)
6038 
    oprot.writeMessageBegin("getOrdersForItemIds", TMessageType.REPLY, seqid)
6039 
    result.write(oprot)
6040 
    oprot.writeMessageEnd()
6041 
    oprot.trans.flush()
6042 
 
4247 rajveer 6043 
  def process_markOrderCancellationRequestReceived(self, seqid, iprot, oprot):
6044 
    args = markOrderCancellationRequestReceived_args()
6045 
    args.read(iprot)
6046 
    iprot.readMessageEnd()
6047 
    result = markOrderCancellationRequestReceived_result()
6048 
    try:
6049 
      self._handler.markOrderCancellationRequestReceived(args.orderId)
6050 
    except TransactionServiceException, ex:
6051 
      result.ex = ex
6052 
    oprot.writeMessageBegin("markOrderCancellationRequestReceived", TMessageType.REPLY, seqid)
6053 
    result.write(oprot)
6054 
    oprot.writeMessageEnd()
6055 
    oprot.trans.flush()
4018 chandransh 6056 
 
4247 rajveer 6057 
  def process_markOrderCancellationRequestConfirmed(self, seqid, iprot, oprot):
6058 
    args = markOrderCancellationRequestConfirmed_args()
6059 
    args.read(iprot)
6060 
    iprot.readMessageEnd()
6061 
    result = markOrderCancellationRequestConfirmed_result()
6062 
    try:
6063 
      self._handler.markOrderCancellationRequestConfirmed(args.orderId)
6064 
    except TransactionServiceException, ex:
6065 
      result.ex = ex
6066 
    oprot.writeMessageBegin("markOrderCancellationRequestConfirmed", TMessageType.REPLY, seqid)
6067 
    result.write(oprot)
6068 
    oprot.writeMessageEnd()
6069 
    oprot.trans.flush()
6070 
 
6071 
  def process_markOrderCancellationRequestDenied(self, seqid, iprot, oprot):
6072 
    args = markOrderCancellationRequestDenied_args()
6073 
    args.read(iprot)
6074 
    iprot.readMessageEnd()
6075 
    result = markOrderCancellationRequestDenied_result()
6076 
    try:
6077 
      self._handler.markOrderCancellationRequestDenied(args.orderId)
6078 
    except TransactionServiceException, ex:
6079 
      result.ex = ex
6080 
    oprot.writeMessageBegin("markOrderCancellationRequestDenied", TMessageType.REPLY, seqid)
6081 
    result.write(oprot)
6082 
    oprot.writeMessageEnd()
6083 
    oprot.trans.flush()
6084 
 
4258 rajveer 6085 
  def process_markTransactionAsPaymentFlagRemoved(self, seqid, iprot, oprot):
6086 
    args = markTransactionAsPaymentFlagRemoved_args()
4247 rajveer 6087 
    args.read(iprot)
6088 
    iprot.readMessageEnd()
4258 rajveer 6089 
    result = markTransactionAsPaymentFlagRemoved_result()
4247 rajveer 6090 
    try:
4258 rajveer 6091 
      self._handler.markTransactionAsPaymentFlagRemoved(args.transactionId)
4247 rajveer 6092 
    except TransactionServiceException, ex:
6093 
      result.ex = ex
4258 rajveer 6094 
    oprot.writeMessageBegin("markTransactionAsPaymentFlagRemoved", TMessageType.REPLY, seqid)
4247 rajveer 6095 
    result.write(oprot)
6096 
    oprot.writeMessageEnd()
6097 
    oprot.trans.flush()
6098 
 
4259 anupam.sin 6099 
  def process_refundTransaction(self, seqid, iprot, oprot):
6100 
    args = refundTransaction_args()
6101 
    args.read(iprot)
6102 
    iprot.readMessageEnd()
6103 
    result = refundTransaction_result()
6104 
    try:
6105 
      self._handler.refundTransaction(args.transactionId, args.refundedBy, args.reason)
6106 
    except TransactionServiceException, ex:
6107 
      result.ex = ex
6108 
    oprot.writeMessageBegin("refundTransaction", TMessageType.REPLY, seqid)
6109 
    result.write(oprot)
6110 
    oprot.writeMessageEnd()
6111 
    oprot.trans.flush()
4247 rajveer 6112 
 
4324 mandeep.dh 6113 
  def process_updateShipmentAddress(self, seqid, iprot, oprot):
6114 
    args = updateShipmentAddress_args()
6115 
    args.read(iprot)
6116 
    iprot.readMessageEnd()
6117 
    result = updateShipmentAddress_result()
6118 
    try:
6119 
      self._handler.updateShipmentAddress(args.orderId, args.addressId)
6120 
    except TransactionServiceException, ex:
6121 
      result.ex = ex
6122 
    oprot.writeMessageBegin("updateShipmentAddress", TMessageType.REPLY, seqid)
6123 
    result.write(oprot)
6124 
    oprot.writeMessageEnd()
6125 
    oprot.trans.flush()
6126 
 
4285 rajveer 6127 
  def process_acceptOrdersForItemId(self, seqid, iprot, oprot):
6128 
    args = acceptOrdersForItemId_args()
6129 
    args.read(iprot)
6130 
    iprot.readMessageEnd()
6131 
    result = acceptOrdersForItemId_result()
6132 
    try:
6133 
      result.success = self._handler.acceptOrdersForItemId(args.itemId, args.inventory)
6134 
    except TransactionServiceException, ex:
6135 
      result.ex = ex
6136 
    oprot.writeMessageBegin("acceptOrdersForItemId", TMessageType.REPLY, seqid)
6137 
    result.write(oprot)
6138 
    oprot.writeMessageEnd()
6139 
    oprot.trans.flush()
4259 anupam.sin 6140 
 
4303 rajveer 6141 
  def process_markOrdersAsPORaised(self, seqid, iprot, oprot):
6142 
    args = markOrdersAsPORaised_args()
6143 
    args.read(iprot)
6144 
    iprot.readMessageEnd()
6145 
    result = markOrdersAsPORaised_result()
6146 
    try:
4369 rajveer 6147 
      self._handler.markOrdersAsPORaised(args.vendorId, args.itemId, args.quantity, args.estimate, args.isReminder)
4303 rajveer 6148 
    except TransactionServiceException, ex:
6149 
      result.ex = ex
6150 
    oprot.writeMessageBegin("markOrdersAsPORaised", TMessageType.REPLY, seqid)
6151 
    result.write(oprot)
6152 
    oprot.writeMessageEnd()
6153 
    oprot.trans.flush()
4285 rajveer 6154 
 
4303 rajveer 6155 
  def process_markOrdersAsReversalInitiated(self, seqid, iprot, oprot):
6156 
    args = markOrdersAsReversalInitiated_args()
6157 
    args.read(iprot)
6158 
    iprot.readMessageEnd()
6159 
    result = markOrdersAsReversalInitiated_result()
6160 
    try:
4369 rajveer 6161 
      self._handler.markOrdersAsReversalInitiated(args.vendorId, args.itemId, args.quantity, args.estimate, args.isReminder)
4303 rajveer 6162 
    except TransactionServiceException, ex:
6163 
      result.ex = ex
6164 
    oprot.writeMessageBegin("markOrdersAsReversalInitiated", TMessageType.REPLY, seqid)
6165 
    result.write(oprot)
6166 
    oprot.writeMessageEnd()
6167 
    oprot.trans.flush()
6168 
 
6169 
  def process_markOrdersAsNotAvailabke(self, seqid, iprot, oprot):
6170 
    args = markOrdersAsNotAvailabke_args()
6171 
    args.read(iprot)
6172 
    iprot.readMessageEnd()
6173 
    result = markOrdersAsNotAvailabke_result()
6174 
    try:
4369 rajveer 6175 
      self._handler.markOrdersAsNotAvailabke(args.vendorId, args.itemId, args.quantity, args.estimate, args.isReminder)
4303 rajveer 6176 
    except TransactionServiceException, ex:
6177 
      result.ex = ex
6178 
    oprot.writeMessageBegin("markOrdersAsNotAvailabke", TMessageType.REPLY, seqid)
6179 
    result.write(oprot)
6180 
    oprot.writeMessageEnd()
6181 
    oprot.trans.flush()
6182 
 
4369 rajveer 6183 
  def process_markOrdersAsTimeout(self, seqid, iprot, oprot):
6184 
    args = markOrdersAsTimeout_args()
6185 
    args.read(iprot)
6186 
    iprot.readMessageEnd()
6187 
    result = markOrdersAsTimeout_result()
6188 
    try:
6189 
      result.success = self._handler.markOrdersAsTimeout(args.vendorId)
6190 
    except TransactionServiceException, ex:
6191 
      result.ex = ex
6192 
    oprot.writeMessageBegin("markOrdersAsTimeout", TMessageType.REPLY, seqid)
6193 
    result.write(oprot)
6194 
    oprot.writeMessageEnd()
6195 
    oprot.trans.flush()
4303 rajveer 6196 
 
4662 rajveer 6197 
  def process_markOrderAsLostInTransit(self, seqid, iprot, oprot):
6198 
    args = markOrderAsLostInTransit_args()
6199 
    args.read(iprot)
6200 
    iprot.readMessageEnd()
6201 
    result = markOrderAsLostInTransit_result()
6202 
    try:
6203 
      result.success = self._handler.markOrderAsLostInTransit(args.orderId)
6204 
    except TransactionServiceException, ex:
6205 
      result.ex = ex
6206 
    oprot.writeMessageBegin("markOrderAsLostInTransit", TMessageType.REPLY, seqid)
6207 
    result.write(oprot)
6208 
    oprot.writeMessageEnd()
6209 
    oprot.trans.flush()
6210 
 
4386 anupam.sin 6211 
  def process_getOrderForAwb(self, seqid, iprot, oprot):
6212 
    args = getOrderForAwb_args()
6213 
    args.read(iprot)
6214 
    iprot.readMessageEnd()
6215 
    result = getOrderForAwb_result()
6216 
    try:
6217 
      result.success = self._handler.getOrderForAwb(args.awb)
6218 
    except TransactionServiceException, ex:
6219 
      result.ex = ex
6220 
    oprot.writeMessageBegin("getOrderForAwb", TMessageType.REPLY, seqid)
6221 
    result.write(oprot)
6222 
    oprot.writeMessageEnd()
6223 
    oprot.trans.flush()
4369 rajveer 6224 
 
4506 phani.kuma 6225 
  def process_getOrdersForProviderForStatus(self, seqid, iprot, oprot):
6226 
    args = getOrdersForProviderForStatus_args()
6227 
    args.read(iprot)
6228 
    iprot.readMessageEnd()
6229 
    result = getOrdersForProviderForStatus_result()
6230 
    try:
4910 phani.kuma 6231 
      result.success = self._handler.getOrdersForProviderForStatus(args.logistics_provider_id, args.order_status_list)
4506 phani.kuma 6232 
    except TransactionServiceException, ex:
6233 
      result.ex = ex
6234 
    oprot.writeMessageBegin("getOrdersForProviderForStatus", TMessageType.REPLY, seqid)
6235 
    result.write(oprot)
6236 
    oprot.writeMessageEnd()
6237 
    oprot.trans.flush()
4386 anupam.sin 6238 
 
4600 varun.gupt 6239 
  def process_getBilledOrdersForVendor(self, seqid, iprot, oprot):
6240 
    args = getBilledOrdersForVendor_args()
6241 
    args.read(iprot)
6242 
    iprot.readMessageEnd()
6243 
    result = getBilledOrdersForVendor_result()
6244 
    try:
6245 
      result.success = self._handler.getBilledOrdersForVendor(args.vendorId, args.billingDateFrom, args.billingDateTo)
6246 
    except TransactionServiceException, ex:
6247 
      result.ex = ex
6248 
    oprot.writeMessageBegin("getBilledOrdersForVendor", TMessageType.REPLY, seqid)
6249 
    result.write(oprot)
6250 
    oprot.writeMessageEnd()
6251 
    oprot.trans.flush()
4506 phani.kuma 6252 
 
4607 rajveer 6253 
  def process_getSlippedSippingDateOrders(self, seqid, iprot, oprot):
6254 
    args = getSlippedSippingDateOrders_args()
6255 
    args.read(iprot)
6256 
    iprot.readMessageEnd()
6257 
    result = getSlippedSippingDateOrders_result()
6258 
    try:
6259 
      result.success = self._handler.getSlippedSippingDateOrders()
6260 
    except TransactionServiceException, ex:
6261 
      result.ex = ex
6262 
    oprot.writeMessageBegin("getSlippedSippingDateOrders", TMessageType.REPLY, seqid)
6263 
    result.write(oprot)
6264 
    oprot.writeMessageEnd()
6265 
    oprot.trans.flush()
6266 
 
4709 rajveer 6267 
  def process_getCancelledOrders(self, seqid, iprot, oprot):
6268 
    args = getCancelledOrders_args()
6269 
    args.read(iprot)
6270 
    iprot.readMessageEnd()
6271 
    result = getCancelledOrders_result()
6272 
    try:
6273 
      result.success = self._handler.getCancelledOrders(args.cancelDateFrom, args.cancelDateTo)
6274 
    except TransactionServiceException, ex:
6275 
      result.ex = ex
6276 
    oprot.writeMessageBegin("getCancelledOrders", TMessageType.REPLY, seqid)
6277 
    result.write(oprot)
6278 
    oprot.writeMessageEnd()
6279 
    oprot.trans.flush()
6280 
 
4600 varun.gupt 6281 
  def process_saveBluedartSettlements(self, seqid, iprot, oprot):
6282 
    args = saveBluedartSettlements_args()
6283 
    args.read(iprot)
6284 
    iprot.readMessageEnd()
6285 
    result = saveBluedartSettlements_result()
6286 
    try:
6287 
      self._handler.saveBluedartSettlements(args.mapAWBAndAmount)
6288 
    except TransactionServiceException, ex:
6289 
      result.ex = ex
6290 
    oprot.writeMessageBegin("saveBluedartSettlements", TMessageType.REPLY, seqid)
6291 
    result.write(oprot)
6292 
    oprot.writeMessageEnd()
6293 
    oprot.trans.flush()
6294 
 
6295 
  def process_savePaymentSettlements(self, seqid, iprot, oprot):
6296 
    args = savePaymentSettlements_args()
6297 
    args.read(iprot)
6298 
    iprot.readMessageEnd()
6299 
    result = savePaymentSettlements_result()
6300 
    try:
4905 varun.gupt 6301 
      self._handler.savePaymentSettlements(args.settlementDate, args.paymentGatewayId, args.referenceId, args.serviceTax, args.otherCharges, args.netCollection)
4600 varun.gupt 6302 
    except TransactionServiceException, ex:
6303 
      result.ex = ex
6304 
    oprot.writeMessageBegin("savePaymentSettlements", TMessageType.REPLY, seqid)
6305 
    result.write(oprot)
6306 
    oprot.writeMessageEnd()
6307 
    oprot.trans.flush()
6308 
 
6309 
  def process_saveEBSSettlementSummary(self, seqid, iprot, oprot):
6310 
    args = saveEBSSettlementSummary_args()
6311 
    args.read(iprot)
6312 
    iprot.readMessageEnd()
6313 
    result = saveEBSSettlementSummary_result()
6314 
    try:
6315 
      self._handler.saveEBSSettlementSummary(args.settlementId, args.settlementDate, args.transactionDateFrom, args.transactionDateTo, args.amount)
6316 
    except TransactionServiceException, ex:
6317 
      result.ex = ex
6318 
    oprot.writeMessageBegin("saveEBSSettlementSummary", TMessageType.REPLY, seqid)
6319 
    result.write(oprot)
6320 
    oprot.writeMessageEnd()
6321 
    oprot.trans.flush()
6322 
 
6323 
  def process_getSettlementForPaymentId(self, seqid, iprot, oprot):
6324 
    args = getSettlementForPaymentId_args()
6325 
    args.read(iprot)
6326 
    iprot.readMessageEnd()
6327 
    result = getSettlementForPaymentId_result()
6328 
    try:
6329 
      result.success = self._handler.getSettlementForPaymentId(args.paymentId)
6330 
    except TransactionServiceException, ex:
6331 
      result.ex = ex
6332 
    oprot.writeMessageBegin("getSettlementForPaymentId", TMessageType.REPLY, seqid)
6333 
    result.write(oprot)
6334 
    oprot.writeMessageEnd()
6335 
    oprot.trans.flush()
6336 
 
6337 
  def process_getEBSSettlementSummaries(self, seqid, iprot, oprot):
6338 
    args = getEBSSettlementSummaries_args()
6339 
    args.read(iprot)
6340 
    iprot.readMessageEnd()
6341 
    result = getEBSSettlementSummaries_result()
6342 
    try:
6343 
      result.success = self._handler.getEBSSettlementSummaries()
6344 
    except TransactionServiceException, ex:
6345 
      result.ex = ex
6346 
    oprot.writeMessageBegin("getEBSSettlementSummaries", TMessageType.REPLY, seqid)
6347 
    result.write(oprot)
6348 
    oprot.writeMessageEnd()
6349 
    oprot.trans.flush()
6350 
 
6351 
  def process_markEBSSettlementUploaded(self, seqid, iprot, oprot):
6352 
    args = markEBSSettlementUploaded_args()
6353 
    args.read(iprot)
6354 
    iprot.readMessageEnd()
6355 
    result = markEBSSettlementUploaded_result()
6356 
    try:
6357 
      self._handler.markEBSSettlementUploaded(args.settlementId)
6358 
    except TransactionServiceException, ex:
6359 
      result.ex = ex
6360 
    oprot.writeMessageBegin("markEBSSettlementUploaded", TMessageType.REPLY, seqid)
6361 
    result.write(oprot)
6362 
    oprot.writeMessageEnd()
6363 
    oprot.trans.flush()
6364 
 
6365 
  def process_getEBSSettlementDate(self, seqid, iprot, oprot):
6366 
    args = getEBSSettlementDate_args()
6367 
    args.read(iprot)
6368 
    iprot.readMessageEnd()
6369 
    result = getEBSSettlementDate_result()
6370 
    try:
6371 
      result.success = self._handler.getEBSSettlementDate(args.settlementId)
6372 
    except TransactionServiceException, ex:
6373 
      result.ex = ex
6374 
    oprot.writeMessageBegin("getEBSSettlementDate", TMessageType.REPLY, seqid)
6375 
    result.write(oprot)
6376 
    oprot.writeMessageEnd()
6377 
    oprot.trans.flush()
6378 
 
4715 varun.gupt 6379 
  def process_getSettlementsByDate(self, seqid, iprot, oprot):
6380 
    args = getSettlementsByDate_args()
6381 
    args.read(iprot)
6382 
    iprot.readMessageEnd()
6383 
    result = getSettlementsByDate_result()
6384 
    try:
6385 
      result.success = self._handler.getSettlementsByDate(args.settlementDateFrom, args.settlementDateTo, args.isRefund)
6386 
    except TransactionServiceException, ex:
6387 
      result.ex = ex
6388 
    oprot.writeMessageBegin("getSettlementsByDate", TMessageType.REPLY, seqid)
6389 
    result.write(oprot)
6390 
    oprot.writeMessageEnd()
6391 
    oprot.trans.flush()
4600 varun.gupt 6392 
 
4715 varun.gupt 6393 
  def process_getReshippedOrderIds(self, seqid, iprot, oprot):
6394 
    args = getReshippedOrderIds_args()
6395 
    args.read(iprot)
6396 
    iprot.readMessageEnd()
6397 
    result = getReshippedOrderIds_result()
6398 
    try:
6399 
      result.success = self._handler.getReshippedOrderIds(args.orderIds)
6400 
    except TransactionServiceException, ex:
6401 
      result.ex = ex
6402 
    oprot.writeMessageBegin("getReshippedOrderIds", TMessageType.REPLY, seqid)
6403 
    result.write(oprot)
6404 
    oprot.writeMessageEnd()
6405 
    oprot.trans.flush()
6406 
 
4757 mandeep.dh 6407 
  def process_updateOrdersAsPORaised(self, seqid, iprot, oprot):
6408 
    args = updateOrdersAsPORaised_args()
6409 
    args.read(iprot)
6410 
    iprot.readMessageEnd()
6411 
    result = updateOrdersAsPORaised_result()
6412 
    try:
6413 
      self._handler.updateOrdersAsPORaised(args.itemIdQuantityMap, args.purchaseOrderId, args.warehouseId)
6414 
    except TransactionServiceException, ex:
6415 
      result.ex = ex
6416 
    oprot.writeMessageBegin("updateOrdersAsPORaised", TMessageType.REPLY, seqid)
6417 
    result.write(oprot)
6418 
    oprot.writeMessageEnd()
6419 
    oprot.trans.flush()
4715 varun.gupt 6420 
 
4875 varun.gupt 6421 
  def process_getOrdersWhereVendorNotPaid(self, seqid, iprot, oprot):
6422 
    args = getOrdersWhereVendorNotPaid_args()
6423 
    args.read(iprot)
6424 
    iprot.readMessageEnd()
6425 
    result = getOrdersWhereVendorNotPaid_result()
6426 
    try:
6427 
      result.success = self._handler.getOrdersWhereVendorNotPaid(args.vendorId)
6428 
    except TransactionServiceException, ex:
6429 
      result.ex = ex
6430 
    oprot.writeMessageBegin("getOrdersWhereVendorNotPaid", TMessageType.REPLY, seqid)
6431 
    result.write(oprot)
6432 
    oprot.writeMessageEnd()
6433 
    oprot.trans.flush()
4757 mandeep.dh 6434 
 
5031 varun.gupt 6435 
  def process_getStatusDistributionOfOrders(self, seqid, iprot, oprot):
6436 
    args = getStatusDistributionOfOrders_args()
6437 
    args.read(iprot)
6438 
    iprot.readMessageEnd()
6439 
    result = getStatusDistributionOfOrders_result()
6440 
    try:
6441 
      result.success = self._handler.getStatusDistributionOfOrders(args.startDate, args.endDate)
6442 
    except TransactionServiceException, ex:
6443 
      result.ex = ex
6444 
    oprot.writeMessageBegin("getStatusDistributionOfOrders", TMessageType.REPLY, seqid)
6445 
    result.write(oprot)
6446 
    oprot.writeMessageEnd()
6447 
    oprot.trans.flush()
4875 varun.gupt 6448 
 
5031 varun.gupt 6449 
 
94 ashish 6450 
# HELPER FUNCTIONS AND STRUCTURES
6451 
 
6452 
class createTransaction_args:
6453 
  """
6454 
  Attributes:
6455 
   - transaction
6456 
  """
6457 
 
6458 
  thrift_spec = (
6459 
    None, # 0
6460 
    (1, TType.STRUCT, 'transaction', (Transaction, Transaction.thrift_spec), None, ), # 1
6461 
  )
6462 
 
6463 
  def __init__(self, transaction=None,):
6464 
    self.transaction = transaction
6465 
 
6466 
  def read(self, iprot):
6467 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
6468 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
6469 
      return
6470 
    iprot.readStructBegin()
6471 
    while True:
6472 
      (fname, ftype, fid) = iprot.readFieldBegin()
6473 
      if ftype == TType.STOP:
6474 
        break
6475 
      if fid == 1:
6476 
        if ftype == TType.STRUCT:
6477 
          self.transaction = Transaction()
6478 
          self.transaction.read(iprot)
6479 
        else:
6480 
          iprot.skip(ftype)
6481 
      else:
6482 
        iprot.skip(ftype)
6483 
      iprot.readFieldEnd()
6484 
    iprot.readStructEnd()
6485 
 
6486 
  def write(self, oprot):
6487 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
6488 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
6489 
      return
6490 
    oprot.writeStructBegin('createTransaction_args')
3431 rajveer 6491 
    if self.transaction is not None:
94 ashish 6492 
      oprot.writeFieldBegin('transaction', TType.STRUCT, 1)
6493 
      self.transaction.write(oprot)
6494 
      oprot.writeFieldEnd()
6495 
    oprot.writeFieldStop()
6496 
    oprot.writeStructEnd()
6497 
 
3431 rajveer 6498 
  def validate(self):
6499 
    return
6500 
 
6501 
 
94 ashish 6502 
  def __repr__(self):
6503 
    L = ['%s=%r' % (key, value)
6504 
      for key, value in self.__dict__.iteritems()]
6505 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
6506 
 
6507 
  def __eq__(self, other):
6508 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
6509 
 
6510 
  def __ne__(self, other):
6511 
    return not (self == other)
6512 
 
6513 
class createTransaction_result:
6514 
  """
6515 
  Attributes:
132 ashish 6516 
   - success
94 ashish 6517 
   - ex
6518 
  """
6519 
 
6520 
  thrift_spec = (
132 ashish 6521 
    (0, TType.I64, 'success', None, None, ), # 0
94 ashish 6522 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
6523 
  )
6524 
 
132 ashish 6525 
  def __init__(self, success=None, ex=None,):
6526 
    self.success = success
94 ashish 6527 
    self.ex = ex
6528 
 
6529 
  def read(self, iprot):
6530 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
6531 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
6532 
      return
6533 
    iprot.readStructBegin()
6534 
    while True:
6535 
      (fname, ftype, fid) = iprot.readFieldBegin()
6536 
      if ftype == TType.STOP:
6537 
        break
132 ashish 6538 
      if fid == 0:
6539 
        if ftype == TType.I64:
6540 
          self.success = iprot.readI64();
6541 
        else:
6542 
          iprot.skip(ftype)
6543 
      elif fid == 1:
94 ashish 6544 
        if ftype == TType.STRUCT:
6545 
          self.ex = TransactionServiceException()
6546 
          self.ex.read(iprot)
6547 
        else:
6548 
          iprot.skip(ftype)
6549 
      else:
6550 
        iprot.skip(ftype)
6551 
      iprot.readFieldEnd()
6552 
    iprot.readStructEnd()
6553 
 
6554 
  def write(self, oprot):
6555 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
6556 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
6557 
      return
6558 
    oprot.writeStructBegin('createTransaction_result')
3431 rajveer 6559 
    if self.success is not None:
132 ashish 6560 
      oprot.writeFieldBegin('success', TType.I64, 0)
6561 
      oprot.writeI64(self.success)
6562 
      oprot.writeFieldEnd()
3431 rajveer 6563 
    if self.ex is not None:
94 ashish 6564 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
6565 
      self.ex.write(oprot)
6566 
      oprot.writeFieldEnd()
6567 
    oprot.writeFieldStop()
6568 
    oprot.writeStructEnd()
6569 
 
3431 rajveer 6570 
  def validate(self):
6571 
    return
6572 
 
6573 
 
94 ashish 6574 
  def __repr__(self):
6575 
    L = ['%s=%r' % (key, value)
6576 
      for key, value in self.__dict__.iteritems()]
6577 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
6578 
 
6579 
  def __eq__(self, other):
6580 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
6581 
 
6582 
  def __ne__(self, other):
6583 
    return not (self == other)
6584 
 
6585 
class getTransaction_args:
6586 
  """
6587 
  Attributes:
6588 
   - id
6589 
  """
6590 
 
6591 
  thrift_spec = (
6592 
    None, # 0
6593 
    (1, TType.I64, 'id', None, None, ), # 1
6594 
  )
6595 
 
6596 
  def __init__(self, id=None,):
6597 
    self.id = id
6598 
 
6599 
  def read(self, iprot):
6600 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
6601 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
6602 
      return
6603 
    iprot.readStructBegin()
6604 
    while True:
6605 
      (fname, ftype, fid) = iprot.readFieldBegin()
6606 
      if ftype == TType.STOP:
6607 
        break
6608 
      if fid == 1:
6609 
        if ftype == TType.I64:
6610 
          self.id = iprot.readI64();
6611 
        else:
6612 
          iprot.skip(ftype)
6613 
      else:
6614 
        iprot.skip(ftype)
6615 
      iprot.readFieldEnd()
6616 
    iprot.readStructEnd()
6617 
 
6618 
  def write(self, oprot):
6619 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
6620 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
6621 
      return
6622 
    oprot.writeStructBegin('getTransaction_args')
3431 rajveer 6623 
    if self.id is not None:
94 ashish 6624 
      oprot.writeFieldBegin('id', TType.I64, 1)
6625 
      oprot.writeI64(self.id)
6626 
      oprot.writeFieldEnd()
6627 
    oprot.writeFieldStop()
6628 
    oprot.writeStructEnd()
6629 
 
3431 rajveer 6630 
  def validate(self):
6631 
    return
6632 
 
6633 
 
94 ashish 6634 
  def __repr__(self):
6635 
    L = ['%s=%r' % (key, value)
6636 
      for key, value in self.__dict__.iteritems()]
6637 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
6638 
 
6639 
  def __eq__(self, other):
6640 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
6641 
 
6642 
  def __ne__(self, other):
6643 
    return not (self == other)
6644 
 
6645 
class getTransaction_result:
6646 
  """
6647 
  Attributes:
6648 
   - success
6649 
   - ex
6650 
  """
6651 
 
6652 
  thrift_spec = (
6653 
    (0, TType.STRUCT, 'success', (Transaction, Transaction.thrift_spec), None, ), # 0
6654 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
6655 
  )
6656 
 
6657 
  def __init__(self, success=None, ex=None,):
6658 
    self.success = success
6659 
    self.ex = ex
6660 
 
6661 
  def read(self, iprot):
6662 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
6663 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
6664 
      return
6665 
    iprot.readStructBegin()
6666 
    while True:
6667 
      (fname, ftype, fid) = iprot.readFieldBegin()
6668 
      if ftype == TType.STOP:
6669 
        break
6670 
      if fid == 0:
6671 
        if ftype == TType.STRUCT:
6672 
          self.success = Transaction()
6673 
          self.success.read(iprot)
6674 
        else:
6675 
          iprot.skip(ftype)
6676 
      elif fid == 1:
6677 
        if ftype == TType.STRUCT:
6678 
          self.ex = TransactionServiceException()
6679 
          self.ex.read(iprot)
6680 
        else:
6681 
          iprot.skip(ftype)
6682 
      else:
6683 
        iprot.skip(ftype)
6684 
      iprot.readFieldEnd()
6685 
    iprot.readStructEnd()
6686 
 
6687 
  def write(self, oprot):
6688 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
6689 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
6690 
      return
6691 
    oprot.writeStructBegin('getTransaction_result')
3431 rajveer 6692 
    if self.success is not None:
94 ashish 6693 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
6694 
      self.success.write(oprot)
6695 
      oprot.writeFieldEnd()
3431 rajveer 6696 
    if self.ex is not None:
94 ashish 6697 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
6698 
      self.ex.write(oprot)
6699 
      oprot.writeFieldEnd()
6700 
    oprot.writeFieldStop()
6701 
    oprot.writeStructEnd()
6702 
 
3431 rajveer 6703 
  def validate(self):
6704 
    return
6705 
 
6706 
 
94 ashish 6707 
  def __repr__(self):
6708 
    L = ['%s=%r' % (key, value)
6709 
      for key, value in self.__dict__.iteritems()]
6710 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
6711 
 
6712 
  def __eq__(self, other):
6713 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
6714 
 
6715 
  def __ne__(self, other):
6716 
    return not (self == other)
6717 
 
6718 
class getTransactionsForCustomer_args:
6719 
  """
6720 
  Attributes:
6721 
   - customerId
6722 
   - from_date
6723 
   - to_date
6724 
   - status
6725 
  """
6726 
 
6727 
  thrift_spec = (
6728 
    None, # 0
6729 
    (1, TType.I64, 'customerId', None, None, ), # 1
6730 
    (2, TType.I64, 'from_date', None, None, ), # 2
6731 
    (3, TType.I64, 'to_date', None, None, ), # 3
6732 
    (4, TType.I32, 'status', None, None, ), # 4
6733 
  )
6734 
 
6735 
  def __init__(self, customerId=None, from_date=None, to_date=None, status=None,):
6736 
    self.customerId = customerId
6737 
    self.from_date = from_date
6738 
    self.to_date = to_date
6739 
    self.status = status
6740 
 
6741 
  def read(self, iprot):
6742 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
6743 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
6744 
      return
6745 
    iprot.readStructBegin()
6746 
    while True:
6747 
      (fname, ftype, fid) = iprot.readFieldBegin()
6748 
      if ftype == TType.STOP:
6749 
        break
6750 
      if fid == 1:
6751 
        if ftype == TType.I64:
6752 
          self.customerId = iprot.readI64();
6753 
        else:
6754 
          iprot.skip(ftype)
6755 
      elif fid == 2:
6756 
        if ftype == TType.I64:
6757 
          self.from_date = iprot.readI64();
6758 
        else:
6759 
          iprot.skip(ftype)
6760 
      elif fid == 3:
6761 
        if ftype == TType.I64:
6762 
          self.to_date = iprot.readI64();
6763 
        else:
6764 
          iprot.skip(ftype)
6765 
      elif fid == 4:
6766 
        if ftype == TType.I32:
6767 
          self.status = iprot.readI32();
6768 
        else:
6769 
          iprot.skip(ftype)
6770 
      else:
6771 
        iprot.skip(ftype)
6772 
      iprot.readFieldEnd()
6773 
    iprot.readStructEnd()
6774 
 
6775 
  def write(self, oprot):
6776 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
6777 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
6778 
      return
6779 
    oprot.writeStructBegin('getTransactionsForCustomer_args')
3431 rajveer 6780 
    if self.customerId is not None:
94 ashish 6781 
      oprot.writeFieldBegin('customerId', TType.I64, 1)
6782 
      oprot.writeI64(self.customerId)
6783 
      oprot.writeFieldEnd()
3431 rajveer 6784 
    if self.from_date is not None:
94 ashish 6785 
      oprot.writeFieldBegin('from_date', TType.I64, 2)
6786 
      oprot.writeI64(self.from_date)
6787 
      oprot.writeFieldEnd()
3431 rajveer 6788 
    if self.to_date is not None:
94 ashish 6789 
      oprot.writeFieldBegin('to_date', TType.I64, 3)
6790 
      oprot.writeI64(self.to_date)
6791 
      oprot.writeFieldEnd()
3431 rajveer 6792 
    if self.status is not None:
94 ashish 6793 
      oprot.writeFieldBegin('status', TType.I32, 4)
6794 
      oprot.writeI32(self.status)
6795 
      oprot.writeFieldEnd()
6796 
    oprot.writeFieldStop()
6797 
    oprot.writeStructEnd()
6798 
 
3431 rajveer 6799 
  def validate(self):
6800 
    return
6801 
 
6802 
 
94 ashish 6803 
  def __repr__(self):
6804 
    L = ['%s=%r' % (key, value)
6805 
      for key, value in self.__dict__.iteritems()]
6806 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
6807 
 
6808 
  def __eq__(self, other):
6809 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
6810 
 
6811 
  def __ne__(self, other):
6812 
    return not (self == other)
6813 
 
6814 
class getTransactionsForCustomer_result:
6815 
  """
6816 
  Attributes:
6817 
   - success
6818 
   - ex
6819 
  """
6820 
 
6821 
  thrift_spec = (
6822 
    (0, TType.LIST, 'success', (TType.STRUCT,(Transaction, Transaction.thrift_spec)), None, ), # 0
6823 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
6824 
  )
6825 
 
6826 
  def __init__(self, success=None, ex=None,):
6827 
    self.success = success
6828 
    self.ex = ex
6829 
 
6830 
  def read(self, iprot):
6831 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
6832 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
6833 
      return
6834 
    iprot.readStructBegin()
6835 
    while True:
6836 
      (fname, ftype, fid) = iprot.readFieldBegin()
6837 
      if ftype == TType.STOP:
6838 
        break
6839 
      if fid == 0:
6840 
        if ftype == TType.LIST:
6841 
          self.success = []
5031 varun.gupt 6842 
          (_etype66, _size63) = iprot.readListBegin()
6843 
          for _i67 in xrange(_size63):
6844 
            _elem68 = Transaction()
6845 
            _elem68.read(iprot)
6846 
            self.success.append(_elem68)
94 ashish 6847 
          iprot.readListEnd()
6848 
        else:
6849 
          iprot.skip(ftype)
6850 
      elif fid == 1:
6851 
        if ftype == TType.STRUCT:
6852 
          self.ex = TransactionServiceException()
6853 
          self.ex.read(iprot)
6854 
        else:
6855 
          iprot.skip(ftype)
6856 
      else:
6857 
        iprot.skip(ftype)
6858 
      iprot.readFieldEnd()
6859 
    iprot.readStructEnd()
6860 
 
6861 
  def write(self, oprot):
6862 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
6863 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
6864 
      return
6865 
    oprot.writeStructBegin('getTransactionsForCustomer_result')
3431 rajveer 6866 
    if self.success is not None:
94 ashish 6867 
      oprot.writeFieldBegin('success', TType.LIST, 0)
6868 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
5031 varun.gupt 6869 
      for iter69 in self.success:
6870 
        iter69.write(oprot)
94 ashish 6871 
      oprot.writeListEnd()
6872 
      oprot.writeFieldEnd()
3431 rajveer 6873 
    if self.ex is not None:
94 ashish 6874 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
6875 
      self.ex.write(oprot)
6876 
      oprot.writeFieldEnd()
6877 
    oprot.writeFieldStop()
6878 
    oprot.writeStructEnd()
6879 
 
3431 rajveer 6880 
  def validate(self):
6881 
    return
6882 
 
6883 
 
94 ashish 6884 
  def __repr__(self):
6885 
    L = ['%s=%r' % (key, value)
6886 
      for key, value in self.__dict__.iteritems()]
6887 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
6888 
 
6889 
  def __eq__(self, other):
6890 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
6891 
 
6892 
  def __ne__(self, other):
6893 
    return not (self == other)
6894 
 
132 ashish 6895 
class getTransactionsForShoppingCartId_args:
6896 
  """
6897 
  Attributes:
6898 
   - shoppingCartId
6899 
  """
6900 
 
6901 
  thrift_spec = (
6902 
    None, # 0
6903 
    (1, TType.I64, 'shoppingCartId', None, None, ), # 1
6904 
  )
6905 
 
6906 
  def __init__(self, shoppingCartId=None,):
6907 
    self.shoppingCartId = shoppingCartId
6908 
 
6909 
  def read(self, iprot):
6910 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
6911 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
6912 
      return
6913 
    iprot.readStructBegin()
6914 
    while True:
6915 
      (fname, ftype, fid) = iprot.readFieldBegin()
6916 
      if ftype == TType.STOP:
6917 
        break
6918 
      if fid == 1:
6919 
        if ftype == TType.I64:
6920 
          self.shoppingCartId = iprot.readI64();
6921 
        else:
6922 
          iprot.skip(ftype)
6923 
      else:
6924 
        iprot.skip(ftype)
6925 
      iprot.readFieldEnd()
6926 
    iprot.readStructEnd()
6927 
 
6928 
  def write(self, oprot):
6929 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
6930 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
6931 
      return
6932 
    oprot.writeStructBegin('getTransactionsForShoppingCartId_args')
3431 rajveer 6933 
    if self.shoppingCartId is not None:
132 ashish 6934 
      oprot.writeFieldBegin('shoppingCartId', TType.I64, 1)
6935 
      oprot.writeI64(self.shoppingCartId)
6936 
      oprot.writeFieldEnd()
6937 
    oprot.writeFieldStop()
6938 
    oprot.writeStructEnd()
6939 
 
3431 rajveer 6940 
  def validate(self):
6941 
    return
6942 
 
6943 
 
132 ashish 6944 
  def __repr__(self):
6945 
    L = ['%s=%r' % (key, value)
6946 
      for key, value in self.__dict__.iteritems()]
6947 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
6948 
 
6949 
  def __eq__(self, other):
6950 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
6951 
 
6952 
  def __ne__(self, other):
6953 
    return not (self == other)
6954 
 
6955 
class getTransactionsForShoppingCartId_result:
6956 
  """
6957 
  Attributes:
6958 
   - success
6959 
   - ex
6960 
  """
6961 
 
6962 
  thrift_spec = (
6963 
    (0, TType.LIST, 'success', (TType.STRUCT,(Transaction, Transaction.thrift_spec)), None, ), # 0
6964 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
6965 
  )
6966 
 
6967 
  def __init__(self, success=None, ex=None,):
6968 
    self.success = success
6969 
    self.ex = ex
6970 
 
6971 
  def read(self, iprot):
6972 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
6973 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
6974 
      return
6975 
    iprot.readStructBegin()
6976 
    while True:
6977 
      (fname, ftype, fid) = iprot.readFieldBegin()
6978 
      if ftype == TType.STOP:
6979 
        break
6980 
      if fid == 0:
6981 
        if ftype == TType.LIST:
6982 
          self.success = []
5031 varun.gupt 6983 
          (_etype73, _size70) = iprot.readListBegin()
6984 
          for _i74 in xrange(_size70):
6985 
            _elem75 = Transaction()
6986 
            _elem75.read(iprot)
6987 
            self.success.append(_elem75)
132 ashish 6988 
          iprot.readListEnd()
6989 
        else:
6990 
          iprot.skip(ftype)
6991 
      elif fid == 1:
6992 
        if ftype == TType.STRUCT:
6993 
          self.ex = TransactionServiceException()
6994 
          self.ex.read(iprot)
6995 
        else:
6996 
          iprot.skip(ftype)
6997 
      else:
6998 
        iprot.skip(ftype)
6999 
      iprot.readFieldEnd()
7000 
    iprot.readStructEnd()
7001 
 
7002 
  def write(self, oprot):
7003 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
7004 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
7005 
      return
7006 
    oprot.writeStructBegin('getTransactionsForShoppingCartId_result')
3431 rajveer 7007 
    if self.success is not None:
132 ashish 7008 
      oprot.writeFieldBegin('success', TType.LIST, 0)
7009 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
5031 varun.gupt 7010 
      for iter76 in self.success:
7011 
        iter76.write(oprot)
132 ashish 7012 
      oprot.writeListEnd()
7013 
      oprot.writeFieldEnd()
3431 rajveer 7014 
    if self.ex is not None:
132 ashish 7015 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
7016 
      self.ex.write(oprot)
7017 
      oprot.writeFieldEnd()
7018 
    oprot.writeFieldStop()
7019 
    oprot.writeStructEnd()
7020 
 
3431 rajveer 7021 
  def validate(self):
7022 
    return
7023 
 
7024 
 
132 ashish 7025 
  def __repr__(self):
7026 
    L = ['%s=%r' % (key, value)
7027 
      for key, value in self.__dict__.iteritems()]
7028 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
7029 
 
7030 
  def __eq__(self, other):
7031 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
7032 
 
7033 
  def __ne__(self, other):
7034 
    return not (self == other)
7035 
 
94 ashish 7036 
class getTransactionStatus_args:
7037 
  """
7038 
  Attributes:
7039 
   - transactionId
7040 
  """
7041 
 
7042 
  thrift_spec = (
7043 
    None, # 0
7044 
    (1, TType.I64, 'transactionId', None, None, ), # 1
7045 
  )
7046 
 
7047 
  def __init__(self, transactionId=None,):
7048 
    self.transactionId = transactionId
7049 
 
7050 
  def read(self, iprot):
7051 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
7052 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
7053 
      return
7054 
    iprot.readStructBegin()
7055 
    while True:
7056 
      (fname, ftype, fid) = iprot.readFieldBegin()
7057 
      if ftype == TType.STOP:
7058 
        break
7059 
      if fid == 1:
7060 
        if ftype == TType.I64:
7061 
          self.transactionId = iprot.readI64();
7062 
        else:
7063 
          iprot.skip(ftype)
7064 
      else:
7065 
        iprot.skip(ftype)
7066 
      iprot.readFieldEnd()
7067 
    iprot.readStructEnd()
7068 
 
7069 
  def write(self, oprot):
7070 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
7071 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
7072 
      return
7073 
    oprot.writeStructBegin('getTransactionStatus_args')
3431 rajveer 7074 
    if self.transactionId is not None:
94 ashish 7075 
      oprot.writeFieldBegin('transactionId', TType.I64, 1)
7076 
      oprot.writeI64(self.transactionId)
7077 
      oprot.writeFieldEnd()
7078 
    oprot.writeFieldStop()
7079 
    oprot.writeStructEnd()
7080 
 
3431 rajveer 7081 
  def validate(self):
7082 
    return
7083 
 
7084 
 
94 ashish 7085 
  def __repr__(self):
7086 
    L = ['%s=%r' % (key, value)
7087 
      for key, value in self.__dict__.iteritems()]
7088 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
7089 
 
7090 
  def __eq__(self, other):
7091 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
7092 
 
7093 
  def __ne__(self, other):
7094 
    return not (self == other)
7095 
 
7096 
class getTransactionStatus_result:
7097 
  """
7098 
  Attributes:
7099 
   - success
7100 
   - ex
7101 
  """
7102 
 
7103 
  thrift_spec = (
7104 
    (0, TType.I32, 'success', None, None, ), # 0
7105 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
7106 
  )
7107 
 
7108 
  def __init__(self, success=None, ex=None,):
7109 
    self.success = success
7110 
    self.ex = ex
7111 
 
7112 
  def read(self, iprot):
7113 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
7114 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
7115 
      return
7116 
    iprot.readStructBegin()
7117 
    while True:
7118 
      (fname, ftype, fid) = iprot.readFieldBegin()
7119 
      if ftype == TType.STOP:
7120 
        break
7121 
      if fid == 0:
7122 
        if ftype == TType.I32:
7123 
          self.success = iprot.readI32();
7124 
        else:
7125 
          iprot.skip(ftype)
7126 
      elif fid == 1:
7127 
        if ftype == TType.STRUCT:
7128 
          self.ex = TransactionServiceException()
7129 
          self.ex.read(iprot)
7130 
        else:
7131 
          iprot.skip(ftype)
7132 
      else:
7133 
        iprot.skip(ftype)
7134 
      iprot.readFieldEnd()
7135 
    iprot.readStructEnd()
7136 
 
7137 
  def write(self, oprot):
7138 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
7139 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
7140 
      return
7141 
    oprot.writeStructBegin('getTransactionStatus_result')
3431 rajveer 7142 
    if self.success is not None:
94 ashish 7143 
      oprot.writeFieldBegin('success', TType.I32, 0)
7144 
      oprot.writeI32(self.success)
7145 
      oprot.writeFieldEnd()
3431 rajveer 7146 
    if self.ex is not None:
94 ashish 7147 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
7148 
      self.ex.write(oprot)
7149 
      oprot.writeFieldEnd()
7150 
    oprot.writeFieldStop()
7151 
    oprot.writeStructEnd()
7152 
 
3431 rajveer 7153 
  def validate(self):
7154 
    return
7155 
 
7156 
 
94 ashish 7157 
  def __repr__(self):
7158 
    L = ['%s=%r' % (key, value)
7159 
      for key, value in self.__dict__.iteritems()]
7160 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
7161 
 
7162 
  def __eq__(self, other):
7163 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
7164 
 
7165 
  def __ne__(self, other):
7166 
    return not (self == other)
7167 
 
7168 
class changeTransactionStatus_args:
7169 
  """
7170 
  Attributes:
7171 
   - transactionId
7172 
   - status
7173 
   - description
7174 
  """
7175 
 
7176 
  thrift_spec = (
7177 
    None, # 0
7178 
    (1, TType.I64, 'transactionId', None, None, ), # 1
7179 
    (2, TType.I32, 'status', None, None, ), # 2
7180 
    (3, TType.STRING, 'description', None, None, ), # 3
7181 
  )
7182 
 
7183 
  def __init__(self, transactionId=None, status=None, description=None,):
7184 
    self.transactionId = transactionId
7185 
    self.status = status
7186 
    self.description = description
7187 
 
7188 
  def read(self, iprot):
7189 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
7190 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
7191 
      return
7192 
    iprot.readStructBegin()
7193 
    while True:
7194 
      (fname, ftype, fid) = iprot.readFieldBegin()
7195 
      if ftype == TType.STOP:
7196 
        break
7197 
      if fid == 1:
7198 
        if ftype == TType.I64:
7199 
          self.transactionId = iprot.readI64();
7200 
        else:
7201 
          iprot.skip(ftype)
7202 
      elif fid == 2:
7203 
        if ftype == TType.I32:
7204 
          self.status = iprot.readI32();
7205 
        else:
7206 
          iprot.skip(ftype)
7207 
      elif fid == 3:
7208 
        if ftype == TType.STRING:
7209 
          self.description = iprot.readString();
7210 
        else:
7211 
          iprot.skip(ftype)
7212 
      else:
7213 
        iprot.skip(ftype)
7214 
      iprot.readFieldEnd()
7215 
    iprot.readStructEnd()
7216 
 
7217 
  def write(self, oprot):
7218 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
7219 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
7220 
      return
7221 
    oprot.writeStructBegin('changeTransactionStatus_args')
3431 rajveer 7222 
    if self.transactionId is not None:
94 ashish 7223 
      oprot.writeFieldBegin('transactionId', TType.I64, 1)
7224 
      oprot.writeI64(self.transactionId)
7225 
      oprot.writeFieldEnd()
3431 rajveer 7226 
    if self.status is not None:
94 ashish 7227 
      oprot.writeFieldBegin('status', TType.I32, 2)
7228 
      oprot.writeI32(self.status)
7229 
      oprot.writeFieldEnd()
3431 rajveer 7230 
    if self.description is not None:
94 ashish 7231 
      oprot.writeFieldBegin('description', TType.STRING, 3)
7232 
      oprot.writeString(self.description)
7233 
      oprot.writeFieldEnd()
7234 
    oprot.writeFieldStop()
7235 
    oprot.writeStructEnd()
7236 
 
3431 rajveer 7237 
  def validate(self):
7238 
    return
7239 
 
7240 
 
94 ashish 7241 
  def __repr__(self):
7242 
    L = ['%s=%r' % (key, value)
7243 
      for key, value in self.__dict__.iteritems()]
7244 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
7245 
 
7246 
  def __eq__(self, other):
7247 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
7248 
 
7249 
  def __ne__(self, other):
7250 
    return not (self == other)
7251 
 
7252 
class changeTransactionStatus_result:
7253 
  """
7254 
  Attributes:
7255 
   - success
7256 
   - ex
7257 
  """
7258 
 
7259 
  thrift_spec = (
7260 
    (0, TType.BOOL, 'success', None, None, ), # 0
7261 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
7262 
  )
7263 
 
7264 
  def __init__(self, success=None, ex=None,):
7265 
    self.success = success
7266 
    self.ex = ex
7267 
 
7268 
  def read(self, iprot):
7269 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
7270 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
7271 
      return
7272 
    iprot.readStructBegin()
7273 
    while True:
7274 
      (fname, ftype, fid) = iprot.readFieldBegin()
7275 
      if ftype == TType.STOP:
7276 
        break
7277 
      if fid == 0:
7278 
        if ftype == TType.BOOL:
7279 
          self.success = iprot.readBool();
7280 
        else:
7281 
          iprot.skip(ftype)
7282 
      elif fid == 1:
7283 
        if ftype == TType.STRUCT:
7284 
          self.ex = TransactionServiceException()
7285 
          self.ex.read(iprot)
7286 
        else:
7287 
          iprot.skip(ftype)
7288 
      else:
7289 
        iprot.skip(ftype)
7290 
      iprot.readFieldEnd()
7291 
    iprot.readStructEnd()
7292 
 
7293 
  def write(self, oprot):
7294 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
7295 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
7296 
      return
7297 
    oprot.writeStructBegin('changeTransactionStatus_result')
3431 rajveer 7298 
    if self.success is not None:
94 ashish 7299 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
7300 
      oprot.writeBool(self.success)
7301 
      oprot.writeFieldEnd()
3431 rajveer 7302 
    if self.ex is not None:
94 ashish 7303 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
7304 
      self.ex.write(oprot)
7305 
      oprot.writeFieldEnd()
7306 
    oprot.writeFieldStop()
7307 
    oprot.writeStructEnd()
7308 
 
3431 rajveer 7309 
  def validate(self):
7310 
    return
7311 
 
7312 
 
94 ashish 7313 
  def __repr__(self):
7314 
    L = ['%s=%r' % (key, value)
7315 
      for key, value in self.__dict__.iteritems()]
7316 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
7317 
 
7318 
  def __eq__(self, other):
7319 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
7320 
 
7321 
  def __ne__(self, other):
7322 
    return not (self == other)
7323 
 
1398 varun.gupt 7324 
class enqueueTransactionInfoEmail_args:
1382 varun.gupt 7325 
  """
7326 
  Attributes:
7327 
   - transactionId
7328 
  """
7329 
 
7330 
  thrift_spec = (
7331 
    None, # 0
7332 
    (1, TType.I64, 'transactionId', None, None, ), # 1
7333 
  )
7334 
 
7335 
  def __init__(self, transactionId=None,):
7336 
    self.transactionId = transactionId
7337 
 
7338 
  def read(self, iprot):
7339 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
7340 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
7341 
      return
7342 
    iprot.readStructBegin()
7343 
    while True:
7344 
      (fname, ftype, fid) = iprot.readFieldBegin()
7345 
      if ftype == TType.STOP:
7346 
        break
7347 
      if fid == 1:
7348 
        if ftype == TType.I64:
7349 
          self.transactionId = iprot.readI64();
7350 
        else:
7351 
          iprot.skip(ftype)
7352 
      else:
7353 
        iprot.skip(ftype)
7354 
      iprot.readFieldEnd()
7355 
    iprot.readStructEnd()
7356 
 
7357 
  def write(self, oprot):
7358 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
7359 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
7360 
      return
1398 varun.gupt 7361 
    oprot.writeStructBegin('enqueueTransactionInfoEmail_args')
3431 rajveer 7362 
    if self.transactionId is not None:
1382 varun.gupt 7363 
      oprot.writeFieldBegin('transactionId', TType.I64, 1)
7364 
      oprot.writeI64(self.transactionId)
7365 
      oprot.writeFieldEnd()
7366 
    oprot.writeFieldStop()
7367 
    oprot.writeStructEnd()
7368 
 
3431 rajveer 7369 
  def validate(self):
7370 
    return
7371 
 
7372 
 
1382 varun.gupt 7373 
  def __repr__(self):
7374 
    L = ['%s=%r' % (key, value)
7375 
      for key, value in self.__dict__.iteritems()]
7376 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
7377 
 
7378 
  def __eq__(self, other):
7379 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
7380 
 
7381 
  def __ne__(self, other):
7382 
    return not (self == other)
7383 
 
1398 varun.gupt 7384 
class enqueueTransactionInfoEmail_result:
1382 varun.gupt 7385 
  """
7386 
  Attributes:
7387 
   - success
7388 
   - ex
7389 
  """
7390 
 
7391 
  thrift_spec = (
7392 
    (0, TType.BOOL, 'success', None, None, ), # 0
7393 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
7394 
  )
7395 
 
7396 
  def __init__(self, success=None, ex=None,):
7397 
    self.success = success
7398 
    self.ex = ex
7399 
 
7400 
  def read(self, iprot):
7401 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
7402 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
7403 
      return
7404 
    iprot.readStructBegin()
7405 
    while True:
7406 
      (fname, ftype, fid) = iprot.readFieldBegin()
7407 
      if ftype == TType.STOP:
7408 
        break
7409 
      if fid == 0:
7410 
        if ftype == TType.BOOL:
7411 
          self.success = iprot.readBool();
7412 
        else:
7413 
          iprot.skip(ftype)
7414 
      elif fid == 1:
7415 
        if ftype == TType.STRUCT:
7416 
          self.ex = TransactionServiceException()
7417 
          self.ex.read(iprot)
7418 
        else:
7419 
          iprot.skip(ftype)
7420 
      else:
7421 
        iprot.skip(ftype)
7422 
      iprot.readFieldEnd()
7423 
    iprot.readStructEnd()
7424 
 
7425 
  def write(self, oprot):
7426 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
7427 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
7428 
      return
1398 varun.gupt 7429 
    oprot.writeStructBegin('enqueueTransactionInfoEmail_result')
3431 rajveer 7430 
    if self.success is not None:
1382 varun.gupt 7431 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
7432 
      oprot.writeBool(self.success)
7433 
      oprot.writeFieldEnd()
3431 rajveer 7434 
    if self.ex is not None:
1382 varun.gupt 7435 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
7436 
      self.ex.write(oprot)
7437 
      oprot.writeFieldEnd()
7438 
    oprot.writeFieldStop()
7439 
    oprot.writeStructEnd()
7440 
 
3431 rajveer 7441 
  def validate(self):
7442 
    return
7443 
 
7444 
 
1382 varun.gupt 7445 
  def __repr__(self):
7446 
    L = ['%s=%r' % (key, value)
7447 
      for key, value in self.__dict__.iteritems()]
7448 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
7449 
 
7450 
  def __eq__(self, other):
7451 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
7452 
 
7453 
  def __ne__(self, other):
7454 
    return not (self == other)
7455 
 
483 rajveer 7456 
class getAllOrders_args:
94 ashish 7457 
  """
7458 
  Attributes:
4801 anupam.sin 7459 
   - statuses
483 rajveer 7460 
   - from_date
7461 
   - to_date
7462 
   - warehouse_id
94 ashish 7463 
  """
7464 
 
7465 
  thrift_spec = (
7466 
    None, # 0
4801 anupam.sin 7467 
    (1, TType.LIST, 'statuses', (TType.I32,None), None, ), # 1
483 rajveer 7468 
    (2, TType.I64, 'from_date', None, None, ), # 2
7469 
    (3, TType.I64, 'to_date', None, None, ), # 3
7470 
    (4, TType.I64, 'warehouse_id', None, None, ), # 4
94 ashish 7471 
  )
7472 
 
4801 anupam.sin 7473 
  def __init__(self, statuses=None, from_date=None, to_date=None, warehouse_id=None,):
7474 
    self.statuses = statuses
483 rajveer 7475 
    self.from_date = from_date
7476 
    self.to_date = to_date
7477 
    self.warehouse_id = warehouse_id
94 ashish 7478 
 
7479 
  def read(self, iprot):
7480 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
7481 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
7482 
      return
7483 
    iprot.readStructBegin()
7484 
    while True:
7485 
      (fname, ftype, fid) = iprot.readFieldBegin()
7486 
      if ftype == TType.STOP:
7487 
        break
7488 
      if fid == 1:
4801 anupam.sin 7489 
        if ftype == TType.LIST:
7490 
          self.statuses = []
5031 varun.gupt 7491 
          (_etype80, _size77) = iprot.readListBegin()
7492 
          for _i81 in xrange(_size77):
7493 
            _elem82 = iprot.readI32();
7494 
            self.statuses.append(_elem82)
4801 anupam.sin 7495 
          iprot.readListEnd()
94 ashish 7496 
        else:
7497 
          iprot.skip(ftype)
483 rajveer 7498 
      elif fid == 2:
7499 
        if ftype == TType.I64:
7500 
          self.from_date = iprot.readI64();
94 ashish 7501 
        else:
7502 
          iprot.skip(ftype)
483 rajveer 7503 
      elif fid == 3:
7504 
        if ftype == TType.I64:
7505 
          self.to_date = iprot.readI64();
94 ashish 7506 
        else:
7507 
          iprot.skip(ftype)
483 rajveer 7508 
      elif fid == 4:
94 ashish 7509 
        if ftype == TType.I64:
483 rajveer 7510 
          self.warehouse_id = iprot.readI64();
94 ashish 7511 
        else:
7512 
          iprot.skip(ftype)
7513 
      else:
7514 
        iprot.skip(ftype)
7515 
      iprot.readFieldEnd()
7516 
    iprot.readStructEnd()
7517 
 
7518 
  def write(self, oprot):
7519 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
7520 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
7521 
      return
483 rajveer 7522 
    oprot.writeStructBegin('getAllOrders_args')
4801 anupam.sin 7523 
    if self.statuses is not None:
7524 
      oprot.writeFieldBegin('statuses', TType.LIST, 1)
7525 
      oprot.writeListBegin(TType.I32, len(self.statuses))
5031 varun.gupt 7526 
      for iter83 in self.statuses:
7527 
        oprot.writeI32(iter83)
4801 anupam.sin 7528 
      oprot.writeListEnd()
94 ashish 7529 
      oprot.writeFieldEnd()
3431 rajveer 7530 
    if self.from_date is not None:
483 rajveer 7531 
      oprot.writeFieldBegin('from_date', TType.I64, 2)
7532 
      oprot.writeI64(self.from_date)
94 ashish 7533 
      oprot.writeFieldEnd()
3431 rajveer 7534 
    if self.to_date is not None:
483 rajveer 7535 
      oprot.writeFieldBegin('to_date', TType.I64, 3)
7536 
      oprot.writeI64(self.to_date)
94 ashish 7537 
      oprot.writeFieldEnd()
3431 rajveer 7538 
    if self.warehouse_id is not None:
483 rajveer 7539 
      oprot.writeFieldBegin('warehouse_id', TType.I64, 4)
7540 
      oprot.writeI64(self.warehouse_id)
94 ashish 7541 
      oprot.writeFieldEnd()
7542 
    oprot.writeFieldStop()
7543 
    oprot.writeStructEnd()
7544 
 
3431 rajveer 7545 
  def validate(self):
7546 
    return
7547 
 
7548 
 
94 ashish 7549 
  def __repr__(self):
7550 
    L = ['%s=%r' % (key, value)
7551 
      for key, value in self.__dict__.iteritems()]
7552 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
7553 
 
7554 
  def __eq__(self, other):
7555 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
7556 
 
7557 
  def __ne__(self, other):
7558 
    return not (self == other)
7559 
 
483 rajveer 7560 
class getAllOrders_result:
94 ashish 7561 
  """
7562 
  Attributes:
7563 
   - success
7564 
   - ex
7565 
  """
7566 
 
7567 
  thrift_spec = (
483 rajveer 7568 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
94 ashish 7569 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
7570 
  )
7571 
 
7572 
  def __init__(self, success=None, ex=None,):
7573 
    self.success = success
7574 
    self.ex = ex
7575 
 
7576 
  def read(self, iprot):
7577 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
7578 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
7579 
      return
7580 
    iprot.readStructBegin()
7581 
    while True:
7582 
      (fname, ftype, fid) = iprot.readFieldBegin()
7583 
      if ftype == TType.STOP:
7584 
        break
7585 
      if fid == 0:
483 rajveer 7586 
        if ftype == TType.LIST:
7587 
          self.success = []
5031 varun.gupt 7588 
          (_etype87, _size84) = iprot.readListBegin()
7589 
          for _i88 in xrange(_size84):
7590 
            _elem89 = Order()
7591 
            _elem89.read(iprot)
7592 
            self.success.append(_elem89)
483 rajveer 7593 
          iprot.readListEnd()
94 ashish 7594 
        else:
7595 
          iprot.skip(ftype)
7596 
      elif fid == 1:
7597 
        if ftype == TType.STRUCT:
7598 
          self.ex = TransactionServiceException()
7599 
          self.ex.read(iprot)
7600 
        else:
7601 
          iprot.skip(ftype)
7602 
      else:
7603 
        iprot.skip(ftype)
7604 
      iprot.readFieldEnd()
7605 
    iprot.readStructEnd()
7606 
 
7607 
  def write(self, oprot):
7608 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
7609 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
7610 
      return
483 rajveer 7611 
    oprot.writeStructBegin('getAllOrders_result')
3431 rajveer 7612 
    if self.success is not None:
483 rajveer 7613 
      oprot.writeFieldBegin('success', TType.LIST, 0)
7614 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
5031 varun.gupt 7615 
      for iter90 in self.success:
7616 
        iter90.write(oprot)
483 rajveer 7617 
      oprot.writeListEnd()
94 ashish 7618 
      oprot.writeFieldEnd()
3431 rajveer 7619 
    if self.ex is not None:
94 ashish 7620 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
7621 
      self.ex.write(oprot)
7622 
      oprot.writeFieldEnd()
7623 
    oprot.writeFieldStop()
7624 
    oprot.writeStructEnd()
7625 
 
3431 rajveer 7626 
  def validate(self):
7627 
    return
7628 
 
7629 
 
94 ashish 7630 
  def __repr__(self):
7631 
    L = ['%s=%r' % (key, value)
7632 
      for key, value in self.__dict__.iteritems()]
7633 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
7634 
 
7635 
  def __eq__(self, other):
7636 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
7637 
 
7638 
  def __ne__(self, other):
7639 
    return not (self == other)
7640 
 
4133 chandransh 7641 
class getOrdersInBatch_args:
7642 
  """
7643 
  Attributes:
7644 
   - statuses
7645 
   - offset
7646 
   - limit
7647 
   - warehouse_id
7648 
  """
7649 
 
7650 
  thrift_spec = (
7651 
    None, # 0
7652 
    (1, TType.LIST, 'statuses', (TType.I32,None), None, ), # 1
7653 
    (2, TType.I64, 'offset', None, None, ), # 2
7654 
    (3, TType.I64, 'limit', None, None, ), # 3
7655 
    (4, TType.I64, 'warehouse_id', None, None, ), # 4
7656 
  )
7657 
 
7658 
  def __init__(self, statuses=None, offset=None, limit=None, warehouse_id=None,):
7659 
    self.statuses = statuses
7660 
    self.offset = offset
7661 
    self.limit = limit
7662 
    self.warehouse_id = warehouse_id
7663 
 
7664 
  def read(self, iprot):
7665 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
7666 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
7667 
      return
7668 
    iprot.readStructBegin()
7669 
    while True:
7670 
      (fname, ftype, fid) = iprot.readFieldBegin()
7671 
      if ftype == TType.STOP:
7672 
        break
7673 
      if fid == 1:
7674 
        if ftype == TType.LIST:
7675 
          self.statuses = []
5031 varun.gupt 7676 
          (_etype94, _size91) = iprot.readListBegin()
7677 
          for _i95 in xrange(_size91):
7678 
            _elem96 = iprot.readI32();
7679 
            self.statuses.append(_elem96)
4133 chandransh 7680 
          iprot.readListEnd()
7681 
        else:
7682 
          iprot.skip(ftype)
7683 
      elif fid == 2:
7684 
        if ftype == TType.I64:
7685 
          self.offset = iprot.readI64();
7686 
        else:
7687 
          iprot.skip(ftype)
7688 
      elif fid == 3:
7689 
        if ftype == TType.I64:
7690 
          self.limit = iprot.readI64();
7691 
        else:
7692 
          iprot.skip(ftype)
7693 
      elif fid == 4:
7694 
        if ftype == TType.I64:
7695 
          self.warehouse_id = iprot.readI64();
7696 
        else:
7697 
          iprot.skip(ftype)
7698 
      else:
7699 
        iprot.skip(ftype)
7700 
      iprot.readFieldEnd()
7701 
    iprot.readStructEnd()
7702 
 
7703 
  def write(self, oprot):
7704 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
7705 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
7706 
      return
7707 
    oprot.writeStructBegin('getOrdersInBatch_args')
7708 
    if self.statuses is not None:
7709 
      oprot.writeFieldBegin('statuses', TType.LIST, 1)
7710 
      oprot.writeListBegin(TType.I32, len(self.statuses))
5031 varun.gupt 7711 
      for iter97 in self.statuses:
7712 
        oprot.writeI32(iter97)
4133 chandransh 7713 
      oprot.writeListEnd()
7714 
      oprot.writeFieldEnd()
7715 
    if self.offset is not None:
7716 
      oprot.writeFieldBegin('offset', TType.I64, 2)
7717 
      oprot.writeI64(self.offset)
7718 
      oprot.writeFieldEnd()
7719 
    if self.limit is not None:
7720 
      oprot.writeFieldBegin('limit', TType.I64, 3)
7721 
      oprot.writeI64(self.limit)
7722 
      oprot.writeFieldEnd()
7723 
    if self.warehouse_id is not None:
7724 
      oprot.writeFieldBegin('warehouse_id', TType.I64, 4)
7725 
      oprot.writeI64(self.warehouse_id)
7726 
      oprot.writeFieldEnd()
7727 
    oprot.writeFieldStop()
7728 
    oprot.writeStructEnd()
7729 
 
7730 
  def validate(self):
7731 
    return
7732 
 
7733 
 
7734 
  def __repr__(self):
7735 
    L = ['%s=%r' % (key, value)
7736 
      for key, value in self.__dict__.iteritems()]
7737 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
7738 
 
7739 
  def __eq__(self, other):
7740 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
7741 
 
7742 
  def __ne__(self, other):
7743 
    return not (self == other)
7744 
 
7745 
class getOrdersInBatch_result:
7746 
  """
7747 
  Attributes:
7748 
   - success
7749 
   - ex
7750 
  """
7751 
 
7752 
  thrift_spec = (
7753 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
7754 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
7755 
  )
7756 
 
7757 
  def __init__(self, success=None, ex=None,):
7758 
    self.success = success
7759 
    self.ex = ex
7760 
 
7761 
  def read(self, iprot):
7762 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
7763 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
7764 
      return
7765 
    iprot.readStructBegin()
7766 
    while True:
7767 
      (fname, ftype, fid) = iprot.readFieldBegin()
7768 
      if ftype == TType.STOP:
7769 
        break
7770 
      if fid == 0:
7771 
        if ftype == TType.LIST:
7772 
          self.success = []
5031 varun.gupt 7773 
          (_etype101, _size98) = iprot.readListBegin()
7774 
          for _i102 in xrange(_size98):
7775 
            _elem103 = Order()
7776 
            _elem103.read(iprot)
7777 
            self.success.append(_elem103)
4133 chandransh 7778 
          iprot.readListEnd()
7779 
        else:
7780 
          iprot.skip(ftype)
7781 
      elif fid == 1:
7782 
        if ftype == TType.STRUCT:
7783 
          self.ex = TransactionServiceException()
7784 
          self.ex.read(iprot)
7785 
        else:
7786 
          iprot.skip(ftype)
7787 
      else:
7788 
        iprot.skip(ftype)
7789 
      iprot.readFieldEnd()
7790 
    iprot.readStructEnd()
7791 
 
7792 
  def write(self, oprot):
7793 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
7794 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
7795 
      return
7796 
    oprot.writeStructBegin('getOrdersInBatch_result')
7797 
    if self.success is not None:
7798 
      oprot.writeFieldBegin('success', TType.LIST, 0)
7799 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
5031 varun.gupt 7800 
      for iter104 in self.success:
7801 
        iter104.write(oprot)
4133 chandransh 7802 
      oprot.writeListEnd()
7803 
      oprot.writeFieldEnd()
7804 
    if self.ex is not None:
7805 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
7806 
      self.ex.write(oprot)
7807 
      oprot.writeFieldEnd()
7808 
    oprot.writeFieldStop()
7809 
    oprot.writeStructEnd()
7810 
 
7811 
  def validate(self):
7812 
    return
7813 
 
7814 
 
7815 
  def __repr__(self):
7816 
    L = ['%s=%r' % (key, value)
7817 
      for key, value in self.__dict__.iteritems()]
7818 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
7819 
 
7820 
  def __eq__(self, other):
7821 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
7822 
 
7823 
  def __ne__(self, other):
7824 
    return not (self == other)
7825 
 
7826 
class getOrderCount_args:
7827 
  """
7828 
  Attributes:
7829 
   - statuses
7830 
   - warehouseId
7831 
  """
7832 
 
7833 
  thrift_spec = (
7834 
    None, # 0
7835 
    (1, TType.LIST, 'statuses', (TType.I32,None), None, ), # 1
7836 
    (2, TType.I64, 'warehouseId', None, None, ), # 2
7837 
  )
7838 
 
7839 
  def __init__(self, statuses=None, warehouseId=None,):
7840 
    self.statuses = statuses
7841 
    self.warehouseId = warehouseId
7842 
 
7843 
  def read(self, iprot):
7844 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
7845 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
7846 
      return
7847 
    iprot.readStructBegin()
7848 
    while True:
7849 
      (fname, ftype, fid) = iprot.readFieldBegin()
7850 
      if ftype == TType.STOP:
7851 
        break
7852 
      if fid == 1:
7853 
        if ftype == TType.LIST:
7854 
          self.statuses = []
5031 varun.gupt 7855 
          (_etype108, _size105) = iprot.readListBegin()
7856 
          for _i109 in xrange(_size105):
7857 
            _elem110 = iprot.readI32();
7858 
            self.statuses.append(_elem110)
4133 chandransh 7859 
          iprot.readListEnd()
7860 
        else:
7861 
          iprot.skip(ftype)
7862 
      elif fid == 2:
7863 
        if ftype == TType.I64:
7864 
          self.warehouseId = iprot.readI64();
7865 
        else:
7866 
          iprot.skip(ftype)
7867 
      else:
7868 
        iprot.skip(ftype)
7869 
      iprot.readFieldEnd()
7870 
    iprot.readStructEnd()
7871 
 
7872 
  def write(self, oprot):
7873 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
7874 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
7875 
      return
7876 
    oprot.writeStructBegin('getOrderCount_args')
7877 
    if self.statuses is not None:
7878 
      oprot.writeFieldBegin('statuses', TType.LIST, 1)
7879 
      oprot.writeListBegin(TType.I32, len(self.statuses))
5031 varun.gupt 7880 
      for iter111 in self.statuses:
7881 
        oprot.writeI32(iter111)
4133 chandransh 7882 
      oprot.writeListEnd()
7883 
      oprot.writeFieldEnd()
7884 
    if self.warehouseId is not None:
7885 
      oprot.writeFieldBegin('warehouseId', TType.I64, 2)
7886 
      oprot.writeI64(self.warehouseId)
7887 
      oprot.writeFieldEnd()
7888 
    oprot.writeFieldStop()
7889 
    oprot.writeStructEnd()
7890 
 
7891 
  def validate(self):
7892 
    return
7893 
 
7894 
 
7895 
  def __repr__(self):
7896 
    L = ['%s=%r' % (key, value)
7897 
      for key, value in self.__dict__.iteritems()]
7898 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
7899 
 
7900 
  def __eq__(self, other):
7901 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
7902 
 
7903 
  def __ne__(self, other):
7904 
    return not (self == other)
7905 
 
7906 
class getOrderCount_result:
7907 
  """
7908 
  Attributes:
7909 
   - success
7910 
   - ex
7911 
  """
7912 
 
7913 
  thrift_spec = (
7914 
    (0, TType.I32, 'success', None, None, ), # 0
7915 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
7916 
  )
7917 
 
7918 
  def __init__(self, success=None, ex=None,):
7919 
    self.success = success
7920 
    self.ex = ex
7921 
 
7922 
  def read(self, iprot):
7923 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
7924 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
7925 
      return
7926 
    iprot.readStructBegin()
7927 
    while True:
7928 
      (fname, ftype, fid) = iprot.readFieldBegin()
7929 
      if ftype == TType.STOP:
7930 
        break
7931 
      if fid == 0:
7932 
        if ftype == TType.I32:
7933 
          self.success = iprot.readI32();
7934 
        else:
7935 
          iprot.skip(ftype)
7936 
      elif fid == 1:
7937 
        if ftype == TType.STRUCT:
7938 
          self.ex = TransactionServiceException()
7939 
          self.ex.read(iprot)
7940 
        else:
7941 
          iprot.skip(ftype)
7942 
      else:
7943 
        iprot.skip(ftype)
7944 
      iprot.readFieldEnd()
7945 
    iprot.readStructEnd()
7946 
 
7947 
  def write(self, oprot):
7948 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
7949 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
7950 
      return
7951 
    oprot.writeStructBegin('getOrderCount_result')
7952 
    if self.success is not None:
7953 
      oprot.writeFieldBegin('success', TType.I32, 0)
7954 
      oprot.writeI32(self.success)
7955 
      oprot.writeFieldEnd()
7956 
    if self.ex is not None:
7957 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
7958 
      self.ex.write(oprot)
7959 
      oprot.writeFieldEnd()
7960 
    oprot.writeFieldStop()
7961 
    oprot.writeStructEnd()
7962 
 
7963 
  def validate(self):
7964 
    return
7965 
 
7966 
 
7967 
  def __repr__(self):
7968 
    L = ['%s=%r' % (key, value)
7969 
      for key, value in self.__dict__.iteritems()]
7970 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
7971 
 
7972 
  def __eq__(self, other):
7973 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
7974 
 
7975 
  def __ne__(self, other):
7976 
    return not (self == other)
7977 
 
999 varun.gupt 7978 
class getOrdersByBillingDate_args:
7979 
  """
7980 
  Attributes:
7981 
   - status
7982 
   - start_billing_date
7983 
   - end_billing_date
7984 
   - warehouse_id
7985 
  """
7986 
 
7987 
  thrift_spec = (
7988 
    None, # 0
7989 
    (1, TType.I32, 'status', None, None, ), # 1
7990 
    (2, TType.I64, 'start_billing_date', None, None, ), # 2
7991 
    (3, TType.I64, 'end_billing_date', None, None, ), # 3
7992 
    (4, TType.I64, 'warehouse_id', None, None, ), # 4
7993 
  )
7994 
 
7995 
  def __init__(self, status=None, start_billing_date=None, end_billing_date=None, warehouse_id=None,):
7996 
    self.status = status
7997 
    self.start_billing_date = start_billing_date
7998 
    self.end_billing_date = end_billing_date
7999 
    self.warehouse_id = warehouse_id
8000 
 
8001 
  def read(self, iprot):
8002 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8003 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8004 
      return
8005 
    iprot.readStructBegin()
8006 
    while True:
8007 
      (fname, ftype, fid) = iprot.readFieldBegin()
8008 
      if ftype == TType.STOP:
8009 
        break
8010 
      if fid == 1:
8011 
        if ftype == TType.I32:
8012 
          self.status = iprot.readI32();
8013 
        else:
8014 
          iprot.skip(ftype)
8015 
      elif fid == 2:
8016 
        if ftype == TType.I64:
8017 
          self.start_billing_date = iprot.readI64();
8018 
        else:
8019 
          iprot.skip(ftype)
8020 
      elif fid == 3:
8021 
        if ftype == TType.I64:
8022 
          self.end_billing_date = iprot.readI64();
8023 
        else:
8024 
          iprot.skip(ftype)
8025 
      elif fid == 4:
8026 
        if ftype == TType.I64:
8027 
          self.warehouse_id = iprot.readI64();
8028 
        else:
8029 
          iprot.skip(ftype)
8030 
      else:
8031 
        iprot.skip(ftype)
8032 
      iprot.readFieldEnd()
8033 
    iprot.readStructEnd()
8034 
 
8035 
  def write(self, oprot):
8036 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8037 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8038 
      return
8039 
    oprot.writeStructBegin('getOrdersByBillingDate_args')
3431 rajveer 8040 
    if self.status is not None:
999 varun.gupt 8041 
      oprot.writeFieldBegin('status', TType.I32, 1)
8042 
      oprot.writeI32(self.status)
8043 
      oprot.writeFieldEnd()
3431 rajveer 8044 
    if self.start_billing_date is not None:
999 varun.gupt 8045 
      oprot.writeFieldBegin('start_billing_date', TType.I64, 2)
8046 
      oprot.writeI64(self.start_billing_date)
8047 
      oprot.writeFieldEnd()
3431 rajveer 8048 
    if self.end_billing_date is not None:
999 varun.gupt 8049 
      oprot.writeFieldBegin('end_billing_date', TType.I64, 3)
8050 
      oprot.writeI64(self.end_billing_date)
8051 
      oprot.writeFieldEnd()
3431 rajveer 8052 
    if self.warehouse_id is not None:
999 varun.gupt 8053 
      oprot.writeFieldBegin('warehouse_id', TType.I64, 4)
8054 
      oprot.writeI64(self.warehouse_id)
8055 
      oprot.writeFieldEnd()
8056 
    oprot.writeFieldStop()
8057 
    oprot.writeStructEnd()
8058 
 
3431 rajveer 8059 
  def validate(self):
8060 
    return
8061 
 
8062 
 
999 varun.gupt 8063 
  def __repr__(self):
8064 
    L = ['%s=%r' % (key, value)
8065 
      for key, value in self.__dict__.iteritems()]
8066 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8067 
 
8068 
  def __eq__(self, other):
8069 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8070 
 
8071 
  def __ne__(self, other):
8072 
    return not (self == other)
8073 
 
8074 
class getOrdersByBillingDate_result:
8075 
  """
8076 
  Attributes:
8077 
   - success
8078 
   - ex
8079 
  """
8080 
 
8081 
  thrift_spec = (
8082 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
8083 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
8084 
  )
8085 
 
8086 
  def __init__(self, success=None, ex=None,):
8087 
    self.success = success
8088 
    self.ex = ex
8089 
 
8090 
  def read(self, iprot):
8091 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8092 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8093 
      return
8094 
    iprot.readStructBegin()
8095 
    while True:
8096 
      (fname, ftype, fid) = iprot.readFieldBegin()
8097 
      if ftype == TType.STOP:
8098 
        break
8099 
      if fid == 0:
8100 
        if ftype == TType.LIST:
8101 
          self.success = []
5031 varun.gupt 8102 
          (_etype115, _size112) = iprot.readListBegin()
8103 
          for _i116 in xrange(_size112):
8104 
            _elem117 = Order()
8105 
            _elem117.read(iprot)
8106 
            self.success.append(_elem117)
999 varun.gupt 8107 
          iprot.readListEnd()
8108 
        else:
8109 
          iprot.skip(ftype)
8110 
      elif fid == 1:
8111 
        if ftype == TType.STRUCT:
8112 
          self.ex = TransactionServiceException()
8113 
          self.ex.read(iprot)
8114 
        else:
8115 
          iprot.skip(ftype)
8116 
      else:
8117 
        iprot.skip(ftype)
8118 
      iprot.readFieldEnd()
8119 
    iprot.readStructEnd()
8120 
 
8121 
  def write(self, oprot):
8122 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8123 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8124 
      return
8125 
    oprot.writeStructBegin('getOrdersByBillingDate_result')
3431 rajveer 8126 
    if self.success is not None:
999 varun.gupt 8127 
      oprot.writeFieldBegin('success', TType.LIST, 0)
8128 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
5031 varun.gupt 8129 
      for iter118 in self.success:
8130 
        iter118.write(oprot)
999 varun.gupt 8131 
      oprot.writeListEnd()
8132 
      oprot.writeFieldEnd()
3431 rajveer 8133 
    if self.ex is not None:
999 varun.gupt 8134 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
8135 
      self.ex.write(oprot)
8136 
      oprot.writeFieldEnd()
8137 
    oprot.writeFieldStop()
8138 
    oprot.writeStructEnd()
8139 
 
3431 rajveer 8140 
  def validate(self):
8141 
    return
8142 
 
8143 
 
999 varun.gupt 8144 
  def __repr__(self):
8145 
    L = ['%s=%r' % (key, value)
8146 
      for key, value in self.__dict__.iteritems()]
8147 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8148 
 
8149 
  def __eq__(self, other):
8150 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8151 
 
8152 
  def __ne__(self, other):
8153 
    return not (self == other)
8154 
 
3427 chandransh 8155 
class getOrdersByShippingDate_args:
8156 
  """
8157 
  Attributes:
8158 
   - fromShippingDate
8159 
   - toShippingDate
8160 
   - providerId
8161 
   - warehouseId
3451 chandransh 8162 
   - cod
3427 chandransh 8163 
  """
8164 
 
8165 
  thrift_spec = (
8166 
    None, # 0
8167 
    (1, TType.I64, 'fromShippingDate', None, None, ), # 1
8168 
    (2, TType.I64, 'toShippingDate', None, None, ), # 2
8169 
    (3, TType.I64, 'providerId', None, None, ), # 3
8170 
    (4, TType.I64, 'warehouseId', None, None, ), # 4
3451 chandransh 8171 
    (5, TType.BOOL, 'cod', None, None, ), # 5
3427 chandransh 8172 
  )
8173 
 
3451 chandransh 8174 
  def __init__(self, fromShippingDate=None, toShippingDate=None, providerId=None, warehouseId=None, cod=None,):
3427 chandransh 8175 
    self.fromShippingDate = fromShippingDate
8176 
    self.toShippingDate = toShippingDate
8177 
    self.providerId = providerId
8178 
    self.warehouseId = warehouseId
3451 chandransh 8179 
    self.cod = cod
3427 chandransh 8180 
 
8181 
  def read(self, iprot):
8182 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8183 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8184 
      return
8185 
    iprot.readStructBegin()
8186 
    while True:
8187 
      (fname, ftype, fid) = iprot.readFieldBegin()
8188 
      if ftype == TType.STOP:
8189 
        break
8190 
      if fid == 1:
8191 
        if ftype == TType.I64:
8192 
          self.fromShippingDate = iprot.readI64();
8193 
        else:
8194 
          iprot.skip(ftype)
8195 
      elif fid == 2:
8196 
        if ftype == TType.I64:
8197 
          self.toShippingDate = iprot.readI64();
8198 
        else:
8199 
          iprot.skip(ftype)
8200 
      elif fid == 3:
8201 
        if ftype == TType.I64:
8202 
          self.providerId = iprot.readI64();
8203 
        else:
8204 
          iprot.skip(ftype)
8205 
      elif fid == 4:
8206 
        if ftype == TType.I64:
8207 
          self.warehouseId = iprot.readI64();
8208 
        else:
8209 
          iprot.skip(ftype)
3451 chandransh 8210 
      elif fid == 5:
8211 
        if ftype == TType.BOOL:
8212 
          self.cod = iprot.readBool();
8213 
        else:
8214 
          iprot.skip(ftype)
3427 chandransh 8215 
      else:
8216 
        iprot.skip(ftype)
8217 
      iprot.readFieldEnd()
8218 
    iprot.readStructEnd()
8219 
 
8220 
  def write(self, oprot):
8221 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8222 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8223 
      return
8224 
    oprot.writeStructBegin('getOrdersByShippingDate_args')
3431 rajveer 8225 
    if self.fromShippingDate is not None:
3427 chandransh 8226 
      oprot.writeFieldBegin('fromShippingDate', TType.I64, 1)
8227 
      oprot.writeI64(self.fromShippingDate)
8228 
      oprot.writeFieldEnd()
3431 rajveer 8229 
    if self.toShippingDate is not None:
3427 chandransh 8230 
      oprot.writeFieldBegin('toShippingDate', TType.I64, 2)
8231 
      oprot.writeI64(self.toShippingDate)
8232 
      oprot.writeFieldEnd()
3431 rajveer 8233 
    if self.providerId is not None:
3427 chandransh 8234 
      oprot.writeFieldBegin('providerId', TType.I64, 3)
8235 
      oprot.writeI64(self.providerId)
8236 
      oprot.writeFieldEnd()
3431 rajveer 8237 
    if self.warehouseId is not None:
3427 chandransh 8238 
      oprot.writeFieldBegin('warehouseId', TType.I64, 4)
8239 
      oprot.writeI64(self.warehouseId)
8240 
      oprot.writeFieldEnd()
3451 chandransh 8241 
    if self.cod is not None:
8242 
      oprot.writeFieldBegin('cod', TType.BOOL, 5)
8243 
      oprot.writeBool(self.cod)
8244 
      oprot.writeFieldEnd()
3427 chandransh 8245 
    oprot.writeFieldStop()
8246 
    oprot.writeStructEnd()
8247 
 
3431 rajveer 8248 
  def validate(self):
8249 
    return
8250 
 
8251 
 
3427 chandransh 8252 
  def __repr__(self):
8253 
    L = ['%s=%r' % (key, value)
8254 
      for key, value in self.__dict__.iteritems()]
8255 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8256 
 
8257 
  def __eq__(self, other):
8258 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8259 
 
8260 
  def __ne__(self, other):
8261 
    return not (self == other)
8262 
 
8263 
class getOrdersByShippingDate_result:
8264 
  """
8265 
  Attributes:
8266 
   - success
8267 
   - ex
8268 
  """
8269 
 
8270 
  thrift_spec = (
8271 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
8272 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
8273 
  )
8274 
 
8275 
  def __init__(self, success=None, ex=None,):
8276 
    self.success = success
8277 
    self.ex = ex
8278 
 
8279 
  def read(self, iprot):
8280 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8281 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8282 
      return
8283 
    iprot.readStructBegin()
8284 
    while True:
8285 
      (fname, ftype, fid) = iprot.readFieldBegin()
8286 
      if ftype == TType.STOP:
8287 
        break
8288 
      if fid == 0:
8289 
        if ftype == TType.LIST:
8290 
          self.success = []
5031 varun.gupt 8291 
          (_etype122, _size119) = iprot.readListBegin()
8292 
          for _i123 in xrange(_size119):
8293 
            _elem124 = Order()
8294 
            _elem124.read(iprot)
8295 
            self.success.append(_elem124)
3427 chandransh 8296 
          iprot.readListEnd()
8297 
        else:
8298 
          iprot.skip(ftype)
8299 
      elif fid == 1:
8300 
        if ftype == TType.STRUCT:
8301 
          self.ex = TransactionServiceException()
8302 
          self.ex.read(iprot)
8303 
        else:
8304 
          iprot.skip(ftype)
8305 
      else:
8306 
        iprot.skip(ftype)
8307 
      iprot.readFieldEnd()
8308 
    iprot.readStructEnd()
8309 
 
8310 
  def write(self, oprot):
8311 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8312 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8313 
      return
8314 
    oprot.writeStructBegin('getOrdersByShippingDate_result')
3431 rajveer 8315 
    if self.success is not None:
3427 chandransh 8316 
      oprot.writeFieldBegin('success', TType.LIST, 0)
8317 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
5031 varun.gupt 8318 
      for iter125 in self.success:
8319 
        iter125.write(oprot)
3427 chandransh 8320 
      oprot.writeListEnd()
8321 
      oprot.writeFieldEnd()
3431 rajveer 8322 
    if self.ex is not None:
3427 chandransh 8323 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
8324 
      self.ex.write(oprot)
8325 
      oprot.writeFieldEnd()
8326 
    oprot.writeFieldStop()
8327 
    oprot.writeStructEnd()
8328 
 
3431 rajveer 8329 
  def validate(self):
8330 
    return
8331 
 
8332 
 
3427 chandransh 8333 
  def __repr__(self):
8334 
    L = ['%s=%r' % (key, value)
8335 
      for key, value in self.__dict__.iteritems()]
8336 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8337 
 
8338 
  def __eq__(self, other):
8339 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8340 
 
8341 
  def __ne__(self, other):
8342 
    return not (self == other)
8343 
 
1382 varun.gupt 8344 
class getReturnableOrdersForCustomer_args:
8345 
  """
8346 
  Attributes:
8347 
   - customer_id
8348 
   - limit
8349 
  """
8350 
 
8351 
  thrift_spec = (
8352 
    None, # 0
8353 
    (1, TType.I64, 'customer_id', None, None, ), # 1
8354 
    (2, TType.I64, 'limit', None, None, ), # 2
8355 
  )
8356 
 
8357 
  def __init__(self, customer_id=None, limit=None,):
8358 
    self.customer_id = customer_id
8359 
    self.limit = limit
8360 
 
8361 
  def read(self, iprot):
8362 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8363 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8364 
      return
8365 
    iprot.readStructBegin()
8366 
    while True:
8367 
      (fname, ftype, fid) = iprot.readFieldBegin()
8368 
      if ftype == TType.STOP:
8369 
        break
8370 
      if fid == 1:
8371 
        if ftype == TType.I64:
8372 
          self.customer_id = iprot.readI64();
8373 
        else:
8374 
          iprot.skip(ftype)
8375 
      elif fid == 2:
8376 
        if ftype == TType.I64:
8377 
          self.limit = iprot.readI64();
8378 
        else:
8379 
          iprot.skip(ftype)
8380 
      else:
8381 
        iprot.skip(ftype)
8382 
      iprot.readFieldEnd()
8383 
    iprot.readStructEnd()
8384 
 
8385 
  def write(self, oprot):
8386 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8387 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8388 
      return
8389 
    oprot.writeStructBegin('getReturnableOrdersForCustomer_args')
3431 rajveer 8390 
    if self.customer_id is not None:
1382 varun.gupt 8391 
      oprot.writeFieldBegin('customer_id', TType.I64, 1)
8392 
      oprot.writeI64(self.customer_id)
8393 
      oprot.writeFieldEnd()
3431 rajveer 8394 
    if self.limit is not None:
1382 varun.gupt 8395 
      oprot.writeFieldBegin('limit', TType.I64, 2)
8396 
      oprot.writeI64(self.limit)
8397 
      oprot.writeFieldEnd()
8398 
    oprot.writeFieldStop()
8399 
    oprot.writeStructEnd()
8400 
 
3431 rajveer 8401 
  def validate(self):
8402 
    return
8403 
 
8404 
 
1382 varun.gupt 8405 
  def __repr__(self):
8406 
    L = ['%s=%r' % (key, value)
8407 
      for key, value in self.__dict__.iteritems()]
8408 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8409 
 
8410 
  def __eq__(self, other):
8411 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8412 
 
8413 
  def __ne__(self, other):
8414 
    return not (self == other)
8415 
 
8416 
class getReturnableOrdersForCustomer_result:
8417 
  """
8418 
  Attributes:
8419 
   - success
8420 
   - ex
8421 
  """
8422 
 
8423 
  thrift_spec = (
8424 
    (0, TType.LIST, 'success', (TType.I64,None), None, ), # 0
8425 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
8426 
  )
8427 
 
8428 
  def __init__(self, success=None, ex=None,):
8429 
    self.success = success
8430 
    self.ex = ex
8431 
 
8432 
  def read(self, iprot):
8433 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8434 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8435 
      return
8436 
    iprot.readStructBegin()
8437 
    while True:
8438 
      (fname, ftype, fid) = iprot.readFieldBegin()
8439 
      if ftype == TType.STOP:
8440 
        break
8441 
      if fid == 0:
8442 
        if ftype == TType.LIST:
8443 
          self.success = []
5031 varun.gupt 8444 
          (_etype129, _size126) = iprot.readListBegin()
8445 
          for _i130 in xrange(_size126):
8446 
            _elem131 = iprot.readI64();
8447 
            self.success.append(_elem131)
1382 varun.gupt 8448 
          iprot.readListEnd()
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
8466 
    oprot.writeStructBegin('getReturnableOrdersForCustomer_result')
3431 rajveer 8467 
    if self.success is not None:
1382 varun.gupt 8468 
      oprot.writeFieldBegin('success', TType.LIST, 0)
8469 
      oprot.writeListBegin(TType.I64, len(self.success))
5031 varun.gupt 8470 
      for iter132 in self.success:
8471 
        oprot.writeI64(iter132)
1382 varun.gupt 8472 
      oprot.writeListEnd()
8473 
      oprot.writeFieldEnd()
3431 rajveer 8474 
    if self.ex is not None:
1382 varun.gupt 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 
 
1382 varun.gupt 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 
 
8496 
class getCancellableOrdersForCustomer_args:
8497 
  """
8498 
  Attributes:
8499 
   - customer_id
8500 
   - limit
8501 
  """
8502 
 
8503 
  thrift_spec = (
8504 
    None, # 0
8505 
    (1, TType.I64, 'customer_id', None, None, ), # 1
8506 
    (2, TType.I64, 'limit', None, None, ), # 2
8507 
  )
8508 
 
8509 
  def __init__(self, customer_id=None, limit=None,):
8510 
    self.customer_id = customer_id
8511 
    self.limit = limit
8512 
 
8513 
  def read(self, iprot):
8514 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8515 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8516 
      return
8517 
    iprot.readStructBegin()
8518 
    while True:
8519 
      (fname, ftype, fid) = iprot.readFieldBegin()
8520 
      if ftype == TType.STOP:
8521 
        break
8522 
      if fid == 1:
8523 
        if ftype == TType.I64:
8524 
          self.customer_id = iprot.readI64();
8525 
        else:
8526 
          iprot.skip(ftype)
8527 
      elif fid == 2:
8528 
        if ftype == TType.I64:
8529 
          self.limit = iprot.readI64();
8530 
        else:
8531 
          iprot.skip(ftype)
8532 
      else:
8533 
        iprot.skip(ftype)
8534 
      iprot.readFieldEnd()
8535 
    iprot.readStructEnd()
8536 
 
8537 
  def write(self, oprot):
8538 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8539 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8540 
      return
8541 
    oprot.writeStructBegin('getCancellableOrdersForCustomer_args')
3431 rajveer 8542 
    if self.customer_id is not None:
1382 varun.gupt 8543 
      oprot.writeFieldBegin('customer_id', TType.I64, 1)
8544 
      oprot.writeI64(self.customer_id)
8545 
      oprot.writeFieldEnd()
3431 rajveer 8546 
    if self.limit is not None:
1382 varun.gupt 8547 
      oprot.writeFieldBegin('limit', TType.I64, 2)
8548 
      oprot.writeI64(self.limit)
8549 
      oprot.writeFieldEnd()
8550 
    oprot.writeFieldStop()
8551 
    oprot.writeStructEnd()
8552 
 
3431 rajveer 8553 
  def validate(self):
8554 
    return
8555 
 
8556 
 
1382 varun.gupt 8557 
  def __repr__(self):
8558 
    L = ['%s=%r' % (key, value)
8559 
      for key, value in self.__dict__.iteritems()]
8560 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8561 
 
8562 
  def __eq__(self, other):
8563 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8564 
 
8565 
  def __ne__(self, other):
8566 
    return not (self == other)
8567 
 
8568 
class getCancellableOrdersForCustomer_result:
8569 
  """
8570 
  Attributes:
8571 
   - success
8572 
   - ex
8573 
  """
8574 
 
8575 
  thrift_spec = (
8576 
    (0, TType.LIST, 'success', (TType.I64,None), None, ), # 0
8577 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
8578 
  )
8579 
 
8580 
  def __init__(self, success=None, ex=None,):
8581 
    self.success = success
8582 
    self.ex = ex
8583 
 
8584 
  def read(self, iprot):
8585 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8586 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8587 
      return
8588 
    iprot.readStructBegin()
8589 
    while True:
8590 
      (fname, ftype, fid) = iprot.readFieldBegin()
8591 
      if ftype == TType.STOP:
8592 
        break
8593 
      if fid == 0:
8594 
        if ftype == TType.LIST:
8595 
          self.success = []
5031 varun.gupt 8596 
          (_etype136, _size133) = iprot.readListBegin()
8597 
          for _i137 in xrange(_size133):
8598 
            _elem138 = iprot.readI64();
8599 
            self.success.append(_elem138)
1382 varun.gupt 8600 
          iprot.readListEnd()
8601 
        else:
8602 
          iprot.skip(ftype)
8603 
      elif fid == 1:
8604 
        if ftype == TType.STRUCT:
8605 
          self.ex = TransactionServiceException()
8606 
          self.ex.read(iprot)
8607 
        else:
8608 
          iprot.skip(ftype)
8609 
      else:
8610 
        iprot.skip(ftype)
8611 
      iprot.readFieldEnd()
8612 
    iprot.readStructEnd()
8613 
 
8614 
  def write(self, oprot):
8615 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8616 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8617 
      return
8618 
    oprot.writeStructBegin('getCancellableOrdersForCustomer_result')
3431 rajveer 8619 
    if self.success is not None:
1382 varun.gupt 8620 
      oprot.writeFieldBegin('success', TType.LIST, 0)
8621 
      oprot.writeListBegin(TType.I64, len(self.success))
5031 varun.gupt 8622 
      for iter139 in self.success:
8623 
        oprot.writeI64(iter139)
1382 varun.gupt 8624 
      oprot.writeListEnd()
8625 
      oprot.writeFieldEnd()
3431 rajveer 8626 
    if self.ex is not None:
1382 varun.gupt 8627 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
8628 
      self.ex.write(oprot)
8629 
      oprot.writeFieldEnd()
8630 
    oprot.writeFieldStop()
8631 
    oprot.writeStructEnd()
8632 
 
3431 rajveer 8633 
  def validate(self):
8634 
    return
8635 
 
8636 
 
1382 varun.gupt 8637 
  def __repr__(self):
8638 
    L = ['%s=%r' % (key, value)
8639 
      for key, value in self.__dict__.iteritems()]
8640 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8641 
 
8642 
  def __eq__(self, other):
8643 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8644 
 
8645 
  def __ne__(self, other):
8646 
    return not (self == other)
8647 
 
483 rajveer 8648 
class changeOrderStatus_args:
94 ashish 8649 
  """
8650 
  Attributes:
483 rajveer 8651 
   - orderId
8652 
   - status
8653 
   - description
94 ashish 8654 
  """
8655 
 
8656 
  thrift_spec = (
8657 
    None, # 0
483 rajveer 8658 
    (1, TType.I64, 'orderId', None, None, ), # 1
8659 
    (2, TType.I32, 'status', None, None, ), # 2
8660 
    (3, TType.STRING, 'description', None, None, ), # 3
94 ashish 8661 
  )
8662 
 
483 rajveer 8663 
  def __init__(self, orderId=None, status=None, description=None,):
8664 
    self.orderId = orderId
8665 
    self.status = status
8666 
    self.description = description
94 ashish 8667 
 
8668 
  def read(self, iprot):
8669 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8670 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8671 
      return
8672 
    iprot.readStructBegin()
8673 
    while True:
8674 
      (fname, ftype, fid) = iprot.readFieldBegin()
8675 
      if ftype == TType.STOP:
8676 
        break
8677 
      if fid == 1:
8678 
        if ftype == TType.I64:
483 rajveer 8679 
          self.orderId = iprot.readI64();
94 ashish 8680 
        else:
8681 
          iprot.skip(ftype)
8682 
      elif fid == 2:
483 rajveer 8683 
        if ftype == TType.I32:
8684 
          self.status = iprot.readI32();
94 ashish 8685 
        else:
8686 
          iprot.skip(ftype)
483 rajveer 8687 
      elif fid == 3:
8688 
        if ftype == TType.STRING:
8689 
          self.description = iprot.readString();
8690 
        else:
8691 
          iprot.skip(ftype)
94 ashish 8692 
      else:
8693 
        iprot.skip(ftype)
8694 
      iprot.readFieldEnd()
8695 
    iprot.readStructEnd()
8696 
 
8697 
  def write(self, oprot):
8698 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8699 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8700 
      return
483 rajveer 8701 
    oprot.writeStructBegin('changeOrderStatus_args')
3431 rajveer 8702 
    if self.orderId is not None:
483 rajveer 8703 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
8704 
      oprot.writeI64(self.orderId)
94 ashish 8705 
      oprot.writeFieldEnd()
3431 rajveer 8706 
    if self.status is not None:
483 rajveer 8707 
      oprot.writeFieldBegin('status', TType.I32, 2)
8708 
      oprot.writeI32(self.status)
94 ashish 8709 
      oprot.writeFieldEnd()
3431 rajveer 8710 
    if self.description is not None:
483 rajveer 8711 
      oprot.writeFieldBegin('description', TType.STRING, 3)
8712 
      oprot.writeString(self.description)
8713 
      oprot.writeFieldEnd()
94 ashish 8714 
    oprot.writeFieldStop()
8715 
    oprot.writeStructEnd()
8716 
 
3431 rajveer 8717 
  def validate(self):
8718 
    return
8719 
 
8720 
 
94 ashish 8721 
  def __repr__(self):
8722 
    L = ['%s=%r' % (key, value)
8723 
      for key, value in self.__dict__.iteritems()]
8724 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8725 
 
8726 
  def __eq__(self, other):
8727 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8728 
 
8729 
  def __ne__(self, other):
8730 
    return not (self == other)
8731 
 
483 rajveer 8732 
class changeOrderStatus_result:
94 ashish 8733 
  """
8734 
  Attributes:
8735 
   - success
8736 
   - ex
8737 
  """
8738 
 
8739 
  thrift_spec = (
8740 
    (0, TType.BOOL, 'success', None, None, ), # 0
8741 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
8742 
  )
8743 
 
8744 
  def __init__(self, success=None, ex=None,):
8745 
    self.success = success
8746 
    self.ex = ex
8747 
 
8748 
  def read(self, iprot):
8749 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8750 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8751 
      return
8752 
    iprot.readStructBegin()
8753 
    while True:
8754 
      (fname, ftype, fid) = iprot.readFieldBegin()
8755 
      if ftype == TType.STOP:
8756 
        break
8757 
      if fid == 0:
8758 
        if ftype == TType.BOOL:
8759 
          self.success = iprot.readBool();
8760 
        else:
8761 
          iprot.skip(ftype)
8762 
      elif fid == 1:
8763 
        if ftype == TType.STRUCT:
8764 
          self.ex = TransactionServiceException()
8765 
          self.ex.read(iprot)
8766 
        else:
8767 
          iprot.skip(ftype)
8768 
      else:
8769 
        iprot.skip(ftype)
8770 
      iprot.readFieldEnd()
8771 
    iprot.readStructEnd()
8772 
 
8773 
  def write(self, oprot):
8774 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8775 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8776 
      return
483 rajveer 8777 
    oprot.writeStructBegin('changeOrderStatus_result')
3431 rajveer 8778 
    if self.success is not None:
94 ashish 8779 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
8780 
      oprot.writeBool(self.success)
8781 
      oprot.writeFieldEnd()
3431 rajveer 8782 
    if self.ex is not None:
94 ashish 8783 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
8784 
      self.ex.write(oprot)
8785 
      oprot.writeFieldEnd()
8786 
    oprot.writeFieldStop()
8787 
    oprot.writeStructEnd()
8788 
 
3431 rajveer 8789 
  def validate(self):
8790 
    return
8791 
 
8792 
 
94 ashish 8793 
  def __repr__(self):
8794 
    L = ['%s=%r' % (key, value)
8795 
      for key, value in self.__dict__.iteritems()]
8796 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8797 
 
8798 
  def __eq__(self, other):
8799 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8800 
 
8801 
  def __ne__(self, other):
8802 
    return not (self == other)
8803 
 
3064 chandransh 8804 
class getOrdersForTransaction_args:
494 rajveer 8805 
  """
8806 
  Attributes:
3064 chandransh 8807 
   - transactionId
8808 
   - customerId
494 rajveer 8809 
  """
8810 
 
8811 
  thrift_spec = (
8812 
    None, # 0
3064 chandransh 8813 
    (1, TType.I64, 'transactionId', None, None, ), # 1
8814 
    (2, TType.I64, 'customerId', None, None, ), # 2
494 rajveer 8815 
  )
8816 
 
3064 chandransh 8817 
  def __init__(self, transactionId=None, customerId=None,):
8818 
    self.transactionId = transactionId
8819 
    self.customerId = customerId
494 rajveer 8820 
 
8821 
  def read(self, iprot):
8822 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8823 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8824 
      return
8825 
    iprot.readStructBegin()
8826 
    while True:
8827 
      (fname, ftype, fid) = iprot.readFieldBegin()
8828 
      if ftype == TType.STOP:
8829 
        break
8830 
      if fid == 1:
8831 
        if ftype == TType.I64:
3064 chandransh 8832 
          self.transactionId = iprot.readI64();
494 rajveer 8833 
        else:
8834 
          iprot.skip(ftype)
8835 
      elif fid == 2:
3064 chandransh 8836 
        if ftype == TType.I64:
8837 
          self.customerId = iprot.readI64();
494 rajveer 8838 
        else:
8839 
          iprot.skip(ftype)
8840 
      else:
8841 
        iprot.skip(ftype)
8842 
      iprot.readFieldEnd()
8843 
    iprot.readStructEnd()
8844 
 
8845 
  def write(self, oprot):
8846 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8847 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8848 
      return
3064 chandransh 8849 
    oprot.writeStructBegin('getOrdersForTransaction_args')
3431 rajveer 8850 
    if self.transactionId is not None:
3064 chandransh 8851 
      oprot.writeFieldBegin('transactionId', TType.I64, 1)
8852 
      oprot.writeI64(self.transactionId)
494 rajveer 8853 
      oprot.writeFieldEnd()
3431 rajveer 8854 
    if self.customerId is not None:
3064 chandransh 8855 
      oprot.writeFieldBegin('customerId', TType.I64, 2)
8856 
      oprot.writeI64(self.customerId)
494 rajveer 8857 
      oprot.writeFieldEnd()
8858 
    oprot.writeFieldStop()
8859 
    oprot.writeStructEnd()
8860 
 
3431 rajveer 8861 
  def validate(self):
8862 
    return
8863 
 
8864 
 
494 rajveer 8865 
  def __repr__(self):
8866 
    L = ['%s=%r' % (key, value)
8867 
      for key, value in self.__dict__.iteritems()]
8868 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8869 
 
8870 
  def __eq__(self, other):
8871 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8872 
 
8873 
  def __ne__(self, other):
8874 
    return not (self == other)
8875 
 
3064 chandransh 8876 
class getOrdersForTransaction_result:
494 rajveer 8877 
  """
8878 
  Attributes:
8879 
   - success
8880 
   - ex
8881 
  """
8882 
 
8883 
  thrift_spec = (
3064 chandransh 8884 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
494 rajveer 8885 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
8886 
  )
8887 
 
8888 
  def __init__(self, success=None, ex=None,):
8889 
    self.success = success
8890 
    self.ex = ex
8891 
 
8892 
  def read(self, iprot):
8893 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8894 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8895 
      return
8896 
    iprot.readStructBegin()
8897 
    while True:
8898 
      (fname, ftype, fid) = iprot.readFieldBegin()
8899 
      if ftype == TType.STOP:
8900 
        break
8901 
      if fid == 0:
3064 chandransh 8902 
        if ftype == TType.LIST:
8903 
          self.success = []
5031 varun.gupt 8904 
          (_etype143, _size140) = iprot.readListBegin()
8905 
          for _i144 in xrange(_size140):
8906 
            _elem145 = Order()
8907 
            _elem145.read(iprot)
8908 
            self.success.append(_elem145)
3064 chandransh 8909 
          iprot.readListEnd()
494 rajveer 8910 
        else:
8911 
          iprot.skip(ftype)
8912 
      elif fid == 1:
8913 
        if ftype == TType.STRUCT:
8914 
          self.ex = TransactionServiceException()
8915 
          self.ex.read(iprot)
8916 
        else:
8917 
          iprot.skip(ftype)
8918 
      else:
8919 
        iprot.skip(ftype)
8920 
      iprot.readFieldEnd()
8921 
    iprot.readStructEnd()
8922 
 
8923 
  def write(self, oprot):
8924 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8925 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8926 
      return
3064 chandransh 8927 
    oprot.writeStructBegin('getOrdersForTransaction_result')
3431 rajveer 8928 
    if self.success is not None:
3064 chandransh 8929 
      oprot.writeFieldBegin('success', TType.LIST, 0)
8930 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
5031 varun.gupt 8931 
      for iter146 in self.success:
8932 
        iter146.write(oprot)
3064 chandransh 8933 
      oprot.writeListEnd()
494 rajveer 8934 
      oprot.writeFieldEnd()
3431 rajveer 8935 
    if self.ex is not None:
494 rajveer 8936 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
8937 
      self.ex.write(oprot)
8938 
      oprot.writeFieldEnd()
8939 
    oprot.writeFieldStop()
8940 
    oprot.writeStructEnd()
8941 
 
3431 rajveer 8942 
  def validate(self):
8943 
    return
8944 
 
8945 
 
494 rajveer 8946 
  def __repr__(self):
8947 
    L = ['%s=%r' % (key, value)
8948 
      for key, value in self.__dict__.iteritems()]
8949 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8950 
 
8951 
  def __eq__(self, other):
8952 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8953 
 
8954 
  def __ne__(self, other):
8955 
    return not (self == other)
8956 
 
3064 chandransh 8957 
class getOrdersForCustomer_args:
1149 chandransh 8958 
  """
8959 
  Attributes:
3064 chandransh 8960 
   - customerId
8961 
   - from_date
8962 
   - to_date
8963 
   - statuses
1149 chandransh 8964 
  """
8965 
 
8966 
  thrift_spec = (
8967 
    None, # 0
3064 chandransh 8968 
    (1, TType.I64, 'customerId', None, None, ), # 1
8969 
    (2, TType.I64, 'from_date', None, None, ), # 2
8970 
    (3, TType.I64, 'to_date', None, None, ), # 3
8971 
    (4, TType.LIST, 'statuses', (TType.I32,None), None, ), # 4
1149 chandransh 8972 
  )
8973 
 
3064 chandransh 8974 
  def __init__(self, customerId=None, from_date=None, to_date=None, statuses=None,):
8975 
    self.customerId = customerId
8976 
    self.from_date = from_date
8977 
    self.to_date = to_date
8978 
    self.statuses = statuses
1149 chandransh 8979 
 
8980 
  def read(self, iprot):
8981 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8982 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8983 
      return
8984 
    iprot.readStructBegin()
8985 
    while True:
8986 
      (fname, ftype, fid) = iprot.readFieldBegin()
8987 
      if ftype == TType.STOP:
8988 
        break
8989 
      if fid == 1:
8990 
        if ftype == TType.I64:
3064 chandransh 8991 
          self.customerId = iprot.readI64();
1149 chandransh 8992 
        else:
8993 
          iprot.skip(ftype)
8994 
      elif fid == 2:
8995 
        if ftype == TType.I64:
3064 chandransh 8996 
          self.from_date = iprot.readI64();
1149 chandransh 8997 
        else:
8998 
          iprot.skip(ftype)
2783 chandransh 8999 
      elif fid == 3:
9000 
        if ftype == TType.I64:
3064 chandransh 9001 
          self.to_date = iprot.readI64();
2783 chandransh 9002 
        else:
9003 
          iprot.skip(ftype)
9004 
      elif fid == 4:
3064 chandransh 9005 
        if ftype == TType.LIST:
9006 
          self.statuses = []
5031 varun.gupt 9007 
          (_etype150, _size147) = iprot.readListBegin()
9008 
          for _i151 in xrange(_size147):
9009 
            _elem152 = iprot.readI32();
9010 
            self.statuses.append(_elem152)
3064 chandransh 9011 
          iprot.readListEnd()
2783 chandransh 9012 
        else:
9013 
          iprot.skip(ftype)
1149 chandransh 9014 
      else:
9015 
        iprot.skip(ftype)
9016 
      iprot.readFieldEnd()
9017 
    iprot.readStructEnd()
9018 
 
9019 
  def write(self, oprot):
9020 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9021 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9022 
      return
3064 chandransh 9023 
    oprot.writeStructBegin('getOrdersForCustomer_args')
3431 rajveer 9024 
    if self.customerId is not None:
3064 chandransh 9025 
      oprot.writeFieldBegin('customerId', TType.I64, 1)
9026 
      oprot.writeI64(self.customerId)
1149 chandransh 9027 
      oprot.writeFieldEnd()
3431 rajveer 9028 
    if self.from_date is not None:
3064 chandransh 9029 
      oprot.writeFieldBegin('from_date', TType.I64, 2)
9030 
      oprot.writeI64(self.from_date)
1149 chandransh 9031 
      oprot.writeFieldEnd()
3431 rajveer 9032 
    if self.to_date is not None:
3064 chandransh 9033 
      oprot.writeFieldBegin('to_date', TType.I64, 3)
9034 
      oprot.writeI64(self.to_date)
2783 chandransh 9035 
      oprot.writeFieldEnd()
3431 rajveer 9036 
    if self.statuses is not None:
3064 chandransh 9037 
      oprot.writeFieldBegin('statuses', TType.LIST, 4)
9038 
      oprot.writeListBegin(TType.I32, len(self.statuses))
5031 varun.gupt 9039 
      for iter153 in self.statuses:
9040 
        oprot.writeI32(iter153)
3064 chandransh 9041 
      oprot.writeListEnd()
2783 chandransh 9042 
      oprot.writeFieldEnd()
1149 chandransh 9043 
    oprot.writeFieldStop()
9044 
    oprot.writeStructEnd()
9045 
 
3431 rajveer 9046 
  def validate(self):
9047 
    return
9048 
 
9049 
 
1149 chandransh 9050 
  def __repr__(self):
9051 
    L = ['%s=%r' % (key, value)
9052 
      for key, value in self.__dict__.iteritems()]
9053 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9054 
 
9055 
  def __eq__(self, other):
9056 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9057 
 
9058 
  def __ne__(self, other):
9059 
    return not (self == other)
9060 
 
3064 chandransh 9061 
class getOrdersForCustomer_result:
1149 chandransh 9062 
  """
9063 
  Attributes:
9064 
   - success
9065 
   - ex
9066 
  """
9067 
 
9068 
  thrift_spec = (
3064 chandransh 9069 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
1149 chandransh 9070 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
9071 
  )
9072 
 
9073 
  def __init__(self, success=None, ex=None,):
9074 
    self.success = success
9075 
    self.ex = ex
9076 
 
9077 
  def read(self, iprot):
9078 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9079 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9080 
      return
9081 
    iprot.readStructBegin()
9082 
    while True:
9083 
      (fname, ftype, fid) = iprot.readFieldBegin()
9084 
      if ftype == TType.STOP:
9085 
        break
9086 
      if fid == 0:
3064 chandransh 9087 
        if ftype == TType.LIST:
9088 
          self.success = []
5031 varun.gupt 9089 
          (_etype157, _size154) = iprot.readListBegin()
9090 
          for _i158 in xrange(_size154):
9091 
            _elem159 = Order()
9092 
            _elem159.read(iprot)
9093 
            self.success.append(_elem159)
3064 chandransh 9094 
          iprot.readListEnd()
1149 chandransh 9095 
        else:
9096 
          iprot.skip(ftype)
9097 
      elif fid == 1:
9098 
        if ftype == TType.STRUCT:
9099 
          self.ex = TransactionServiceException()
9100 
          self.ex.read(iprot)
9101 
        else:
9102 
          iprot.skip(ftype)
9103 
      else:
9104 
        iprot.skip(ftype)
9105 
      iprot.readFieldEnd()
9106 
    iprot.readStructEnd()
9107 
 
9108 
  def write(self, oprot):
9109 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9110 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9111 
      return
3064 chandransh 9112 
    oprot.writeStructBegin('getOrdersForCustomer_result')
3431 rajveer 9113 
    if self.success is not None:
3064 chandransh 9114 
      oprot.writeFieldBegin('success', TType.LIST, 0)
9115 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
5031 varun.gupt 9116 
      for iter160 in self.success:
9117 
        iter160.write(oprot)
3064 chandransh 9118 
      oprot.writeListEnd()
1149 chandransh 9119 
      oprot.writeFieldEnd()
3431 rajveer 9120 
    if self.ex is not None:
1149 chandransh 9121 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
9122 
      self.ex.write(oprot)
9123 
      oprot.writeFieldEnd()
9124 
    oprot.writeFieldStop()
9125 
    oprot.writeStructEnd()
9126 
 
3431 rajveer 9127 
  def validate(self):
9128 
    return
9129 
 
9130 
 
1149 chandransh 9131 
  def __repr__(self):
9132 
    L = ['%s=%r' % (key, value)
9133 
      for key, value in self.__dict__.iteritems()]
9134 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9135 
 
9136 
  def __eq__(self, other):
9137 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9138 
 
9139 
  def __ne__(self, other):
9140 
    return not (self == other)
9141 
 
3064 chandransh 9142 
class createOrder_args:
921 rajveer 9143 
  """
9144 
  Attributes:
3064 chandransh 9145 
   - order
921 rajveer 9146 
  """
9147 
 
9148 
  thrift_spec = (
9149 
    None, # 0
3064 chandransh 9150 
    (1, TType.STRUCT, 'order', (Order, Order.thrift_spec), None, ), # 1
921 rajveer 9151 
  )
9152 
 
3064 chandransh 9153 
  def __init__(self, order=None,):
9154 
    self.order = order
921 rajveer 9155 
 
9156 
  def read(self, iprot):
9157 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9158 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9159 
      return
9160 
    iprot.readStructBegin()
9161 
    while True:
9162 
      (fname, ftype, fid) = iprot.readFieldBegin()
9163 
      if ftype == TType.STOP:
9164 
        break
9165 
      if fid == 1:
3064 chandransh 9166 
        if ftype == TType.STRUCT:
9167 
          self.order = Order()
9168 
          self.order.read(iprot)
921 rajveer 9169 
        else:
9170 
          iprot.skip(ftype)
9171 
      else:
9172 
        iprot.skip(ftype)
9173 
      iprot.readFieldEnd()
9174 
    iprot.readStructEnd()
9175 
 
9176 
  def write(self, oprot):
9177 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9178 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9179 
      return
3064 chandransh 9180 
    oprot.writeStructBegin('createOrder_args')
3431 rajveer 9181 
    if self.order is not None:
3064 chandransh 9182 
      oprot.writeFieldBegin('order', TType.STRUCT, 1)
9183 
      self.order.write(oprot)
921 rajveer 9184 
      oprot.writeFieldEnd()
9185 
    oprot.writeFieldStop()
9186 
    oprot.writeStructEnd()
9187 
 
3431 rajveer 9188 
  def validate(self):
9189 
    return
9190 
 
9191 
 
921 rajveer 9192 
  def __repr__(self):
9193 
    L = ['%s=%r' % (key, value)
9194 
      for key, value in self.__dict__.iteritems()]
9195 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9196 
 
9197 
  def __eq__(self, other):
9198 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9199 
 
9200 
  def __ne__(self, other):
9201 
    return not (self == other)
9202 
 
3064 chandransh 9203 
class createOrder_result:
921 rajveer 9204 
  """
9205 
  Attributes:
9206 
   - success
9207 
   - ex
9208 
  """
9209 
 
9210 
  thrift_spec = (
3064 chandransh 9211 
    (0, TType.I64, 'success', None, None, ), # 0
921 rajveer 9212 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
9213 
  )
9214 
 
9215 
  def __init__(self, success=None, ex=None,):
9216 
    self.success = success
9217 
    self.ex = ex
9218 
 
9219 
  def read(self, iprot):
9220 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9221 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9222 
      return
9223 
    iprot.readStructBegin()
9224 
    while True:
9225 
      (fname, ftype, fid) = iprot.readFieldBegin()
9226 
      if ftype == TType.STOP:
9227 
        break
9228 
      if fid == 0:
3064 chandransh 9229 
        if ftype == TType.I64:
9230 
          self.success = iprot.readI64();
921 rajveer 9231 
        else:
9232 
          iprot.skip(ftype)
9233 
      elif fid == 1:
9234 
        if ftype == TType.STRUCT:
9235 
          self.ex = TransactionServiceException()
9236 
          self.ex.read(iprot)
9237 
        else:
9238 
          iprot.skip(ftype)
9239 
      else:
9240 
        iprot.skip(ftype)
9241 
      iprot.readFieldEnd()
9242 
    iprot.readStructEnd()
9243 
 
9244 
  def write(self, oprot):
9245 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9246 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9247 
      return
3064 chandransh 9248 
    oprot.writeStructBegin('createOrder_result')
3431 rajveer 9249 
    if self.success is not None:
3064 chandransh 9250 
      oprot.writeFieldBegin('success', TType.I64, 0)
9251 
      oprot.writeI64(self.success)
921 rajveer 9252 
      oprot.writeFieldEnd()
3431 rajveer 9253 
    if self.ex is not None:
921 rajveer 9254 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
9255 
      self.ex.write(oprot)
9256 
      oprot.writeFieldEnd()
9257 
    oprot.writeFieldStop()
9258 
    oprot.writeStructEnd()
9259 
 
3431 rajveer 9260 
  def validate(self):
9261 
    return
9262 
 
9263 
 
921 rajveer 9264 
  def __repr__(self):
9265 
    L = ['%s=%r' % (key, value)
9266 
      for key, value in self.__dict__.iteritems()]
9267 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9268 
 
9269 
  def __eq__(self, other):
9270 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9271 
 
9272 
  def __ne__(self, other):
9273 
    return not (self == other)
9274 
 
3064 chandransh 9275 
class getOrder_args:
921 rajveer 9276 
  """
9277 
  Attributes:
3064 chandransh 9278 
   - id
921 rajveer 9279 
  """
9280 
 
9281 
  thrift_spec = (
9282 
    None, # 0
3064 chandransh 9283 
    (1, TType.I64, 'id', None, None, ), # 1
921 rajveer 9284 
  )
9285 
 
3064 chandransh 9286 
  def __init__(self, id=None,):
9287 
    self.id = id
921 rajveer 9288 
 
9289 
  def read(self, iprot):
9290 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9291 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9292 
      return
9293 
    iprot.readStructBegin()
9294 
    while True:
9295 
      (fname, ftype, fid) = iprot.readFieldBegin()
9296 
      if ftype == TType.STOP:
9297 
        break
9298 
      if fid == 1:
9299 
        if ftype == TType.I64:
3064 chandransh 9300 
          self.id = iprot.readI64();
921 rajveer 9301 
        else:
9302 
          iprot.skip(ftype)
9303 
      else:
9304 
        iprot.skip(ftype)
9305 
      iprot.readFieldEnd()
9306 
    iprot.readStructEnd()
9307 
 
9308 
  def write(self, oprot):
9309 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9310 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9311 
      return
3064 chandransh 9312 
    oprot.writeStructBegin('getOrder_args')
3431 rajveer 9313 
    if self.id is not None:
3064 chandransh 9314 
      oprot.writeFieldBegin('id', TType.I64, 1)
9315 
      oprot.writeI64(self.id)
921 rajveer 9316 
      oprot.writeFieldEnd()
9317 
    oprot.writeFieldStop()
9318 
    oprot.writeStructEnd()
9319 
 
3431 rajveer 9320 
  def validate(self):
9321 
    return
9322 
 
9323 
 
921 rajveer 9324 
  def __repr__(self):
9325 
    L = ['%s=%r' % (key, value)
9326 
      for key, value in self.__dict__.iteritems()]
9327 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9328 
 
9329 
  def __eq__(self, other):
9330 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9331 
 
9332 
  def __ne__(self, other):
9333 
    return not (self == other)
9334 
 
3064 chandransh 9335 
class getOrder_result:
921 rajveer 9336 
  """
9337 
  Attributes:
9338 
   - success
9339 
   - ex
9340 
  """
9341 
 
9342 
  thrift_spec = (
3064 chandransh 9343 
    (0, TType.STRUCT, 'success', (Order, Order.thrift_spec), None, ), # 0
921 rajveer 9344 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
9345 
  )
9346 
 
9347 
  def __init__(self, success=None, ex=None,):
9348 
    self.success = success
9349 
    self.ex = ex
9350 
 
9351 
  def read(self, iprot):
9352 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9353 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9354 
      return
9355 
    iprot.readStructBegin()
9356 
    while True:
9357 
      (fname, ftype, fid) = iprot.readFieldBegin()
9358 
      if ftype == TType.STOP:
9359 
        break
9360 
      if fid == 0:
3064 chandransh 9361 
        if ftype == TType.STRUCT:
9362 
          self.success = Order()
9363 
          self.success.read(iprot)
921 rajveer 9364 
        else:
9365 
          iprot.skip(ftype)
9366 
      elif fid == 1:
9367 
        if ftype == TType.STRUCT:
9368 
          self.ex = TransactionServiceException()
9369 
          self.ex.read(iprot)
9370 
        else:
9371 
          iprot.skip(ftype)
9372 
      else:
9373 
        iprot.skip(ftype)
9374 
      iprot.readFieldEnd()
9375 
    iprot.readStructEnd()
9376 
 
9377 
  def write(self, oprot):
9378 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9379 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9380 
      return
3064 chandransh 9381 
    oprot.writeStructBegin('getOrder_result')
3431 rajveer 9382 
    if self.success is not None:
3064 chandransh 9383 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
9384 
      self.success.write(oprot)
921 rajveer 9385 
      oprot.writeFieldEnd()
3431 rajveer 9386 
    if self.ex is not None:
921 rajveer 9387 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
9388 
      self.ex.write(oprot)
9389 
      oprot.writeFieldEnd()
9390 
    oprot.writeFieldStop()
9391 
    oprot.writeStructEnd()
9392 
 
3431 rajveer 9393 
  def validate(self):
9394 
    return
9395 
 
9396 
 
921 rajveer 9397 
  def __repr__(self):
9398 
    L = ['%s=%r' % (key, value)
9399 
      for key, value in self.__dict__.iteritems()]
9400 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9401 
 
9402 
  def __eq__(self, other):
9403 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9404 
 
9405 
  def __ne__(self, other):
9406 
    return not (self == other)
9407 
 
3064 chandransh 9408 
class getLineItemsForOrder_args:
94 ashish 9409 
  """
9410 
  Attributes:
3064 chandransh 9411 
   - orderId
94 ashish 9412 
  """
9413 
 
9414 
  thrift_spec = (
9415 
    None, # 0
3064 chandransh 9416 
    (1, TType.I64, 'orderId', None, None, ), # 1
94 ashish 9417 
  )
9418 
 
3064 chandransh 9419 
  def __init__(self, orderId=None,):
9420 
    self.orderId = orderId
94 ashish 9421 
 
9422 
  def read(self, iprot):
9423 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9424 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9425 
      return
9426 
    iprot.readStructBegin()
9427 
    while True:
9428 
      (fname, ftype, fid) = iprot.readFieldBegin()
9429 
      if ftype == TType.STOP:
9430 
        break
9431 
      if fid == 1:
9432 
        if ftype == TType.I64:
3064 chandransh 9433 
          self.orderId = iprot.readI64();
94 ashish 9434 
        else:
9435 
          iprot.skip(ftype)
9436 
      else:
9437 
        iprot.skip(ftype)
9438 
      iprot.readFieldEnd()
9439 
    iprot.readStructEnd()
9440 
 
9441 
  def write(self, oprot):
9442 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9443 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9444 
      return
3064 chandransh 9445 
    oprot.writeStructBegin('getLineItemsForOrder_args')
3431 rajveer 9446 
    if self.orderId is not None:
3064 chandransh 9447 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
9448 
      oprot.writeI64(self.orderId)
94 ashish 9449 
      oprot.writeFieldEnd()
9450 
    oprot.writeFieldStop()
9451 
    oprot.writeStructEnd()
9452 
 
3431 rajveer 9453 
  def validate(self):
9454 
    return
9455 
 
9456 
 
94 ashish 9457 
  def __repr__(self):
9458 
    L = ['%s=%r' % (key, value)
9459 
      for key, value in self.__dict__.iteritems()]
9460 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9461 
 
9462 
  def __eq__(self, other):
9463 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9464 
 
9465 
  def __ne__(self, other):
9466 
    return not (self == other)
9467 
 
3064 chandransh 9468 
class getLineItemsForOrder_result:
94 ashish 9469 
  """
9470 
  Attributes:
9471 
   - success
9472 
   - ex
9473 
  """
9474 
 
9475 
  thrift_spec = (
3064 chandransh 9476 
    (0, TType.LIST, 'success', (TType.STRUCT,(LineItem, LineItem.thrift_spec)), None, ), # 0
94 ashish 9477 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
9478 
  )
9479 
 
9480 
  def __init__(self, success=None, ex=None,):
9481 
    self.success = success
9482 
    self.ex = ex
9483 
 
9484 
  def read(self, iprot):
9485 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9486 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9487 
      return
9488 
    iprot.readStructBegin()
9489 
    while True:
9490 
      (fname, ftype, fid) = iprot.readFieldBegin()
9491 
      if ftype == TType.STOP:
9492 
        break
9493 
      if fid == 0:
483 rajveer 9494 
        if ftype == TType.LIST:
9495 
          self.success = []
5031 varun.gupt 9496 
          (_etype164, _size161) = iprot.readListBegin()
9497 
          for _i165 in xrange(_size161):
9498 
            _elem166 = LineItem()
9499 
            _elem166.read(iprot)
9500 
            self.success.append(_elem166)
483 rajveer 9501 
          iprot.readListEnd()
94 ashish 9502 
        else:
9503 
          iprot.skip(ftype)
9504 
      elif fid == 1:
9505 
        if ftype == TType.STRUCT:
9506 
          self.ex = TransactionServiceException()
9507 
          self.ex.read(iprot)
9508 
        else:
9509 
          iprot.skip(ftype)
9510 
      else:
9511 
        iprot.skip(ftype)
9512 
      iprot.readFieldEnd()
9513 
    iprot.readStructEnd()
9514 
 
9515 
  def write(self, oprot):
9516 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9517 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9518 
      return
3064 chandransh 9519 
    oprot.writeStructBegin('getLineItemsForOrder_result')
3431 rajveer 9520 
    if self.success is not None:
483 rajveer 9521 
      oprot.writeFieldBegin('success', TType.LIST, 0)
9522 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
5031 varun.gupt 9523 
      for iter167 in self.success:
9524 
        iter167.write(oprot)
483 rajveer 9525 
      oprot.writeListEnd()
94 ashish 9526 
      oprot.writeFieldEnd()
3431 rajveer 9527 
    if self.ex is not None:
94 ashish 9528 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
9529 
      self.ex.write(oprot)
9530 
      oprot.writeFieldEnd()
9531 
    oprot.writeFieldStop()
9532 
    oprot.writeStructEnd()
9533 
 
3431 rajveer 9534 
  def validate(self):
9535 
    return
9536 
 
9537 
 
94 ashish 9538 
  def __repr__(self):
9539 
    L = ['%s=%r' % (key, value)
9540 
      for key, value in self.__dict__.iteritems()]
9541 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9542 
 
9543 
  def __eq__(self, other):
9544 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9545 
 
9546 
  def __ne__(self, other):
9547 
    return not (self == other)
9548 
 
4999 phani.kuma 9549 
class getOrderList_args:
9550 
  """
9551 
  Attributes:
9552 
   - order_ids
9553 
  """
9554 
 
9555 
  thrift_spec = (
9556 
    None, # 0
9557 
    (1, TType.LIST, 'order_ids', (TType.I64,None), None, ), # 1
9558 
  )
9559 
 
9560 
  def __init__(self, order_ids=None,):
9561 
    self.order_ids = order_ids
9562 
 
9563 
  def read(self, iprot):
9564 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9565 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9566 
      return
9567 
    iprot.readStructBegin()
9568 
    while True:
9569 
      (fname, ftype, fid) = iprot.readFieldBegin()
9570 
      if ftype == TType.STOP:
9571 
        break
9572 
      if fid == 1:
9573 
        if ftype == TType.LIST:
9574 
          self.order_ids = []
5031 varun.gupt 9575 
          (_etype171, _size168) = iprot.readListBegin()
9576 
          for _i172 in xrange(_size168):
9577 
            _elem173 = iprot.readI64();
9578 
            self.order_ids.append(_elem173)
4999 phani.kuma 9579 
          iprot.readListEnd()
9580 
        else:
9581 
          iprot.skip(ftype)
9582 
      else:
9583 
        iprot.skip(ftype)
9584 
      iprot.readFieldEnd()
9585 
    iprot.readStructEnd()
9586 
 
9587 
  def write(self, oprot):
9588 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9589 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9590 
      return
9591 
    oprot.writeStructBegin('getOrderList_args')
9592 
    if self.order_ids is not None:
9593 
      oprot.writeFieldBegin('order_ids', TType.LIST, 1)
9594 
      oprot.writeListBegin(TType.I64, len(self.order_ids))
5031 varun.gupt 9595 
      for iter174 in self.order_ids:
9596 
        oprot.writeI64(iter174)
4999 phani.kuma 9597 
      oprot.writeListEnd()
9598 
      oprot.writeFieldEnd()
9599 
    oprot.writeFieldStop()
9600 
    oprot.writeStructEnd()
9601 
 
9602 
  def validate(self):
9603 
    return
9604 
 
9605 
 
9606 
  def __repr__(self):
9607 
    L = ['%s=%r' % (key, value)
9608 
      for key, value in self.__dict__.iteritems()]
9609 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9610 
 
9611 
  def __eq__(self, other):
9612 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9613 
 
9614 
  def __ne__(self, other):
9615 
    return not (self == other)
9616 
 
9617 
class getOrderList_result:
9618 
  """
9619 
  Attributes:
9620 
   - success
9621 
  """
9622 
 
9623 
  thrift_spec = (
9624 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
9625 
  )
9626 
 
9627 
  def __init__(self, success=None,):
9628 
    self.success = success
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 
      if fid == 0:
9640 
        if ftype == TType.LIST:
9641 
          self.success = []
5031 varun.gupt 9642 
          (_etype178, _size175) = iprot.readListBegin()
9643 
          for _i179 in xrange(_size175):
9644 
            _elem180 = Order()
9645 
            _elem180.read(iprot)
9646 
            self.success.append(_elem180)
4999 phani.kuma 9647 
          iprot.readListEnd()
9648 
        else:
9649 
          iprot.skip(ftype)
9650 
      else:
9651 
        iprot.skip(ftype)
9652 
      iprot.readFieldEnd()
9653 
    iprot.readStructEnd()
9654 
 
9655 
  def write(self, oprot):
9656 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9657 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9658 
      return
9659 
    oprot.writeStructBegin('getOrderList_result')
9660 
    if self.success is not None:
9661 
      oprot.writeFieldBegin('success', TType.LIST, 0)
9662 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
5031 varun.gupt 9663 
      for iter181 in self.success:
9664 
        iter181.write(oprot)
4999 phani.kuma 9665 
      oprot.writeListEnd()
9666 
      oprot.writeFieldEnd()
9667 
    oprot.writeFieldStop()
9668 
    oprot.writeStructEnd()
9669 
 
9670 
  def validate(self):
9671 
    return
9672 
 
9673 
 
9674 
  def __repr__(self):
9675 
    L = ['%s=%r' % (key, value)
9676 
      for key, value in self.__dict__.iteritems()]
9677 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9678 
 
9679 
  def __eq__(self, other):
9680 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9681 
 
9682 
  def __ne__(self, other):
9683 
    return not (self == other)
9684 
 
3064 chandransh 9685 
class getOrderForCustomer_args:
94 ashish 9686 
  """
9687 
  Attributes:
3064 chandransh 9688 
   - orderId
483 rajveer 9689 
   - customerId
94 ashish 9690 
  """
9691 
 
9692 
  thrift_spec = (
9693 
    None, # 0
3064 chandransh 9694 
    (1, TType.I64, 'orderId', None, None, ), # 1
9695 
    (2, TType.I64, 'customerId', None, None, ), # 2
94 ashish 9696 
  )
9697 
 
3064 chandransh 9698 
  def __init__(self, orderId=None, customerId=None,):
9699 
    self.orderId = orderId
483 rajveer 9700 
    self.customerId = customerId
94 ashish 9701 
 
9702 
  def read(self, iprot):
9703 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9704 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9705 
      return
9706 
    iprot.readStructBegin()
9707 
    while True:
9708 
      (fname, ftype, fid) = iprot.readFieldBegin()
9709 
      if ftype == TType.STOP:
9710 
        break
9711 
      if fid == 1:
9712 
        if ftype == TType.I64:
3064 chandransh 9713 
          self.orderId = iprot.readI64();
94 ashish 9714 
        else:
9715 
          iprot.skip(ftype)
9716 
      elif fid == 2:
9717 
        if ftype == TType.I64:
3064 chandransh 9718 
          self.customerId = iprot.readI64();
94 ashish 9719 
        else:
9720 
          iprot.skip(ftype)
9721 
      else:
9722 
        iprot.skip(ftype)
9723 
      iprot.readFieldEnd()
9724 
    iprot.readStructEnd()
9725 
 
9726 
  def write(self, oprot):
9727 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9728 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9729 
      return
3064 chandransh 9730 
    oprot.writeStructBegin('getOrderForCustomer_args')
3431 rajveer 9731 
    if self.orderId is not None:
3064 chandransh 9732 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
9733 
      oprot.writeI64(self.orderId)
9734 
      oprot.writeFieldEnd()
3431 rajveer 9735 
    if self.customerId is not None:
3064 chandransh 9736 
      oprot.writeFieldBegin('customerId', TType.I64, 2)
483 rajveer 9737 
      oprot.writeI64(self.customerId)
94 ashish 9738 
      oprot.writeFieldEnd()
9739 
    oprot.writeFieldStop()
9740 
    oprot.writeStructEnd()
9741 
 
3431 rajveer 9742 
  def validate(self):
9743 
    return
9744 
 
9745 
 
94 ashish 9746 
  def __repr__(self):
9747 
    L = ['%s=%r' % (key, value)
9748 
      for key, value in self.__dict__.iteritems()]
9749 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9750 
 
9751 
  def __eq__(self, other):
9752 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9753 
 
9754 
  def __ne__(self, other):
9755 
    return not (self == other)
9756 
 
3064 chandransh 9757 
class getOrderForCustomer_result:
94 ashish 9758 
  """
9759 
  Attributes:
9760 
   - success
9761 
   - ex
9762 
  """
9763 
 
9764 
  thrift_spec = (
3064 chandransh 9765 
    (0, TType.STRUCT, 'success', (Order, Order.thrift_spec), None, ), # 0
94 ashish 9766 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
9767 
  )
9768 
 
9769 
  def __init__(self, success=None, ex=None,):
9770 
    self.success = success
9771 
    self.ex = ex
9772 
 
9773 
  def read(self, iprot):
9774 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9775 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9776 
      return
9777 
    iprot.readStructBegin()
9778 
    while True:
9779 
      (fname, ftype, fid) = iprot.readFieldBegin()
9780 
      if ftype == TType.STOP:
9781 
        break
9782 
      if fid == 0:
3064 chandransh 9783 
        if ftype == TType.STRUCT:
9784 
          self.success = Order()
9785 
          self.success.read(iprot)
94 ashish 9786 
        else:
9787 
          iprot.skip(ftype)
9788 
      elif fid == 1:
9789 
        if ftype == TType.STRUCT:
9790 
          self.ex = TransactionServiceException()
9791 
          self.ex.read(iprot)
9792 
        else:
9793 
          iprot.skip(ftype)
9794 
      else:
9795 
        iprot.skip(ftype)
9796 
      iprot.readFieldEnd()
9797 
    iprot.readStructEnd()
9798 
 
9799 
  def write(self, oprot):
9800 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9801 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9802 
      return
3064 chandransh 9803 
    oprot.writeStructBegin('getOrderForCustomer_result')
3431 rajveer 9804 
    if self.success is not None:
3064 chandransh 9805 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
9806 
      self.success.write(oprot)
94 ashish 9807 
      oprot.writeFieldEnd()
3431 rajveer 9808 
    if self.ex is not None:
94 ashish 9809 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
9810 
      self.ex.write(oprot)
9811 
      oprot.writeFieldEnd()
9812 
    oprot.writeFieldStop()
9813 
    oprot.writeStructEnd()
9814 
 
3431 rajveer 9815 
  def validate(self):
9816 
    return
9817 
 
9818 
 
94 ashish 9819 
  def __repr__(self):
9820 
    L = ['%s=%r' % (key, value)
9821 
      for key, value in self.__dict__.iteritems()]
9822 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9823 
 
9824 
  def __eq__(self, other):
9825 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9826 
 
9827 
  def __ne__(self, other):
9828 
    return not (self == other)
9829 
 
3064 chandransh 9830 
class getAlerts_args:
94 ashish 9831 
  """
9832 
  Attributes:
4394 rajveer 9833 
   - type
4444 rajveer 9834 
   - warehouseId
4394 rajveer 9835 
   - status
9836 
   - timestamp
94 ashish 9837 
  """
9838 
 
9839 
  thrift_spec = (
9840 
    None, # 0
4394 rajveer 9841 
    (1, TType.I64, 'type', None, None, ), # 1
4444 rajveer 9842 
    (2, TType.I64, 'warehouseId', None, None, ), # 2
9843 
    (3, TType.I64, 'status', None, None, ), # 3
9844 
    (4, TType.I64, 'timestamp', None, None, ), # 4
94 ashish 9845 
  )
9846 
 
4444 rajveer 9847 
  def __init__(self, type=None, warehouseId=None, status=None, timestamp=None,):
4394 rajveer 9848 
    self.type = type
4444 rajveer 9849 
    self.warehouseId = warehouseId
4394 rajveer 9850 
    self.status = status
9851 
    self.timestamp = timestamp
94 ashish 9852 
 
9853 
  def read(self, iprot):
9854 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9855 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9856 
      return
9857 
    iprot.readStructBegin()
9858 
    while True:
9859 
      (fname, ftype, fid) = iprot.readFieldBegin()
9860 
      if ftype == TType.STOP:
9861 
        break
9862 
      if fid == 1:
3064 chandransh 9863 
        if ftype == TType.I64:
4394 rajveer 9864 
          self.type = iprot.readI64();
94 ashish 9865 
        else:
9866 
          iprot.skip(ftype)
3064 chandransh 9867 
      elif fid == 2:
4394 rajveer 9868 
        if ftype == TType.I64:
4444 rajveer 9869 
          self.warehouseId = iprot.readI64();
3064 chandransh 9870 
        else:
9871 
          iprot.skip(ftype)
4394 rajveer 9872 
      elif fid == 3:
9873 
        if ftype == TType.I64:
4444 rajveer 9874 
          self.status = iprot.readI64();
9875 
        else:
9876 
          iprot.skip(ftype)
9877 
      elif fid == 4:
9878 
        if ftype == TType.I64:
4394 rajveer 9879 
          self.timestamp = iprot.readI64();
9880 
        else:
9881 
          iprot.skip(ftype)
94 ashish 9882 
      else:
9883 
        iprot.skip(ftype)
9884 
      iprot.readFieldEnd()
9885 
    iprot.readStructEnd()
9886 
 
9887 
  def write(self, oprot):
9888 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9889 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9890 
      return
3064 chandransh 9891 
    oprot.writeStructBegin('getAlerts_args')
4394 rajveer 9892 
    if self.type is not None:
9893 
      oprot.writeFieldBegin('type', TType.I64, 1)
9894 
      oprot.writeI64(self.type)
94 ashish 9895 
      oprot.writeFieldEnd()
4444 rajveer 9896 
    if self.warehouseId is not None:
9897 
      oprot.writeFieldBegin('warehouseId', TType.I64, 2)
9898 
      oprot.writeI64(self.warehouseId)
9899 
      oprot.writeFieldEnd()
4394 rajveer 9900 
    if self.status is not None:
4444 rajveer 9901 
      oprot.writeFieldBegin('status', TType.I64, 3)
4394 rajveer 9902 
      oprot.writeI64(self.status)
3064 chandransh 9903 
      oprot.writeFieldEnd()
4394 rajveer 9904 
    if self.timestamp is not None:
4444 rajveer 9905 
      oprot.writeFieldBegin('timestamp', TType.I64, 4)
4394 rajveer 9906 
      oprot.writeI64(self.timestamp)
9907 
      oprot.writeFieldEnd()
94 ashish 9908 
    oprot.writeFieldStop()
9909 
    oprot.writeStructEnd()
9910 
 
3431 rajveer 9911 
  def validate(self):
9912 
    return
9913 
 
9914 
 
94 ashish 9915 
  def __repr__(self):
9916 
    L = ['%s=%r' % (key, value)
9917 
      for key, value in self.__dict__.iteritems()]
9918 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9919 
 
9920 
  def __eq__(self, other):
9921 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9922 
 
9923 
  def __ne__(self, other):
9924 
    return not (self == other)
9925 
 
3064 chandransh 9926 
class getAlerts_result:
94 ashish 9927 
  """
9928 
  Attributes:
9929 
   - success
9930 
  """
9931 
 
9932 
  thrift_spec = (
3064 chandransh 9933 
    (0, TType.LIST, 'success', (TType.STRUCT,(Alert, Alert.thrift_spec)), None, ), # 0
94 ashish 9934 
  )
9935 
 
3064 chandransh 9936 
  def __init__(self, success=None,):
94 ashish 9937 
    self.success = success
9938 
 
9939 
  def read(self, iprot):
9940 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9941 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9942 
      return
9943 
    iprot.readStructBegin()
9944 
    while True:
9945 
      (fname, ftype, fid) = iprot.readFieldBegin()
9946 
      if ftype == TType.STOP:
9947 
        break
9948 
      if fid == 0:
3064 chandransh 9949 
        if ftype == TType.LIST:
9950 
          self.success = []
5031 varun.gupt 9951 
          (_etype185, _size182) = iprot.readListBegin()
9952 
          for _i186 in xrange(_size182):
9953 
            _elem187 = Alert()
9954 
            _elem187.read(iprot)
9955 
            self.success.append(_elem187)
3064 chandransh 9956 
          iprot.readListEnd()
94 ashish 9957 
        else:
9958 
          iprot.skip(ftype)
9959 
      else:
9960 
        iprot.skip(ftype)
9961 
      iprot.readFieldEnd()
9962 
    iprot.readStructEnd()
9963 
 
9964 
  def write(self, oprot):
9965 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9966 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9967 
      return
3064 chandransh 9968 
    oprot.writeStructBegin('getAlerts_result')
3431 rajveer 9969 
    if self.success is not None:
3064 chandransh 9970 
      oprot.writeFieldBegin('success', TType.LIST, 0)
9971 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
5031 varun.gupt 9972 
      for iter188 in self.success:
9973 
        iter188.write(oprot)
3064 chandransh 9974 
      oprot.writeListEnd()
94 ashish 9975 
      oprot.writeFieldEnd()
9976 
    oprot.writeFieldStop()
9977 
    oprot.writeStructEnd()
9978 
 
3431 rajveer 9979 
  def validate(self):
9980 
    return
9981 
 
9982 
 
94 ashish 9983 
  def __repr__(self):
9984 
    L = ['%s=%r' % (key, value)
9985 
      for key, value in self.__dict__.iteritems()]
9986 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9987 
 
9988 
  def __eq__(self, other):
9989 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9990 
 
9991 
  def __ne__(self, other):
9992 
    return not (self == other)
9993 
 
4394 rajveer 9994 
class addAlert_args:
94 ashish 9995 
  """
9996 
  Attributes:
3064 chandransh 9997 
   - type
4444 rajveer 9998 
   - warehouseId
4394 rajveer 9999 
   - description
94 ashish 10000 
  """
10001 
 
10002 
  thrift_spec = (
10003 
    None, # 0
4394 rajveer 10004 
    (1, TType.I64, 'type', None, None, ), # 1
4444 rajveer 10005 
    (2, TType.I64, 'warehouseId', None, None, ), # 2
10006 
    (3, TType.STRING, 'description', None, None, ), # 3
94 ashish 10007 
  )
10008 
 
4444 rajveer 10009 
  def __init__(self, type=None, warehouseId=None, description=None,):
3064 chandransh 10010 
    self.type = type
4444 rajveer 10011 
    self.warehouseId = warehouseId
4394 rajveer 10012 
    self.description = description
94 ashish 10013 
 
10014 
  def read(self, iprot):
10015 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10016 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10017 
      return
10018 
    iprot.readStructBegin()
10019 
    while True:
10020 
      (fname, ftype, fid) = iprot.readFieldBegin()
10021 
      if ftype == TType.STOP:
10022 
        break
10023 
      if fid == 1:
10024 
        if ftype == TType.I64:
4394 rajveer 10025 
          self.type = iprot.readI64();
94 ashish 10026 
        else:
10027 
          iprot.skip(ftype)
3064 chandransh 10028 
      elif fid == 2:
4444 rajveer 10029 
        if ftype == TType.I64:
10030 
          self.warehouseId = iprot.readI64();
10031 
        else:
10032 
          iprot.skip(ftype)
10033 
      elif fid == 3:
3064 chandransh 10034 
        if ftype == TType.STRING:
4394 rajveer 10035 
          self.description = iprot.readString();
3064 chandransh 10036 
        else:
10037 
          iprot.skip(ftype)
94 ashish 10038 
      else:
10039 
        iprot.skip(ftype)
10040 
      iprot.readFieldEnd()
10041 
    iprot.readStructEnd()
10042 
 
10043 
  def write(self, oprot):
10044 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10045 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10046 
      return
4394 rajveer 10047 
    oprot.writeStructBegin('addAlert_args')
3431 rajveer 10048 
    if self.type is not None:
4394 rajveer 10049 
      oprot.writeFieldBegin('type', TType.I64, 1)
3064 chandransh 10050 
      oprot.writeI64(self.type)
10051 
      oprot.writeFieldEnd()
4444 rajveer 10052 
    if self.warehouseId is not None:
10053 
      oprot.writeFieldBegin('warehouseId', TType.I64, 2)
10054 
      oprot.writeI64(self.warehouseId)
10055 
      oprot.writeFieldEnd()
4394 rajveer 10056 
    if self.description is not None:
4444 rajveer 10057 
      oprot.writeFieldBegin('description', TType.STRING, 3)
4394 rajveer 10058 
      oprot.writeString(self.description)
3064 chandransh 10059 
      oprot.writeFieldEnd()
94 ashish 10060 
    oprot.writeFieldStop()
10061 
    oprot.writeStructEnd()
10062 
 
3431 rajveer 10063 
  def validate(self):
10064 
    return
10065 
 
10066 
 
94 ashish 10067 
  def __repr__(self):
10068 
    L = ['%s=%r' % (key, value)
10069 
      for key, value in self.__dict__.iteritems()]
10070 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10071 
 
10072 
  def __eq__(self, other):
10073 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10074 
 
10075 
  def __ne__(self, other):
10076 
    return not (self == other)
10077 
 
4394 rajveer 10078 
class addAlert_result:
3064 chandransh 10079 
 
10080 
  thrift_spec = (
10081 
  )
10082 
 
10083 
  def read(self, iprot):
10084 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10085 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10086 
      return
10087 
    iprot.readStructBegin()
10088 
    while True:
10089 
      (fname, ftype, fid) = iprot.readFieldBegin()
10090 
      if ftype == TType.STOP:
10091 
        break
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
4394 rajveer 10101 
    oprot.writeStructBegin('addAlert_result')
3064 chandransh 10102 
    oprot.writeFieldStop()
10103 
    oprot.writeStructEnd()
10104 
 
3431 rajveer 10105 
  def validate(self):
10106 
    return
10107 
 
10108 
 
3064 chandransh 10109 
  def __repr__(self):
10110 
    L = ['%s=%r' % (key, value)
10111 
      for key, value in self.__dict__.iteritems()]
10112 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10113 
 
10114 
  def __eq__(self, other):
10115 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10116 
 
10117 
  def __ne__(self, other):
10118 
    return not (self == other)
10119 
 
4444 rajveer 10120 
class markAlertsAsSeen_args:
10121 
  """
10122 
  Attributes:
10123 
   - warehouseId
10124 
  """
10125 
 
10126 
  thrift_spec = (
10127 
    None, # 0
10128 
    (1, TType.I64, 'warehouseId', None, None, ), # 1
10129 
  )
10130 
 
10131 
  def __init__(self, warehouseId=None,):
10132 
    self.warehouseId = warehouseId
10133 
 
10134 
  def read(self, iprot):
10135 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10136 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10137 
      return
10138 
    iprot.readStructBegin()
10139 
    while True:
10140 
      (fname, ftype, fid) = iprot.readFieldBegin()
10141 
      if ftype == TType.STOP:
10142 
        break
10143 
      if fid == 1:
10144 
        if ftype == TType.I64:
10145 
          self.warehouseId = iprot.readI64();
10146 
        else:
10147 
          iprot.skip(ftype)
10148 
      else:
10149 
        iprot.skip(ftype)
10150 
      iprot.readFieldEnd()
10151 
    iprot.readStructEnd()
10152 
 
10153 
  def write(self, oprot):
10154 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10155 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10156 
      return
10157 
    oprot.writeStructBegin('markAlertsAsSeen_args')
10158 
    if self.warehouseId is not None:
10159 
      oprot.writeFieldBegin('warehouseId', TType.I64, 1)
10160 
      oprot.writeI64(self.warehouseId)
10161 
      oprot.writeFieldEnd()
10162 
    oprot.writeFieldStop()
10163 
    oprot.writeStructEnd()
10164 
 
10165 
  def validate(self):
10166 
    return
10167 
 
10168 
 
10169 
  def __repr__(self):
10170 
    L = ['%s=%r' % (key, value)
10171 
      for key, value in self.__dict__.iteritems()]
10172 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10173 
 
10174 
  def __eq__(self, other):
10175 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10176 
 
10177 
  def __ne__(self, other):
10178 
    return not (self == other)
10179 
 
10180 
class markAlertsAsSeen_result:
10181 
 
10182 
  thrift_spec = (
10183 
  )
10184 
 
10185 
  def read(self, iprot):
10186 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10187 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10188 
      return
10189 
    iprot.readStructBegin()
10190 
    while True:
10191 
      (fname, ftype, fid) = iprot.readFieldBegin()
10192 
      if ftype == TType.STOP:
10193 
        break
10194 
      else:
10195 
        iprot.skip(ftype)
10196 
      iprot.readFieldEnd()
10197 
    iprot.readStructEnd()
10198 
 
10199 
  def write(self, oprot):
10200 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10201 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10202 
      return
10203 
    oprot.writeStructBegin('markAlertsAsSeen_result')
10204 
    oprot.writeFieldStop()
10205 
    oprot.writeStructEnd()
10206 
 
10207 
  def validate(self):
10208 
    return
10209 
 
10210 
 
10211 
  def __repr__(self):
10212 
    L = ['%s=%r' % (key, value)
10213 
      for key, value in self.__dict__.iteritems()]
10214 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10215 
 
10216 
  def __eq__(self, other):
10217 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10218 
 
10219 
  def __ne__(self, other):
10220 
    return not (self == other)
10221 
 
3064 chandransh 10222 
class getValidOrderCount_args:
10223 
 
10224 
  thrift_spec = (
10225 
  )
10226 
 
10227 
  def read(self, iprot):
10228 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10229 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10230 
      return
10231 
    iprot.readStructBegin()
10232 
    while True:
10233 
      (fname, ftype, fid) = iprot.readFieldBegin()
10234 
      if ftype == TType.STOP:
10235 
        break
10236 
      else:
10237 
        iprot.skip(ftype)
10238 
      iprot.readFieldEnd()
10239 
    iprot.readStructEnd()
10240 
 
10241 
  def write(self, oprot):
10242 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10243 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10244 
      return
10245 
    oprot.writeStructBegin('getValidOrderCount_args')
10246 
    oprot.writeFieldStop()
10247 
    oprot.writeStructEnd()
10248 
 
3431 rajveer 10249 
  def validate(self):
10250 
    return
10251 
 
10252 
 
3064 chandransh 10253 
  def __repr__(self):
10254 
    L = ['%s=%r' % (key, value)
10255 
      for key, value in self.__dict__.iteritems()]
10256 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10257 
 
10258 
  def __eq__(self, other):
10259 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10260 
 
10261 
  def __ne__(self, other):
10262 
    return not (self == other)
10263 
 
10264 
class getValidOrderCount_result:
94 ashish 10265 
  """
10266 
  Attributes:
10267 
   - success
10268 
  """
10269 
 
10270 
  thrift_spec = (
3064 chandransh 10271 
    (0, TType.I64, 'success', None, None, ), # 0
94 ashish 10272 
  )
10273 
 
3064 chandransh 10274 
  def __init__(self, success=None,):
94 ashish 10275 
    self.success = success
10276 
 
10277 
  def read(self, iprot):
10278 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10279 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10280 
      return
10281 
    iprot.readStructBegin()
10282 
    while True:
10283 
      (fname, ftype, fid) = iprot.readFieldBegin()
10284 
      if ftype == TType.STOP:
10285 
        break
10286 
      if fid == 0:
3064 chandransh 10287 
        if ftype == TType.I64:
10288 
          self.success = iprot.readI64();
94 ashish 10289 
        else:
10290 
          iprot.skip(ftype)
10291 
      else:
10292 
        iprot.skip(ftype)
10293 
      iprot.readFieldEnd()
10294 
    iprot.readStructEnd()
10295 
 
10296 
  def write(self, oprot):
10297 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10298 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10299 
      return
3064 chandransh 10300 
    oprot.writeStructBegin('getValidOrderCount_result')
3431 rajveer 10301 
    if self.success is not None:
3064 chandransh 10302 
      oprot.writeFieldBegin('success', TType.I64, 0)
10303 
      oprot.writeI64(self.success)
94 ashish 10304 
      oprot.writeFieldEnd()
10305 
    oprot.writeFieldStop()
10306 
    oprot.writeStructEnd()
10307 
 
3431 rajveer 10308 
  def validate(self):
10309 
    return
10310 
 
10311 
 
94 ashish 10312 
  def __repr__(self):
10313 
    L = ['%s=%r' % (key, value)
10314 
      for key, value in self.__dict__.iteritems()]
10315 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10316 
 
10317 
  def __eq__(self, other):
10318 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10319 
 
10320 
  def __ne__(self, other):
10321 
    return not (self == other)
10322 
 
3064 chandransh 10323 
class getNoOfCustomersWithSuccessfulTransaction_args:
10324 
 
10325 
  thrift_spec = (
10326 
  )
10327 
 
10328 
  def read(self, iprot):
10329 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10330 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10331 
      return
10332 
    iprot.readStructBegin()
10333 
    while True:
10334 
      (fname, ftype, fid) = iprot.readFieldBegin()
10335 
      if ftype == TType.STOP:
10336 
        break
10337 
      else:
10338 
        iprot.skip(ftype)
10339 
      iprot.readFieldEnd()
10340 
    iprot.readStructEnd()
10341 
 
10342 
  def write(self, oprot):
10343 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10344 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10345 
      return
10346 
    oprot.writeStructBegin('getNoOfCustomersWithSuccessfulTransaction_args')
10347 
    oprot.writeFieldStop()
10348 
    oprot.writeStructEnd()
10349 
 
3431 rajveer 10350 
  def validate(self):
10351 
    return
10352 
 
10353 
 
3064 chandransh 10354 
  def __repr__(self):
10355 
    L = ['%s=%r' % (key, value)
10356 
      for key, value in self.__dict__.iteritems()]
10357 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10358 
 
10359 
  def __eq__(self, other):
10360 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10361 
 
10362 
  def __ne__(self, other):
10363 
    return not (self == other)
10364 
 
10365 
class getNoOfCustomersWithSuccessfulTransaction_result:
94 ashish 10366 
  """
10367 
  Attributes:
3064 chandransh 10368 
   - success
94 ashish 10369 
  """
10370 
 
10371 
  thrift_spec = (
3064 chandransh 10372 
    (0, TType.I64, 'success', None, None, ), # 0
94 ashish 10373 
  )
10374 
 
3064 chandransh 10375 
  def __init__(self, success=None,):
10376 
    self.success = success
94 ashish 10377 
 
10378 
  def read(self, iprot):
10379 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10380 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10381 
      return
10382 
    iprot.readStructBegin()
10383 
    while True:
10384 
      (fname, ftype, fid) = iprot.readFieldBegin()
10385 
      if ftype == TType.STOP:
10386 
        break
3064 chandransh 10387 
      if fid == 0:
94 ashish 10388 
        if ftype == TType.I64:
3064 chandransh 10389 
          self.success = iprot.readI64();
94 ashish 10390 
        else:
10391 
          iprot.skip(ftype)
10392 
      else:
10393 
        iprot.skip(ftype)
10394 
      iprot.readFieldEnd()
10395 
    iprot.readStructEnd()
10396 
 
10397 
  def write(self, oprot):
10398 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10399 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10400 
      return
3064 chandransh 10401 
    oprot.writeStructBegin('getNoOfCustomersWithSuccessfulTransaction_result')
3431 rajveer 10402 
    if self.success is not None:
3064 chandransh 10403 
      oprot.writeFieldBegin('success', TType.I64, 0)
10404 
      oprot.writeI64(self.success)
94 ashish 10405 
      oprot.writeFieldEnd()
10406 
    oprot.writeFieldStop()
10407 
    oprot.writeStructEnd()
10408 
 
3431 rajveer 10409 
  def validate(self):
10410 
    return
10411 
 
10412 
 
94 ashish 10413 
  def __repr__(self):
10414 
    L = ['%s=%r' % (key, value)
10415 
      for key, value in self.__dict__.iteritems()]
10416 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10417 
 
10418 
  def __eq__(self, other):
10419 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10420 
 
10421 
  def __ne__(self, other):
10422 
    return not (self == other)
10423 
 
3064 chandransh 10424 
class getValidOrdersAmountRange_args:
10425 
 
10426 
  thrift_spec = (
10427 
  )
10428 
 
10429 
  def read(self, iprot):
10430 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10431 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10432 
      return
10433 
    iprot.readStructBegin()
10434 
    while True:
10435 
      (fname, ftype, fid) = iprot.readFieldBegin()
10436 
      if ftype == TType.STOP:
10437 
        break
10438 
      else:
10439 
        iprot.skip(ftype)
10440 
      iprot.readFieldEnd()
10441 
    iprot.readStructEnd()
10442 
 
10443 
  def write(self, oprot):
10444 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10445 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10446 
      return
10447 
    oprot.writeStructBegin('getValidOrdersAmountRange_args')
10448 
    oprot.writeFieldStop()
10449 
    oprot.writeStructEnd()
10450 
 
3431 rajveer 10451 
  def validate(self):
10452 
    return
10453 
 
10454 
 
3064 chandransh 10455 
  def __repr__(self):
10456 
    L = ['%s=%r' % (key, value)
10457 
      for key, value in self.__dict__.iteritems()]
10458 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10459 
 
10460 
  def __eq__(self, other):
10461 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10462 
 
10463 
  def __ne__(self, other):
10464 
    return not (self == other)
10465 
 
10466 
class getValidOrdersAmountRange_result:
94 ashish 10467 
  """
10468 
  Attributes:
10469 
   - success
10470 
  """
10471 
 
10472 
  thrift_spec = (
3064 chandransh 10473 
    (0, TType.LIST, 'success', (TType.DOUBLE,None), None, ), # 0
94 ashish 10474 
  )
10475 
 
3064 chandransh 10476 
  def __init__(self, success=None,):
94 ashish 10477 
    self.success = success
10478 
 
10479 
  def read(self, iprot):
10480 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10481 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10482 
      return
10483 
    iprot.readStructBegin()
10484 
    while True:
10485 
      (fname, ftype, fid) = iprot.readFieldBegin()
10486 
      if ftype == TType.STOP:
10487 
        break
10488 
      if fid == 0:
483 rajveer 10489 
        if ftype == TType.LIST:
10490 
          self.success = []
5031 varun.gupt 10491 
          (_etype192, _size189) = iprot.readListBegin()
10492 
          for _i193 in xrange(_size189):
10493 
            _elem194 = iprot.readDouble();
10494 
            self.success.append(_elem194)
483 rajveer 10495 
          iprot.readListEnd()
94 ashish 10496 
        else:
10497 
          iprot.skip(ftype)
10498 
      else:
10499 
        iprot.skip(ftype)
10500 
      iprot.readFieldEnd()
10501 
    iprot.readStructEnd()
10502 
 
10503 
  def write(self, oprot):
10504 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10505 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10506 
      return
3064 chandransh 10507 
    oprot.writeStructBegin('getValidOrdersAmountRange_result')
3431 rajveer 10508 
    if self.success is not None:
483 rajveer 10509 
      oprot.writeFieldBegin('success', TType.LIST, 0)
3064 chandransh 10510 
      oprot.writeListBegin(TType.DOUBLE, len(self.success))
5031 varun.gupt 10511 
      for iter195 in self.success:
10512 
        oprot.writeDouble(iter195)
483 rajveer 10513 
      oprot.writeListEnd()
94 ashish 10514 
      oprot.writeFieldEnd()
10515 
    oprot.writeFieldStop()
10516 
    oprot.writeStructEnd()
10517 
 
3431 rajveer 10518 
  def validate(self):
10519 
    return
10520 
 
10521 
 
94 ashish 10522 
  def __repr__(self):
10523 
    L = ['%s=%r' % (key, value)
10524 
      for key, value in self.__dict__.iteritems()]
10525 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10526 
 
10527 
  def __eq__(self, other):
10528 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10529 
 
10530 
  def __ne__(self, other):
10531 
    return not (self == other)
10532 
 
3064 chandransh 10533 
class getValidOrders_args:
1528 ankur.sing 10534 
  """
10535 
  Attributes:
3064 chandransh 10536 
   - limit
1528 ankur.sing 10537 
  """
10538 
 
10539 
  thrift_spec = (
10540 
    None, # 0
3064 chandransh 10541 
    (1, TType.I64, 'limit', None, None, ), # 1
1528 ankur.sing 10542 
  )
10543 
 
3064 chandransh 10544 
  def __init__(self, limit=None,):
10545 
    self.limit = limit
1528 ankur.sing 10546 
 
10547 
  def read(self, iprot):
10548 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10549 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10550 
      return
10551 
    iprot.readStructBegin()
10552 
    while True:
10553 
      (fname, ftype, fid) = iprot.readFieldBegin()
10554 
      if ftype == TType.STOP:
10555 
        break
10556 
      if fid == 1:
10557 
        if ftype == TType.I64:
3064 chandransh 10558 
          self.limit = iprot.readI64();
1528 ankur.sing 10559 
        else:
10560 
          iprot.skip(ftype)
10561 
      else:
10562 
        iprot.skip(ftype)
10563 
      iprot.readFieldEnd()
10564 
    iprot.readStructEnd()
10565 
 
10566 
  def write(self, oprot):
10567 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10568 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10569 
      return
3064 chandransh 10570 
    oprot.writeStructBegin('getValidOrders_args')
3431 rajveer 10571 
    if self.limit is not None:
3064 chandransh 10572 
      oprot.writeFieldBegin('limit', TType.I64, 1)
10573 
      oprot.writeI64(self.limit)
1528 ankur.sing 10574 
      oprot.writeFieldEnd()
10575 
    oprot.writeFieldStop()
10576 
    oprot.writeStructEnd()
10577 
 
3431 rajveer 10578 
  def validate(self):
10579 
    return
10580 
 
10581 
 
1528 ankur.sing 10582 
  def __repr__(self):
10583 
    L = ['%s=%r' % (key, value)
10584 
      for key, value in self.__dict__.iteritems()]
10585 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10586 
 
10587 
  def __eq__(self, other):
10588 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10589 
 
10590 
  def __ne__(self, other):
10591 
    return not (self == other)
10592 
 
3064 chandransh 10593 
class getValidOrders_result:
1528 ankur.sing 10594 
  """
10595 
  Attributes:
10596 
   - success
10597 
  """
10598 
 
10599 
  thrift_spec = (
3064 chandransh 10600 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
1528 ankur.sing 10601 
  )
10602 
 
3064 chandransh 10603 
  def __init__(self, success=None,):
1528 ankur.sing 10604 
    self.success = success
10605 
 
10606 
  def read(self, iprot):
10607 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10608 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10609 
      return
10610 
    iprot.readStructBegin()
10611 
    while True:
10612 
      (fname, ftype, fid) = iprot.readFieldBegin()
10613 
      if ftype == TType.STOP:
10614 
        break
10615 
      if fid == 0:
3064 chandransh 10616 
        if ftype == TType.LIST:
10617 
          self.success = []
5031 varun.gupt 10618 
          (_etype199, _size196) = iprot.readListBegin()
10619 
          for _i200 in xrange(_size196):
10620 
            _elem201 = Order()
10621 
            _elem201.read(iprot)
10622 
            self.success.append(_elem201)
3064 chandransh 10623 
          iprot.readListEnd()
1528 ankur.sing 10624 
        else:
10625 
          iprot.skip(ftype)
10626 
      else:
10627 
        iprot.skip(ftype)
10628 
      iprot.readFieldEnd()
10629 
    iprot.readStructEnd()
10630 
 
10631 
  def write(self, oprot):
10632 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10633 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10634 
      return
3064 chandransh 10635 
    oprot.writeStructBegin('getValidOrders_result')
3431 rajveer 10636 
    if self.success is not None:
3064 chandransh 10637 
      oprot.writeFieldBegin('success', TType.LIST, 0)
10638 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
5031 varun.gupt 10639 
      for iter202 in self.success:
10640 
        iter202.write(oprot)
3064 chandransh 10641 
      oprot.writeListEnd()
1528 ankur.sing 10642 
      oprot.writeFieldEnd()
10643 
    oprot.writeFieldStop()
10644 
    oprot.writeStructEnd()
10645 
 
3431 rajveer 10646 
  def validate(self):
10647 
    return
10648 
 
10649 
 
1528 ankur.sing 10650 
  def __repr__(self):
10651 
    L = ['%s=%r' % (key, value)
10652 
      for key, value in self.__dict__.iteritems()]
10653 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10654 
 
10655 
  def __eq__(self, other):
10656 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10657 
 
10658 
  def __ne__(self, other):
10659 
    return not (self == other)
10660 
 
1220 chandransh 10661 
class batchOrders_args:
10662 
  """
10663 
  Attributes:
10664 
   - warehouseId
10665 
  """
10666 
 
10667 
  thrift_spec = (
10668 
    None, # 0
10669 
    (1, TType.I64, 'warehouseId', None, None, ), # 1
10670 
  )
10671 
 
10672 
  def __init__(self, warehouseId=None,):
10673 
    self.warehouseId = warehouseId
10674 
 
10675 
  def read(self, iprot):
10676 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10677 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10678 
      return
10679 
    iprot.readStructBegin()
10680 
    while True:
10681 
      (fname, ftype, fid) = iprot.readFieldBegin()
10682 
      if ftype == TType.STOP:
10683 
        break
10684 
      if fid == 1:
10685 
        if ftype == TType.I64:
10686 
          self.warehouseId = iprot.readI64();
10687 
        else:
10688 
          iprot.skip(ftype)
10689 
      else:
10690 
        iprot.skip(ftype)
10691 
      iprot.readFieldEnd()
10692 
    iprot.readStructEnd()
10693 
 
10694 
  def write(self, oprot):
10695 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10696 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10697 
      return
10698 
    oprot.writeStructBegin('batchOrders_args')
3431 rajveer 10699 
    if self.warehouseId is not None:
1220 chandransh 10700 
      oprot.writeFieldBegin('warehouseId', TType.I64, 1)
10701 
      oprot.writeI64(self.warehouseId)
10702 
      oprot.writeFieldEnd()
10703 
    oprot.writeFieldStop()
10704 
    oprot.writeStructEnd()
10705 
 
3431 rajveer 10706 
  def validate(self):
10707 
    return
10708 
 
10709 
 
1220 chandransh 10710 
  def __repr__(self):
10711 
    L = ['%s=%r' % (key, value)
10712 
      for key, value in self.__dict__.iteritems()]
10713 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10714 
 
10715 
  def __eq__(self, other):
10716 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10717 
 
10718 
  def __ne__(self, other):
10719 
    return not (self == other)
10720 
 
10721 
class batchOrders_result:
10722 
  """
10723 
  Attributes:
10724 
   - success
10725 
   - ex
10726 
  """
10727 
 
10728 
  thrift_spec = (
10729 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
10730 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
10731 
  )
10732 
 
10733 
  def __init__(self, success=None, ex=None,):
10734 
    self.success = success
10735 
    self.ex = ex
10736 
 
10737 
  def read(self, iprot):
10738 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10739 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10740 
      return
10741 
    iprot.readStructBegin()
10742 
    while True:
10743 
      (fname, ftype, fid) = iprot.readFieldBegin()
10744 
      if ftype == TType.STOP:
10745 
        break
10746 
      if fid == 0:
10747 
        if ftype == TType.LIST:
10748 
          self.success = []
5031 varun.gupt 10749 
          (_etype206, _size203) = iprot.readListBegin()
10750 
          for _i207 in xrange(_size203):
10751 
            _elem208 = Order()
10752 
            _elem208.read(iprot)
10753 
            self.success.append(_elem208)
1220 chandransh 10754 
          iprot.readListEnd()
10755 
        else:
10756 
          iprot.skip(ftype)
10757 
      elif fid == 1:
10758 
        if ftype == TType.STRUCT:
10759 
          self.ex = TransactionServiceException()
10760 
          self.ex.read(iprot)
10761 
        else:
10762 
          iprot.skip(ftype)
10763 
      else:
10764 
        iprot.skip(ftype)
10765 
      iprot.readFieldEnd()
10766 
    iprot.readStructEnd()
10767 
 
10768 
  def write(self, oprot):
10769 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10770 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10771 
      return
10772 
    oprot.writeStructBegin('batchOrders_result')
3431 rajveer 10773 
    if self.success is not None:
1220 chandransh 10774 
      oprot.writeFieldBegin('success', TType.LIST, 0)
10775 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
5031 varun.gupt 10776 
      for iter209 in self.success:
10777 
        iter209.write(oprot)
1220 chandransh 10778 
      oprot.writeListEnd()
10779 
      oprot.writeFieldEnd()
3431 rajveer 10780 
    if self.ex is not None:
1220 chandransh 10781 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
10782 
      self.ex.write(oprot)
10783 
      oprot.writeFieldEnd()
10784 
    oprot.writeFieldStop()
10785 
    oprot.writeStructEnd()
10786 
 
3431 rajveer 10787 
  def validate(self):
10788 
    return
10789 
 
10790 
 
1220 chandransh 10791 
  def __repr__(self):
10792 
    L = ['%s=%r' % (key, value)
10793 
      for key, value in self.__dict__.iteritems()]
10794 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10795 
 
10796 
  def __eq__(self, other):
10797 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10798 
 
10799 
  def __ne__(self, other):
10800 
    return not (self == other)
10801 
 
1208 chandransh 10802 
class markOrderAsOutOfStock_args:
10803 
  """
10804 
  Attributes:
10805 
   - orderId
10806 
  """
10807 
 
10808 
  thrift_spec = (
10809 
    None, # 0
10810 
    (1, TType.I64, 'orderId', None, None, ), # 1
10811 
  )
10812 
 
10813 
  def __init__(self, orderId=None,):
10814 
    self.orderId = orderId
10815 
 
10816 
  def read(self, iprot):
10817 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10818 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10819 
      return
10820 
    iprot.readStructBegin()
10821 
    while True:
10822 
      (fname, ftype, fid) = iprot.readFieldBegin()
10823 
      if ftype == TType.STOP:
10824 
        break
10825 
      if fid == 1:
10826 
        if ftype == TType.I64:
10827 
          self.orderId = iprot.readI64();
10828 
        else:
10829 
          iprot.skip(ftype)
10830 
      else:
10831 
        iprot.skip(ftype)
10832 
      iprot.readFieldEnd()
10833 
    iprot.readStructEnd()
10834 
 
10835 
  def write(self, oprot):
10836 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10837 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10838 
      return
10839 
    oprot.writeStructBegin('markOrderAsOutOfStock_args')
3431 rajveer 10840 
    if self.orderId is not None:
1208 chandransh 10841 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
10842 
      oprot.writeI64(self.orderId)
10843 
      oprot.writeFieldEnd()
10844 
    oprot.writeFieldStop()
10845 
    oprot.writeStructEnd()
10846 
 
3431 rajveer 10847 
  def validate(self):
10848 
    return
10849 
 
10850 
 
1208 chandransh 10851 
  def __repr__(self):
10852 
    L = ['%s=%r' % (key, value)
10853 
      for key, value in self.__dict__.iteritems()]
10854 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10855 
 
10856 
  def __eq__(self, other):
10857 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10858 
 
10859 
  def __ne__(self, other):
10860 
    return not (self == other)
10861 
 
10862 
class markOrderAsOutOfStock_result:
10863 
  """
10864 
  Attributes:
10865 
   - success
10866 
   - ex
10867 
  """
10868 
 
10869 
  thrift_spec = (
10870 
    (0, TType.BOOL, 'success', None, None, ), # 0
10871 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
10872 
  )
10873 
 
10874 
  def __init__(self, success=None, ex=None,):
10875 
    self.success = success
10876 
    self.ex = ex
10877 
 
10878 
  def read(self, iprot):
10879 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10880 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10881 
      return
10882 
    iprot.readStructBegin()
10883 
    while True:
10884 
      (fname, ftype, fid) = iprot.readFieldBegin()
10885 
      if ftype == TType.STOP:
10886 
        break
10887 
      if fid == 0:
10888 
        if ftype == TType.BOOL:
10889 
          self.success = iprot.readBool();
10890 
        else:
10891 
          iprot.skip(ftype)
10892 
      elif fid == 1:
10893 
        if ftype == TType.STRUCT:
10894 
          self.ex = TransactionServiceException()
10895 
          self.ex.read(iprot)
10896 
        else:
10897 
          iprot.skip(ftype)
10898 
      else:
10899 
        iprot.skip(ftype)
10900 
      iprot.readFieldEnd()
10901 
    iprot.readStructEnd()
10902 
 
10903 
  def write(self, oprot):
10904 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10905 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10906 
      return
10907 
    oprot.writeStructBegin('markOrderAsOutOfStock_result')
3431 rajveer 10908 
    if self.success is not None:
1208 chandransh 10909 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
10910 
      oprot.writeBool(self.success)
10911 
      oprot.writeFieldEnd()
3431 rajveer 10912 
    if self.ex is not None:
1208 chandransh 10913 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
10914 
      self.ex.write(oprot)
10915 
      oprot.writeFieldEnd()
10916 
    oprot.writeFieldStop()
10917 
    oprot.writeStructEnd()
10918 
 
3431 rajveer 10919 
  def validate(self):
10920 
    return
10921 
 
10922 
 
1208 chandransh 10923 
  def __repr__(self):
10924 
    L = ['%s=%r' % (key, value)
10925 
      for key, value in self.__dict__.iteritems()]
10926 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10927 
 
10928 
  def __eq__(self, other):
10929 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10930 
 
10931 
  def __ne__(self, other):
10932 
    return not (self == other)
10933 
 
3064 chandransh 10934 
class verifyOrder_args:
759 chandransh 10935 
  """
10936 
  Attributes:
3064 chandransh 10937 
   - orderId
759 chandransh 10938 
  """
10939 
 
10940 
  thrift_spec = (
10941 
    None, # 0
3064 chandransh 10942 
    (1, TType.I64, 'orderId', None, None, ), # 1
759 chandransh 10943 
  )
10944 
 
3064 chandransh 10945 
  def __init__(self, orderId=None,):
10946 
    self.orderId = orderId
759 chandransh 10947 
 
10948 
  def read(self, iprot):
10949 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10950 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10951 
      return
10952 
    iprot.readStructBegin()
10953 
    while True:
10954 
      (fname, ftype, fid) = iprot.readFieldBegin()
10955 
      if ftype == TType.STOP:
10956 
        break
10957 
      if fid == 1:
10958 
        if ftype == TType.I64:
3064 chandransh 10959 
          self.orderId = iprot.readI64();
759 chandransh 10960 
        else:
10961 
          iprot.skip(ftype)
10962 
      else:
10963 
        iprot.skip(ftype)
10964 
      iprot.readFieldEnd()
10965 
    iprot.readStructEnd()
10966 
 
10967 
  def write(self, oprot):
10968 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10969 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10970 
      return
3064 chandransh 10971 
    oprot.writeStructBegin('verifyOrder_args')
3431 rajveer 10972 
    if self.orderId is not None:
3064 chandransh 10973 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
10974 
      oprot.writeI64(self.orderId)
759 chandransh 10975 
      oprot.writeFieldEnd()
10976 
    oprot.writeFieldStop()
10977 
    oprot.writeStructEnd()
10978 
 
3431 rajveer 10979 
  def validate(self):
10980 
    return
10981 
 
10982 
 
759 chandransh 10983 
  def __repr__(self):
10984 
    L = ['%s=%r' % (key, value)
10985 
      for key, value in self.__dict__.iteritems()]
10986 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10987 
 
10988 
  def __eq__(self, other):
10989 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10990 
 
10991 
  def __ne__(self, other):
10992 
    return not (self == other)
10993 
 
3064 chandransh 10994 
class verifyOrder_result:
759 chandransh 10995 
  """
10996 
  Attributes:
10997 
   - success
10998 
   - ex
10999 
  """
11000 
 
11001 
  thrift_spec = (
11002 
    (0, TType.BOOL, 'success', None, None, ), # 0
11003 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
11004 
  )
11005 
 
11006 
  def __init__(self, success=None, ex=None,):
11007 
    self.success = success
11008 
    self.ex = ex
11009 
 
11010 
  def read(self, iprot):
11011 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11012 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11013 
      return
11014 
    iprot.readStructBegin()
11015 
    while True:
11016 
      (fname, ftype, fid) = iprot.readFieldBegin()
11017 
      if ftype == TType.STOP:
11018 
        break
11019 
      if fid == 0:
11020 
        if ftype == TType.BOOL:
11021 
          self.success = iprot.readBool();
11022 
        else:
11023 
          iprot.skip(ftype)
11024 
      elif fid == 1:
11025 
        if ftype == TType.STRUCT:
11026 
          self.ex = TransactionServiceException()
11027 
          self.ex.read(iprot)
11028 
        else:
11029 
          iprot.skip(ftype)
11030 
      else:
11031 
        iprot.skip(ftype)
11032 
      iprot.readFieldEnd()
11033 
    iprot.readStructEnd()
11034 
 
11035 
  def write(self, oprot):
11036 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11037 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11038 
      return
3064 chandransh 11039 
    oprot.writeStructBegin('verifyOrder_result')
3431 rajveer 11040 
    if self.success is not None:
759 chandransh 11041 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
11042 
      oprot.writeBool(self.success)
11043 
      oprot.writeFieldEnd()
3431 rajveer 11044 
    if self.ex is not None:
759 chandransh 11045 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
11046 
      self.ex.write(oprot)
11047 
      oprot.writeFieldEnd()
11048 
    oprot.writeFieldStop()
11049 
    oprot.writeStructEnd()
11050 
 
3431 rajveer 11051 
  def validate(self):
11052 
    return
11053 
 
11054 
 
759 chandransh 11055 
  def __repr__(self):
11056 
    L = ['%s=%r' % (key, value)
11057 
      for key, value in self.__dict__.iteritems()]
11058 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11059 
 
11060 
  def __eq__(self, other):
11061 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11062 
 
11063 
  def __ne__(self, other):
11064 
    return not (self == other)
11065 
 
3064 chandransh 11066 
class acceptOrder_args:
1113 chandransh 11067 
  """
11068 
  Attributes:
3064 chandransh 11069 
   - orderId
1113 chandransh 11070 
  """
11071 
 
11072 
  thrift_spec = (
11073 
    None, # 0
3064 chandransh 11074 
    (1, TType.I64, 'orderId', None, None, ), # 1
1113 chandransh 11075 
  )
11076 
 
3064 chandransh 11077 
  def __init__(self, orderId=None,):
11078 
    self.orderId = orderId
1113 chandransh 11079 
 
11080 
  def read(self, iprot):
11081 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11082 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11083 
      return
11084 
    iprot.readStructBegin()
11085 
    while True:
11086 
      (fname, ftype, fid) = iprot.readFieldBegin()
11087 
      if ftype == TType.STOP:
11088 
        break
11089 
      if fid == 1:
11090 
        if ftype == TType.I64:
3064 chandransh 11091 
          self.orderId = iprot.readI64();
1113 chandransh 11092 
        else:
11093 
          iprot.skip(ftype)
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('acceptOrder_args')
3431 rajveer 11104 
    if self.orderId is not None:
3064 chandransh 11105 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
11106 
      oprot.writeI64(self.orderId)
1113 chandransh 11107 
      oprot.writeFieldEnd()
11108 
    oprot.writeFieldStop()
11109 
    oprot.writeStructEnd()
11110 
 
3431 rajveer 11111 
  def validate(self):
11112 
    return
11113 
 
11114 
 
1113 chandransh 11115 
  def __repr__(self):
11116 
    L = ['%s=%r' % (key, value)
11117 
      for key, value in self.__dict__.iteritems()]
11118 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11119 
 
11120 
  def __eq__(self, other):
11121 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11122 
 
11123 
  def __ne__(self, other):
11124 
    return not (self == other)
11125 
 
3064 chandransh 11126 
class acceptOrder_result:
1113 chandransh 11127 
  """
11128 
  Attributes:
11129 
   - success
11130 
   - ex
11131 
  """
11132 
 
11133 
  thrift_spec = (
3064 chandransh 11134 
    (0, TType.BOOL, 'success', None, None, ), # 0
1113 chandransh 11135 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
11136 
  )
11137 
 
11138 
  def __init__(self, success=None, ex=None,):
11139 
    self.success = success
11140 
    self.ex = ex
11141 
 
11142 
  def read(self, iprot):
11143 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11144 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11145 
      return
11146 
    iprot.readStructBegin()
11147 
    while True:
11148 
      (fname, ftype, fid) = iprot.readFieldBegin()
11149 
      if ftype == TType.STOP:
11150 
        break
11151 
      if fid == 0:
3064 chandransh 11152 
        if ftype == TType.BOOL:
11153 
          self.success = iprot.readBool();
1113 chandransh 11154 
        else:
11155 
          iprot.skip(ftype)
11156 
      elif fid == 1:
11157 
        if ftype == TType.STRUCT:
11158 
          self.ex = TransactionServiceException()
11159 
          self.ex.read(iprot)
11160 
        else:
11161 
          iprot.skip(ftype)
11162 
      else:
11163 
        iprot.skip(ftype)
11164 
      iprot.readFieldEnd()
11165 
    iprot.readStructEnd()
11166 
 
11167 
  def write(self, oprot):
11168 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11169 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11170 
      return
3064 chandransh 11171 
    oprot.writeStructBegin('acceptOrder_result')
3431 rajveer 11172 
    if self.success is not None:
3064 chandransh 11173 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
11174 
      oprot.writeBool(self.success)
1113 chandransh 11175 
      oprot.writeFieldEnd()
3431 rajveer 11176 
    if self.ex is not None:
1113 chandransh 11177 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
11178 
      self.ex.write(oprot)
11179 
      oprot.writeFieldEnd()
11180 
    oprot.writeFieldStop()
11181 
    oprot.writeStructEnd()
11182 
 
3431 rajveer 11183 
  def validate(self):
11184 
    return
11185 
 
11186 
 
1113 chandransh 11187 
  def __repr__(self):
11188 
    L = ['%s=%r' % (key, value)
11189 
      for key, value in self.__dict__.iteritems()]
11190 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11191 
 
11192 
  def __eq__(self, other):
11193 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11194 
 
11195 
  def __ne__(self, other):
11196 
    return not (self == other)
11197 
 
3064 chandransh 11198 
class addBillingDetails_args:
1135 chandransh 11199 
  """
11200 
  Attributes:
3064 chandransh 11201 
   - orderId
11202 
   - invoice_number
4658 mandeep.dh 11203 
   - serialNumber
4283 anupam.sin 11204 
   - itemNumber
3064 chandransh 11205 
   - billed_by
4264 rajveer 11206 
   - jacketNumber
4283 anupam.sin 11207 
   - billingType
11208 
   - vendorId
4763 rajveer 11209 
   - authorize
1135 chandransh 11210 
  """
11211 
 
11212 
  thrift_spec = (
11213 
    None, # 0
3064 chandransh 11214 
    (1, TType.I64, 'orderId', None, None, ), # 1
11215 
    (2, TType.STRING, 'invoice_number', None, None, ), # 2
4658 mandeep.dh 11216 
    (3, TType.STRING, 'serialNumber', None, None, ), # 3
4283 anupam.sin 11217 
    (4, TType.STRING, 'itemNumber', None, None, ), # 4
11218 
    (5, TType.STRING, 'billed_by', None, None, ), # 5
11219 
    (6, TType.I64, 'jacketNumber', None, None, ), # 6
11220 
    (7, TType.I64, 'billingType', None, None, ), # 7
11221 
    (8, TType.I64, 'vendorId', None, None, ), # 8
4763 rajveer 11222 
    (9, TType.BOOL, 'authorize', None, None, ), # 9
1135 chandransh 11223 
  )
11224 
 
4763 rajveer 11225 
  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 11226 
    self.orderId = orderId
11227 
    self.invoice_number = invoice_number
4658 mandeep.dh 11228 
    self.serialNumber = serialNumber
4283 anupam.sin 11229 
    self.itemNumber = itemNumber
3064 chandransh 11230 
    self.billed_by = billed_by
4264 rajveer 11231 
    self.jacketNumber = jacketNumber
4283 anupam.sin 11232 
    self.billingType = billingType
11233 
    self.vendorId = vendorId
4763 rajveer 11234 
    self.authorize = authorize
1135 chandransh 11235 
 
11236 
  def read(self, iprot):
11237 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11238 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11239 
      return
11240 
    iprot.readStructBegin()
11241 
    while True:
11242 
      (fname, ftype, fid) = iprot.readFieldBegin()
11243 
      if ftype == TType.STOP:
11244 
        break
11245 
      if fid == 1:
11246 
        if ftype == TType.I64:
3064 chandransh 11247 
          self.orderId = iprot.readI64();
1135 chandransh 11248 
        else:
11249 
          iprot.skip(ftype)
11250 
      elif fid == 2:
3064 chandransh 11251 
        if ftype == TType.STRING:
11252 
          self.invoice_number = iprot.readString();
1135 chandransh 11253 
        else:
11254 
          iprot.skip(ftype)
3064 chandransh 11255 
      elif fid == 3:
4658 mandeep.dh 11256 
        if ftype == TType.STRING:
11257 
          self.serialNumber = iprot.readString();
3064 chandransh 11258 
        else:
11259 
          iprot.skip(ftype)
11260 
      elif fid == 4:
11261 
        if ftype == TType.STRING:
11262 
          self.itemNumber = iprot.readString();
11263 
        else:
11264 
          iprot.skip(ftype)
11265 
      elif fid == 5:
11266 
        if ftype == TType.STRING:
4283 anupam.sin 11267 
          self.billed_by = iprot.readString();
3064 chandransh 11268 
        else:
11269 
          iprot.skip(ftype)
11270 
      elif fid == 6:
11271 
        if ftype == TType.I64:
4283 anupam.sin 11272 
          self.jacketNumber = iprot.readI64();
11273 
        else:
11274 
          iprot.skip(ftype)
11275 
      elif fid == 7:
11276 
        if ftype == TType.I64:
3064 chandransh 11277 
          self.billingType = iprot.readI64();
11278 
        else:
11279 
          iprot.skip(ftype)
4283 anupam.sin 11280 
      elif fid == 8:
11281 
        if ftype == TType.I64:
11282 
          self.vendorId = iprot.readI64();
11283 
        else:
11284 
          iprot.skip(ftype)
4763 rajveer 11285 
      elif fid == 9:
11286 
        if ftype == TType.BOOL:
11287 
          self.authorize = iprot.readBool();
11288 
        else:
11289 
          iprot.skip(ftype)
1246 chandransh 11290 
      else:
11291 
        iprot.skip(ftype)
11292 
      iprot.readFieldEnd()
11293 
    iprot.readStructEnd()
11294 
 
11295 
  def write(self, oprot):
11296 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11297 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11298 
      return
4283 anupam.sin 11299 
    oprot.writeStructBegin('addBillingDetails_args')
3431 rajveer 11300 
    if self.orderId is not None:
3064 chandransh 11301 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
11302 
      oprot.writeI64(self.orderId)
1246 chandransh 11303 
      oprot.writeFieldEnd()
4283 anupam.sin 11304 
    if self.invoice_number is not None:
11305 
      oprot.writeFieldBegin('invoice_number', TType.STRING, 2)
11306 
      oprot.writeString(self.invoice_number)
1246 chandransh 11307 
      oprot.writeFieldEnd()
4658 mandeep.dh 11308 
    if self.serialNumber is not None:
11309 
      oprot.writeFieldBegin('serialNumber', TType.STRING, 3)
11310 
      oprot.writeString(self.serialNumber)
3064 chandransh 11311 
      oprot.writeFieldEnd()
3431 rajveer 11312 
    if self.itemNumber is not None:
3064 chandransh 11313 
      oprot.writeFieldBegin('itemNumber', TType.STRING, 4)
11314 
      oprot.writeString(self.itemNumber)
11315 
      oprot.writeFieldEnd()
4283 anupam.sin 11316 
    if self.billed_by is not None:
11317 
      oprot.writeFieldBegin('billed_by', TType.STRING, 5)
11318 
      oprot.writeString(self.billed_by)
3064 chandransh 11319 
      oprot.writeFieldEnd()
4283 anupam.sin 11320 
    if self.jacketNumber is not None:
11321 
      oprot.writeFieldBegin('jacketNumber', TType.I64, 6)
11322 
      oprot.writeI64(self.jacketNumber)
11323 
      oprot.writeFieldEnd()
3431 rajveer 11324 
    if self.billingType is not None:
4283 anupam.sin 11325 
      oprot.writeFieldBegin('billingType', TType.I64, 7)
3064 chandransh 11326 
      oprot.writeI64(self.billingType)
11327 
      oprot.writeFieldEnd()
4283 anupam.sin 11328 
    if self.vendorId is not None:
11329 
      oprot.writeFieldBegin('vendorId', TType.I64, 8)
11330 
      oprot.writeI64(self.vendorId)
11331 
      oprot.writeFieldEnd()
4763 rajveer 11332 
    if self.authorize is not None:
11333 
      oprot.writeFieldBegin('authorize', TType.BOOL, 9)
11334 
      oprot.writeBool(self.authorize)
11335 
      oprot.writeFieldEnd()
1246 chandransh 11336 
    oprot.writeFieldStop()
11337 
    oprot.writeStructEnd()
11338 
 
3431 rajveer 11339 
  def validate(self):
11340 
    return
11341 
 
11342 
 
1246 chandransh 11343 
  def __repr__(self):
11344 
    L = ['%s=%r' % (key, value)
11345 
      for key, value in self.__dict__.iteritems()]
11346 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11347 
 
11348 
  def __eq__(self, other):
11349 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11350 
 
11351 
  def __ne__(self, other):
11352 
    return not (self == other)
11353 
 
4283 anupam.sin 11354 
class addBillingDetails_result:
1246 chandransh 11355 
  """
11356 
  Attributes:
3064 chandransh 11357 
   - success
1246 chandransh 11358 
   - ex
11359 
  """
11360 
 
11361 
  thrift_spec = (
3064 chandransh 11362 
    (0, TType.BOOL, 'success', None, None, ), # 0
1246 chandransh 11363 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
11364 
  )
11365 
 
3064 chandransh 11366 
  def __init__(self, success=None, ex=None,):
11367 
    self.success = success
1246 chandransh 11368 
    self.ex = ex
11369 
 
11370 
  def read(self, iprot):
11371 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11372 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11373 
      return
11374 
    iprot.readStructBegin()
11375 
    while True:
11376 
      (fname, ftype, fid) = iprot.readFieldBegin()
11377 
      if ftype == TType.STOP:
11378 
        break
3064 chandransh 11379 
      if fid == 0:
11380 
        if ftype == TType.BOOL:
11381 
          self.success = iprot.readBool();
11382 
        else:
11383 
          iprot.skip(ftype)
11384 
      elif fid == 1:
1246 chandransh 11385 
        if ftype == TType.STRUCT:
11386 
          self.ex = TransactionServiceException()
11387 
          self.ex.read(iprot)
11388 
        else:
11389 
          iprot.skip(ftype)
11390 
      else:
11391 
        iprot.skip(ftype)
11392 
      iprot.readFieldEnd()
11393 
    iprot.readStructEnd()
11394 
 
11395 
  def write(self, oprot):
11396 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11397 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11398 
      return
4283 anupam.sin 11399 
    oprot.writeStructBegin('addBillingDetails_result')
3431 rajveer 11400 
    if self.success is not None:
3064 chandransh 11401 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
11402 
      oprot.writeBool(self.success)
11403 
      oprot.writeFieldEnd()
3431 rajveer 11404 
    if self.ex is not None:
1246 chandransh 11405 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
11406 
      self.ex.write(oprot)
11407 
      oprot.writeFieldEnd()
11408 
    oprot.writeFieldStop()
11409 
    oprot.writeStructEnd()
11410 
 
3431 rajveer 11411 
  def validate(self):
11412 
    return
11413 
 
11414 
 
1246 chandransh 11415 
  def __repr__(self):
11416 
    L = ['%s=%r' % (key, value)
11417 
      for key, value in self.__dict__.iteritems()]
11418 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11419 
 
11420 
  def __eq__(self, other):
11421 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11422 
 
11423 
  def __ne__(self, other):
11424 
    return not (self == other)
11425 
 
4579 rajveer 11426 
class addInvoiceNumber_args:
11427 
  """
11428 
  Attributes:
11429 
   - orderId
11430 
   - invoiceNumber
4763 rajveer 11431 
   - color
4579 rajveer 11432 
  """
11433 
 
11434 
  thrift_spec = (
11435 
    None, # 0
11436 
    (1, TType.I64, 'orderId', None, None, ), # 1
11437 
    (2, TType.STRING, 'invoiceNumber', None, None, ), # 2
4763 rajveer 11438 
    (3, TType.STRING, 'color', None, None, ), # 3
4579 rajveer 11439 
  )
11440 
 
4763 rajveer 11441 
  def __init__(self, orderId=None, invoiceNumber=None, color=None,):
4579 rajveer 11442 
    self.orderId = orderId
11443 
    self.invoiceNumber = invoiceNumber
4763 rajveer 11444 
    self.color = color
4579 rajveer 11445 
 
11446 
  def read(self, iprot):
11447 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11448 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11449 
      return
11450 
    iprot.readStructBegin()
11451 
    while True:
11452 
      (fname, ftype, fid) = iprot.readFieldBegin()
11453 
      if ftype == TType.STOP:
11454 
        break
11455 
      if fid == 1:
11456 
        if ftype == TType.I64:
11457 
          self.orderId = iprot.readI64();
11458 
        else:
11459 
          iprot.skip(ftype)
11460 
      elif fid == 2:
11461 
        if ftype == TType.STRING:
11462 
          self.invoiceNumber = iprot.readString();
11463 
        else:
11464 
          iprot.skip(ftype)
4763 rajveer 11465 
      elif fid == 3:
11466 
        if ftype == TType.STRING:
11467 
          self.color = iprot.readString();
11468 
        else:
11469 
          iprot.skip(ftype)
4579 rajveer 11470 
      else:
11471 
        iprot.skip(ftype)
11472 
      iprot.readFieldEnd()
11473 
    iprot.readStructEnd()
11474 
 
11475 
  def write(self, oprot):
11476 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11477 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11478 
      return
11479 
    oprot.writeStructBegin('addInvoiceNumber_args')
11480 
    if self.orderId is not None:
11481 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
11482 
      oprot.writeI64(self.orderId)
11483 
      oprot.writeFieldEnd()
11484 
    if self.invoiceNumber is not None:
11485 
      oprot.writeFieldBegin('invoiceNumber', TType.STRING, 2)
11486 
      oprot.writeString(self.invoiceNumber)
11487 
      oprot.writeFieldEnd()
4763 rajveer 11488 
    if self.color is not None:
11489 
      oprot.writeFieldBegin('color', TType.STRING, 3)
11490 
      oprot.writeString(self.color)
11491 
      oprot.writeFieldEnd()
4579 rajveer 11492 
    oprot.writeFieldStop()
11493 
    oprot.writeStructEnd()
11494 
 
11495 
  def validate(self):
11496 
    return
11497 
 
11498 
 
11499 
  def __repr__(self):
11500 
    L = ['%s=%r' % (key, value)
11501 
      for key, value in self.__dict__.iteritems()]
11502 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11503 
 
11504 
  def __eq__(self, other):
11505 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11506 
 
11507 
  def __ne__(self, other):
11508 
    return not (self == other)
11509 
 
11510 
class addInvoiceNumber_result:
11511 
  """
11512 
  Attributes:
11513 
   - ex
11514 
  """
11515 
 
11516 
  thrift_spec = (
11517 
    None, # 0
11518 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
11519 
  )
11520 
 
11521 
  def __init__(self, ex=None,):
11522 
    self.ex = ex
11523 
 
11524 
  def read(self, iprot):
11525 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11526 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11527 
      return
11528 
    iprot.readStructBegin()
11529 
    while True:
11530 
      (fname, ftype, fid) = iprot.readFieldBegin()
11531 
      if ftype == TType.STOP:
11532 
        break
11533 
      if fid == 1:
11534 
        if ftype == TType.STRUCT:
11535 
          self.ex = TransactionServiceException()
11536 
          self.ex.read(iprot)
11537 
        else:
11538 
          iprot.skip(ftype)
11539 
      else:
11540 
        iprot.skip(ftype)
11541 
      iprot.readFieldEnd()
11542 
    iprot.readStructEnd()
11543 
 
11544 
  def write(self, oprot):
11545 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11546 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11547 
      return
11548 
    oprot.writeStructBegin('addInvoiceNumber_result')
11549 
    if self.ex is not None:
11550 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
11551 
      self.ex.write(oprot)
11552 
      oprot.writeFieldEnd()
11553 
    oprot.writeFieldStop()
11554 
    oprot.writeStructEnd()
11555 
 
11556 
  def validate(self):
11557 
    return
11558 
 
11559 
 
11560 
  def __repr__(self):
11561 
    L = ['%s=%r' % (key, value)
11562 
      for key, value in self.__dict__.iteritems()]
11563 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11564 
 
11565 
  def __eq__(self, other):
11566 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11567 
 
11568 
  def __ne__(self, other):
11569 
    return not (self == other)
11570 
 
4910 phani.kuma 11571 
class markOrdersAsShippedFromWarehouse_args:
1408 ankur.sing 11572 
  """
11573 
  Attributes:
3064 chandransh 11574 
   - warehouseId
1408 ankur.sing 11575 
   - providerId
3064 chandransh 11576 
   - cod
4910 phani.kuma 11577 
   - orderIds
1408 ankur.sing 11578 
  """
11579 
 
11580 
  thrift_spec = (
11581 
    None, # 0
3064 chandransh 11582 
    (1, TType.I64, 'warehouseId', None, None, ), # 1
11583 
    (2, TType.I64, 'providerId', None, None, ), # 2
11584 
    (3, TType.BOOL, 'cod', None, None, ), # 3
4910 phani.kuma 11585 
    (4, TType.LIST, 'orderIds', (TType.I64,None), None, ), # 4
1408 ankur.sing 11586 
  )
11587 
 
4910 phani.kuma 11588 
  def __init__(self, warehouseId=None, providerId=None, cod=None, orderIds=None,):
3064 chandransh 11589 
    self.warehouseId = warehouseId
1408 ankur.sing 11590 
    self.providerId = providerId
3064 chandransh 11591 
    self.cod = cod
4910 phani.kuma 11592 
    self.orderIds = orderIds
1408 ankur.sing 11593 
 
11594 
  def read(self, iprot):
11595 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11596 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11597 
      return
11598 
    iprot.readStructBegin()
11599 
    while True:
11600 
      (fname, ftype, fid) = iprot.readFieldBegin()
11601 
      if ftype == TType.STOP:
11602 
        break
11603 
      if fid == 1:
11604 
        if ftype == TType.I64:
3064 chandransh 11605 
          self.warehouseId = iprot.readI64();
1408 ankur.sing 11606 
        else:
11607 
          iprot.skip(ftype)
11608 
      elif fid == 2:
11609 
        if ftype == TType.I64:
3064 chandransh 11610 
          self.providerId = iprot.readI64();
1408 ankur.sing 11611 
        else:
11612 
          iprot.skip(ftype)
3064 chandransh 11613 
      elif fid == 3:
11614 
        if ftype == TType.BOOL:
11615 
          self.cod = iprot.readBool();
11616 
        else:
11617 
          iprot.skip(ftype)
4910 phani.kuma 11618 
      elif fid == 4:
11619 
        if ftype == TType.LIST:
11620 
          self.orderIds = []
5031 varun.gupt 11621 
          (_etype213, _size210) = iprot.readListBegin()
11622 
          for _i214 in xrange(_size210):
11623 
            _elem215 = iprot.readI64();
11624 
            self.orderIds.append(_elem215)
4910 phani.kuma 11625 
          iprot.readListEnd()
11626 
        else:
11627 
          iprot.skip(ftype)
1408 ankur.sing 11628 
      else:
11629 
        iprot.skip(ftype)
11630 
      iprot.readFieldEnd()
11631 
    iprot.readStructEnd()
11632 
 
11633 
  def write(self, oprot):
11634 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11635 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11636 
      return
4910 phani.kuma 11637 
    oprot.writeStructBegin('markOrdersAsShippedFromWarehouse_args')
3431 rajveer 11638 
    if self.warehouseId is not None:
3064 chandransh 11639 
      oprot.writeFieldBegin('warehouseId', TType.I64, 1)
11640 
      oprot.writeI64(self.warehouseId)
11641 
      oprot.writeFieldEnd()
3431 rajveer 11642 
    if self.providerId is not None:
3064 chandransh 11643 
      oprot.writeFieldBegin('providerId', TType.I64, 2)
1408 ankur.sing 11644 
      oprot.writeI64(self.providerId)
11645 
      oprot.writeFieldEnd()
3431 rajveer 11646 
    if self.cod is not None:
3064 chandransh 11647 
      oprot.writeFieldBegin('cod', TType.BOOL, 3)
11648 
      oprot.writeBool(self.cod)
1408 ankur.sing 11649 
      oprot.writeFieldEnd()
4910 phani.kuma 11650 
    if self.orderIds is not None:
11651 
      oprot.writeFieldBegin('orderIds', TType.LIST, 4)
11652 
      oprot.writeListBegin(TType.I64, len(self.orderIds))
5031 varun.gupt 11653 
      for iter216 in self.orderIds:
11654 
        oprot.writeI64(iter216)
4910 phani.kuma 11655 
      oprot.writeListEnd()
11656 
      oprot.writeFieldEnd()
1408 ankur.sing 11657 
    oprot.writeFieldStop()
11658 
    oprot.writeStructEnd()
11659 
 
3431 rajveer 11660 
  def validate(self):
11661 
    return
11662 
 
11663 
 
1408 ankur.sing 11664 
  def __repr__(self):
11665 
    L = ['%s=%r' % (key, value)
11666 
      for key, value in self.__dict__.iteritems()]
11667 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11668 
 
11669 
  def __eq__(self, other):
11670 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11671 
 
11672 
  def __ne__(self, other):
11673 
    return not (self == other)
11674 
 
4910 phani.kuma 11675 
class markOrdersAsShippedFromWarehouse_result:
1408 ankur.sing 11676 
  """
11677 
  Attributes:
11678 
   - success
3064 chandransh 11679 
   - ex
1408 ankur.sing 11680 
  """
11681 
 
11682 
  thrift_spec = (
3064 chandransh 11683 
    (0, TType.BOOL, 'success', None, None, ), # 0
11684 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
1408 ankur.sing 11685 
  )
11686 
 
3064 chandransh 11687 
  def __init__(self, success=None, ex=None,):
1408 ankur.sing 11688 
    self.success = success
3064 chandransh 11689 
    self.ex = ex
1408 ankur.sing 11690 
 
11691 
  def read(self, iprot):
11692 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11693 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11694 
      return
11695 
    iprot.readStructBegin()
11696 
    while True:
11697 
      (fname, ftype, fid) = iprot.readFieldBegin()
11698 
      if ftype == TType.STOP:
11699 
        break
11700 
      if fid == 0:
3064 chandransh 11701 
        if ftype == TType.BOOL:
11702 
          self.success = iprot.readBool();
1408 ankur.sing 11703 
        else:
11704 
          iprot.skip(ftype)
3064 chandransh 11705 
      elif fid == 1:
11706 
        if ftype == TType.STRUCT:
11707 
          self.ex = TransactionServiceException()
11708 
          self.ex.read(iprot)
11709 
        else:
11710 
          iprot.skip(ftype)
1408 ankur.sing 11711 
      else:
11712 
        iprot.skip(ftype)
11713 
      iprot.readFieldEnd()
11714 
    iprot.readStructEnd()
11715 
 
11716 
  def write(self, oprot):
11717 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11718 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11719 
      return
4910 phani.kuma 11720 
    oprot.writeStructBegin('markOrdersAsShippedFromWarehouse_result')
3431 rajveer 11721 
    if self.success is not None:
3064 chandransh 11722 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
11723 
      oprot.writeBool(self.success)
1408 ankur.sing 11724 
      oprot.writeFieldEnd()
3431 rajveer 11725 
    if self.ex is not None:
3064 chandransh 11726 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
11727 
      self.ex.write(oprot)
11728 
      oprot.writeFieldEnd()
1408 ankur.sing 11729 
    oprot.writeFieldStop()
11730 
    oprot.writeStructEnd()
11731 
 
3431 rajveer 11732 
  def validate(self):
11733 
    return
11734 
 
11735 
 
1408 ankur.sing 11736 
  def __repr__(self):
11737 
    L = ['%s=%r' % (key, value)
11738 
      for key, value in self.__dict__.iteritems()]
11739 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11740 
 
11741 
  def __eq__(self, other):
11742 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11743 
 
11744 
  def __ne__(self, other):
11745 
    return not (self == other)
11746 
 
4910 phani.kuma 11747 
class markOrdersAsPickedUp_args:
4410 rajveer 11748 
  """
11749 
  Attributes:
11750 
   - providerId
4910 phani.kuma 11751 
   - pickupDetails
4410 rajveer 11752 
  """
11753 
 
11754 
  thrift_spec = (
11755 
    None, # 0
4910 phani.kuma 11756 
    (1, TType.I64, 'providerId', None, None, ), # 1
11757 
    (2, TType.MAP, 'pickupDetails', (TType.STRING,None,TType.STRING,None), None, ), # 2
4410 rajveer 11758 
  )
11759 
 
4910 phani.kuma 11760 
  def __init__(self, providerId=None, pickupDetails=None,):
4410 rajveer 11761 
    self.providerId = providerId
4910 phani.kuma 11762 
    self.pickupDetails = pickupDetails
4410 rajveer 11763 
 
11764 
  def read(self, iprot):
11765 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11766 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11767 
      return
11768 
    iprot.readStructBegin()
11769 
    while True:
11770 
      (fname, ftype, fid) = iprot.readFieldBegin()
11771 
      if ftype == TType.STOP:
11772 
        break
11773 
      if fid == 1:
11774 
        if ftype == TType.I64:
4910 phani.kuma 11775 
          self.providerId = iprot.readI64();
4410 rajveer 11776 
        else:
11777 
          iprot.skip(ftype)
11778 
      elif fid == 2:
4910 phani.kuma 11779 
        if ftype == TType.MAP:
11780 
          self.pickupDetails = {}
5031 varun.gupt 11781 
          (_ktype218, _vtype219, _size217 ) = iprot.readMapBegin()
11782 
          for _i221 in xrange(_size217):
11783 
            _key222 = iprot.readString();
11784 
            _val223 = iprot.readString();
11785 
            self.pickupDetails[_key222] = _val223
4910 phani.kuma 11786 
          iprot.readMapEnd()
4410 rajveer 11787 
        else:
11788 
          iprot.skip(ftype)
11789 
      else:
11790 
        iprot.skip(ftype)
11791 
      iprot.readFieldEnd()
11792 
    iprot.readStructEnd()
11793 
 
11794 
  def write(self, oprot):
11795 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11796 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11797 
      return
4910 phani.kuma 11798 
    oprot.writeStructBegin('markOrdersAsPickedUp_args')
4410 rajveer 11799 
    if self.providerId is not None:
4910 phani.kuma 11800 
      oprot.writeFieldBegin('providerId', TType.I64, 1)
4410 rajveer 11801 
      oprot.writeI64(self.providerId)
11802 
      oprot.writeFieldEnd()
4910 phani.kuma 11803 
    if self.pickupDetails is not None:
11804 
      oprot.writeFieldBegin('pickupDetails', TType.MAP, 2)
11805 
      oprot.writeMapBegin(TType.STRING, TType.STRING, len(self.pickupDetails))
5031 varun.gupt 11806 
      for kiter224,viter225 in self.pickupDetails.items():
11807 
        oprot.writeString(kiter224)
11808 
        oprot.writeString(viter225)
4910 phani.kuma 11809 
      oprot.writeMapEnd()
4410 rajveer 11810 
      oprot.writeFieldEnd()
11811 
    oprot.writeFieldStop()
11812 
    oprot.writeStructEnd()
11813 
 
11814 
  def validate(self):
11815 
    return
11816 
 
11817 
 
11818 
  def __repr__(self):
11819 
    L = ['%s=%r' % (key, value)
11820 
      for key, value in self.__dict__.iteritems()]
11821 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11822 
 
11823 
  def __eq__(self, other):
11824 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11825 
 
11826 
  def __ne__(self, other):
11827 
    return not (self == other)
11828 
 
4910 phani.kuma 11829 
class markOrdersAsPickedUp_result:
4410 rajveer 11830 
  """
11831 
  Attributes:
11832 
   - ex
11833 
  """
11834 
 
11835 
  thrift_spec = (
4910 phani.kuma 11836 
    None, # 0
4410 rajveer 11837 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
11838 
  )
11839 
 
4910 phani.kuma 11840 
  def __init__(self, ex=None,):
4410 rajveer 11841 
    self.ex = ex
11842 
 
11843 
  def read(self, iprot):
11844 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11845 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11846 
      return
11847 
    iprot.readStructBegin()
11848 
    while True:
11849 
      (fname, ftype, fid) = iprot.readFieldBegin()
11850 
      if ftype == TType.STOP:
11851 
        break
4910 phani.kuma 11852 
      if fid == 1:
4410 rajveer 11853 
        if ftype == TType.STRUCT:
11854 
          self.ex = TransactionServiceException()
11855 
          self.ex.read(iprot)
11856 
        else:
11857 
          iprot.skip(ftype)
11858 
      else:
11859 
        iprot.skip(ftype)
11860 
      iprot.readFieldEnd()
11861 
    iprot.readStructEnd()
11862 
 
11863 
  def write(self, oprot):
11864 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11865 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11866 
      return
4910 phani.kuma 11867 
    oprot.writeStructBegin('markOrdersAsPickedUp_result')
4410 rajveer 11868 
    if self.ex is not None:
11869 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
11870 
      self.ex.write(oprot)
11871 
      oprot.writeFieldEnd()
11872 
    oprot.writeFieldStop()
11873 
    oprot.writeStructEnd()
11874 
 
11875 
  def validate(self):
11876 
    return
11877 
 
11878 
 
11879 
  def __repr__(self):
11880 
    L = ['%s=%r' % (key, value)
11881 
      for key, value in self.__dict__.iteritems()]
11882 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11883 
 
11884 
  def __eq__(self, other):
11885 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11886 
 
11887 
  def __ne__(self, other):
11888 
    return not (self == other)
11889 
 
4910 phani.kuma 11890 
class getOrdersNotPickedUp_args:
304 ashish 11891 
  """
11892 
  Attributes:
3064 chandransh 11893 
   - providerId
304 ashish 11894 
  """
94 ashish 11895 
 
304 ashish 11896 
  thrift_spec = (
11897 
    None, # 0
3064 chandransh 11898 
    (1, TType.I64, 'providerId', None, None, ), # 1
304 ashish 11899 
  )
11900 
 
4910 phani.kuma 11901 
  def __init__(self, providerId=None,):
3064 chandransh 11902 
    self.providerId = providerId
304 ashish 11903 
 
11904 
  def read(self, iprot):
11905 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11906 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11907 
      return
11908 
    iprot.readStructBegin()
11909 
    while True:
11910 
      (fname, ftype, fid) = iprot.readFieldBegin()
11911 
      if ftype == TType.STOP:
11912 
        break
11913 
      if fid == 1:
11914 
        if ftype == TType.I64:
3064 chandransh 11915 
          self.providerId = iprot.readI64();
304 ashish 11916 
        else:
11917 
          iprot.skip(ftype)
11918 
      else:
11919 
        iprot.skip(ftype)
11920 
      iprot.readFieldEnd()
11921 
    iprot.readStructEnd()
11922 
 
11923 
  def write(self, oprot):
11924 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11925 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11926 
      return
4910 phani.kuma 11927 
    oprot.writeStructBegin('getOrdersNotPickedUp_args')
3431 rajveer 11928 
    if self.providerId is not None:
3064 chandransh 11929 
      oprot.writeFieldBegin('providerId', TType.I64, 1)
11930 
      oprot.writeI64(self.providerId)
304 ashish 11931 
      oprot.writeFieldEnd()
11932 
    oprot.writeFieldStop()
11933 
    oprot.writeStructEnd()
11934 
 
3431 rajveer 11935 
  def validate(self):
11936 
    return
11937 
 
11938 
 
304 ashish 11939 
  def __repr__(self):
11940 
    L = ['%s=%r' % (key, value)
11941 
      for key, value in self.__dict__.iteritems()]
11942 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11943 
 
11944 
  def __eq__(self, other):
11945 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11946 
 
11947 
  def __ne__(self, other):
11948 
    return not (self == other)
11949 
 
4910 phani.kuma 11950 
class getOrdersNotPickedUp_result:
304 ashish 11951 
  """
11952 
  Attributes:
11953 
   - success
11954 
  """
11955 
 
11956 
  thrift_spec = (
3064 chandransh 11957 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
304 ashish 11958 
  )
11959 
 
4910 phani.kuma 11960 
  def __init__(self, success=None,):
304 ashish 11961 
    self.success = success
11962 
 
11963 
  def read(self, iprot):
11964 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11965 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11966 
      return
11967 
    iprot.readStructBegin()
11968 
    while True:
11969 
      (fname, ftype, fid) = iprot.readFieldBegin()
11970 
      if ftype == TType.STOP:
11971 
        break
11972 
      if fid == 0:
11973 
        if ftype == TType.LIST:
11974 
          self.success = []
5031 varun.gupt 11975 
          (_etype229, _size226) = iprot.readListBegin()
11976 
          for _i230 in xrange(_size226):
11977 
            _elem231 = Order()
11978 
            _elem231.read(iprot)
11979 
            self.success.append(_elem231)
304 ashish 11980 
          iprot.readListEnd()
11981 
        else:
11982 
          iprot.skip(ftype)
11983 
      else:
11984 
        iprot.skip(ftype)
11985 
      iprot.readFieldEnd()
11986 
    iprot.readStructEnd()
11987 
 
11988 
  def write(self, oprot):
11989 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11990 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11991 
      return
4910 phani.kuma 11992 
    oprot.writeStructBegin('getOrdersNotPickedUp_result')
3431 rajveer 11993 
    if self.success is not None:
304 ashish 11994 
      oprot.writeFieldBegin('success', TType.LIST, 0)
11995 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
5031 varun.gupt 11996 
      for iter232 in self.success:
11997 
        iter232.write(oprot)
304 ashish 11998 
      oprot.writeListEnd()
11999 
      oprot.writeFieldEnd()
12000 
    oprot.writeFieldStop()
12001 
    oprot.writeStructEnd()
12002 
 
3431 rajveer 12003 
  def validate(self):
12004 
    return
12005 
 
12006 
 
304 ashish 12007 
  def __repr__(self):
12008 
    L = ['%s=%r' % (key, value)
12009 
      for key, value in self.__dict__.iteritems()]
12010 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12011 
 
12012 
  def __eq__(self, other):
12013 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12014 
 
12015 
  def __ne__(self, other):
12016 
    return not (self == other)
12017 
 
3064 chandransh 12018 
class markOrdersAsDelivered_args:
304 ashish 12019 
  """
12020 
  Attributes:
3064 chandransh 12021 
   - providerId
12022 
   - deliveredOrders
304 ashish 12023 
  """
12024 
 
12025 
  thrift_spec = (
12026 
    None, # 0
3064 chandransh 12027 
    (1, TType.I64, 'providerId', None, None, ), # 1
12028 
    (2, TType.MAP, 'deliveredOrders', (TType.STRING,None,TType.STRING,None), None, ), # 2
304 ashish 12029 
  )
12030 
 
3064 chandransh 12031 
  def __init__(self, providerId=None, deliveredOrders=None,):
12032 
    self.providerId = providerId
12033 
    self.deliveredOrders = deliveredOrders
304 ashish 12034 
 
12035 
  def read(self, iprot):
12036 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12037 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12038 
      return
12039 
    iprot.readStructBegin()
12040 
    while True:
12041 
      (fname, ftype, fid) = iprot.readFieldBegin()
12042 
      if ftype == TType.STOP:
12043 
        break
12044 
      if fid == 1:
12045 
        if ftype == TType.I64:
3064 chandransh 12046 
          self.providerId = iprot.readI64();
304 ashish 12047 
        else:
12048 
          iprot.skip(ftype)
12049 
      elif fid == 2:
3064 chandransh 12050 
        if ftype == TType.MAP:
12051 
          self.deliveredOrders = {}
5031 varun.gupt 12052 
          (_ktype234, _vtype235, _size233 ) = iprot.readMapBegin()
12053 
          for _i237 in xrange(_size233):
12054 
            _key238 = iprot.readString();
12055 
            _val239 = iprot.readString();
12056 
            self.deliveredOrders[_key238] = _val239
3064 chandransh 12057 
          iprot.readMapEnd()
304 ashish 12058 
        else:
12059 
          iprot.skip(ftype)
12060 
      else:
12061 
        iprot.skip(ftype)
12062 
      iprot.readFieldEnd()
12063 
    iprot.readStructEnd()
12064 
 
12065 
  def write(self, oprot):
12066 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12067 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12068 
      return
3064 chandransh 12069 
    oprot.writeStructBegin('markOrdersAsDelivered_args')
3431 rajveer 12070 
    if self.providerId is not None:
3064 chandransh 12071 
      oprot.writeFieldBegin('providerId', TType.I64, 1)
12072 
      oprot.writeI64(self.providerId)
304 ashish 12073 
      oprot.writeFieldEnd()
3431 rajveer 12074 
    if self.deliveredOrders is not None:
3064 chandransh 12075 
      oprot.writeFieldBegin('deliveredOrders', TType.MAP, 2)
12076 
      oprot.writeMapBegin(TType.STRING, TType.STRING, len(self.deliveredOrders))
5031 varun.gupt 12077 
      for kiter240,viter241 in self.deliveredOrders.items():
12078 
        oprot.writeString(kiter240)
12079 
        oprot.writeString(viter241)
3064 chandransh 12080 
      oprot.writeMapEnd()
304 ashish 12081 
      oprot.writeFieldEnd()
12082 
    oprot.writeFieldStop()
12083 
    oprot.writeStructEnd()
12084 
 
3431 rajveer 12085 
  def validate(self):
12086 
    return
12087 
 
12088 
 
304 ashish 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 
 
3064 chandransh 12100 
class markOrdersAsDelivered_result:
12101 
  """
12102 
  Attributes:
12103 
   - ex
12104 
  """
304 ashish 12105 
 
12106 
  thrift_spec = (
3064 chandransh 12107 
    None, # 0
12108 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
304 ashish 12109 
  )
12110 
 
3064 chandransh 12111 
  def __init__(self, ex=None,):
12112 
    self.ex = ex
304 ashish 12113 
 
1596 ankur.sing 12114 
  def read(self, iprot):
12115 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12116 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12117 
      return
12118 
    iprot.readStructBegin()
12119 
    while True:
12120 
      (fname, ftype, fid) = iprot.readFieldBegin()
12121 
      if ftype == TType.STOP:
12122 
        break
3064 chandransh 12123 
      if fid == 1:
12124 
        if ftype == TType.STRUCT:
12125 
          self.ex = TransactionServiceException()
12126 
          self.ex.read(iprot)
12127 
        else:
12128 
          iprot.skip(ftype)
1596 ankur.sing 12129 
      else:
12130 
        iprot.skip(ftype)
12131 
      iprot.readFieldEnd()
12132 
    iprot.readStructEnd()
12133 
 
12134 
  def write(self, oprot):
12135 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12136 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12137 
      return
3064 chandransh 12138 
    oprot.writeStructBegin('markOrdersAsDelivered_result')
3431 rajveer 12139 
    if self.ex is not None:
3064 chandransh 12140 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
12141 
      self.ex.write(oprot)
12142 
      oprot.writeFieldEnd()
1596 ankur.sing 12143 
    oprot.writeFieldStop()
12144 
    oprot.writeStructEnd()
12145 
 
3431 rajveer 12146 
  def validate(self):
12147 
    return
12148 
 
12149 
 
1596 ankur.sing 12150 
  def __repr__(self):
12151 
    L = ['%s=%r' % (key, value)
12152 
      for key, value in self.__dict__.iteritems()]
12153 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12154 
 
12155 
  def __eq__(self, other):
12156 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12157 
 
12158 
  def __ne__(self, other):
12159 
    return not (self == other)
12160 
 
4910 phani.kuma 12161 
class markAsRTOrders_args:
1596 ankur.sing 12162 
  """
12163 
  Attributes:
3064 chandransh 12164 
   - providerId
12165 
   - returnedOrders
1596 ankur.sing 12166 
  """
12167 
 
12168 
  thrift_spec = (
3064 chandransh 12169 
    None, # 0
12170 
    (1, TType.I64, 'providerId', None, None, ), # 1
12171 
    (2, TType.MAP, 'returnedOrders', (TType.STRING,None,TType.STRING,None), None, ), # 2
1596 ankur.sing 12172 
  )
12173 
 
3064 chandransh 12174 
  def __init__(self, providerId=None, returnedOrders=None,):
12175 
    self.providerId = providerId
12176 
    self.returnedOrders = returnedOrders
1596 ankur.sing 12177 
 
12178 
  def read(self, iprot):
12179 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12180 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12181 
      return
12182 
    iprot.readStructBegin()
12183 
    while True:
12184 
      (fname, ftype, fid) = iprot.readFieldBegin()
12185 
      if ftype == TType.STOP:
12186 
        break
3064 chandransh 12187 
      if fid == 1:
1596 ankur.sing 12188 
        if ftype == TType.I64:
3064 chandransh 12189 
          self.providerId = iprot.readI64();
1596 ankur.sing 12190 
        else:
12191 
          iprot.skip(ftype)
3064 chandransh 12192 
      elif fid == 2:
12193 
        if ftype == TType.MAP:
12194 
          self.returnedOrders = {}
5031 varun.gupt 12195 
          (_ktype243, _vtype244, _size242 ) = iprot.readMapBegin()
12196 
          for _i246 in xrange(_size242):
12197 
            _key247 = iprot.readString();
12198 
            _val248 = iprot.readString();
12199 
            self.returnedOrders[_key247] = _val248
3064 chandransh 12200 
          iprot.readMapEnd()
12201 
        else:
12202 
          iprot.skip(ftype)
1596 ankur.sing 12203 
      else:
12204 
        iprot.skip(ftype)
12205 
      iprot.readFieldEnd()
12206 
    iprot.readStructEnd()
12207 
 
12208 
  def write(self, oprot):
12209 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12210 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12211 
      return
4910 phani.kuma 12212 
    oprot.writeStructBegin('markAsRTOrders_args')
3431 rajveer 12213 
    if self.providerId is not None:
3064 chandransh 12214 
      oprot.writeFieldBegin('providerId', TType.I64, 1)
12215 
      oprot.writeI64(self.providerId)
1596 ankur.sing 12216 
      oprot.writeFieldEnd()
3431 rajveer 12217 
    if self.returnedOrders is not None:
3064 chandransh 12218 
      oprot.writeFieldBegin('returnedOrders', TType.MAP, 2)
12219 
      oprot.writeMapBegin(TType.STRING, TType.STRING, len(self.returnedOrders))
5031 varun.gupt 12220 
      for kiter249,viter250 in self.returnedOrders.items():
12221 
        oprot.writeString(kiter249)
12222 
        oprot.writeString(viter250)
3064 chandransh 12223 
      oprot.writeMapEnd()
12224 
      oprot.writeFieldEnd()
1596 ankur.sing 12225 
    oprot.writeFieldStop()
12226 
    oprot.writeStructEnd()
12227 
 
3431 rajveer 12228 
  def validate(self):
12229 
    return
12230 
 
12231 
 
1596 ankur.sing 12232 
  def __repr__(self):
12233 
    L = ['%s=%r' % (key, value)
12234 
      for key, value in self.__dict__.iteritems()]
12235 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12236 
 
12237 
  def __eq__(self, other):
12238 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12239 
 
12240 
  def __ne__(self, other):
12241 
    return not (self == other)
12242 
 
4910 phani.kuma 12243 
class markAsRTOrders_result:
3064 chandransh 12244 
  """
12245 
  Attributes:
12246 
   - ex
12247 
  """
1596 ankur.sing 12248 
 
1627 ankur.sing 12249 
  thrift_spec = (
3064 chandransh 12250 
    None, # 0
12251 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
1627 ankur.sing 12252 
  )
12253 
 
3064 chandransh 12254 
  def __init__(self, ex=None,):
12255 
    self.ex = ex
12256 
 
1627 ankur.sing 12257 
  def read(self, iprot):
12258 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12259 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12260 
      return
12261 
    iprot.readStructBegin()
12262 
    while True:
12263 
      (fname, ftype, fid) = iprot.readFieldBegin()
12264 
      if ftype == TType.STOP:
12265 
        break
3064 chandransh 12266 
      if fid == 1:
12267 
        if ftype == TType.STRUCT:
12268 
          self.ex = TransactionServiceException()
12269 
          self.ex.read(iprot)
12270 
        else:
12271 
          iprot.skip(ftype)
1627 ankur.sing 12272 
      else:
12273 
        iprot.skip(ftype)
12274 
      iprot.readFieldEnd()
12275 
    iprot.readStructEnd()
12276 
 
12277 
  def write(self, oprot):
12278 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12279 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12280 
      return
4910 phani.kuma 12281 
    oprot.writeStructBegin('markAsRTOrders_result')
3431 rajveer 12282 
    if self.ex is not None:
3064 chandransh 12283 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
12284 
      self.ex.write(oprot)
12285 
      oprot.writeFieldEnd()
1627 ankur.sing 12286 
    oprot.writeFieldStop()
12287 
    oprot.writeStructEnd()
12288 
 
3431 rajveer 12289 
  def validate(self):
12290 
    return
12291 
 
12292 
 
1627 ankur.sing 12293 
  def __repr__(self):
12294 
    L = ['%s=%r' % (key, value)
12295 
      for key, value in self.__dict__.iteritems()]
12296 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12297 
 
12298 
  def __eq__(self, other):
12299 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12300 
 
12301 
  def __ne__(self, other):
12302 
    return not (self == other)
12303 
 
4910 phani.kuma 12304 
class getRTOrders_args:
12305 
  """
12306 
  Attributes:
12307 
   - providerId
12308 
  """
12309 
 
12310 
  thrift_spec = (
12311 
    None, # 0
12312 
    (1, TType.I64, 'providerId', None, None, ), # 1
12313 
  )
12314 
 
12315 
  def __init__(self, providerId=None,):
12316 
    self.providerId = providerId
12317 
 
12318 
  def read(self, iprot):
12319 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12320 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12321 
      return
12322 
    iprot.readStructBegin()
12323 
    while True:
12324 
      (fname, ftype, fid) = iprot.readFieldBegin()
12325 
      if ftype == TType.STOP:
12326 
        break
12327 
      if fid == 1:
12328 
        if ftype == TType.I64:
12329 
          self.providerId = iprot.readI64();
12330 
        else:
12331 
          iprot.skip(ftype)
12332 
      else:
12333 
        iprot.skip(ftype)
12334 
      iprot.readFieldEnd()
12335 
    iprot.readStructEnd()
12336 
 
12337 
  def write(self, oprot):
12338 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12339 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12340 
      return
12341 
    oprot.writeStructBegin('getRTOrders_args')
12342 
    if self.providerId is not None:
12343 
      oprot.writeFieldBegin('providerId', TType.I64, 1)
12344 
      oprot.writeI64(self.providerId)
12345 
      oprot.writeFieldEnd()
12346 
    oprot.writeFieldStop()
12347 
    oprot.writeStructEnd()
12348 
 
12349 
  def validate(self):
12350 
    return
12351 
 
12352 
 
12353 
  def __repr__(self):
12354 
    L = ['%s=%r' % (key, value)
12355 
      for key, value in self.__dict__.iteritems()]
12356 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12357 
 
12358 
  def __eq__(self, other):
12359 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12360 
 
12361 
  def __ne__(self, other):
12362 
    return not (self == other)
12363 
 
12364 
class getRTOrders_result:
12365 
  """
12366 
  Attributes:
12367 
   - success
12368 
  """
12369 
 
12370 
  thrift_spec = (
12371 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
12372 
  )
12373 
 
12374 
  def __init__(self, success=None,):
12375 
    self.success = success
12376 
 
12377 
  def read(self, iprot):
12378 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12379 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12380 
      return
12381 
    iprot.readStructBegin()
12382 
    while True:
12383 
      (fname, ftype, fid) = iprot.readFieldBegin()
12384 
      if ftype == TType.STOP:
12385 
        break
12386 
      if fid == 0:
12387 
        if ftype == TType.LIST:
12388 
          self.success = []
5031 varun.gupt 12389 
          (_etype254, _size251) = iprot.readListBegin()
12390 
          for _i255 in xrange(_size251):
12391 
            _elem256 = Order()
12392 
            _elem256.read(iprot)
12393 
            self.success.append(_elem256)
4910 phani.kuma 12394 
          iprot.readListEnd()
12395 
        else:
12396 
          iprot.skip(ftype)
12397 
      else:
12398 
        iprot.skip(ftype)
12399 
      iprot.readFieldEnd()
12400 
    iprot.readStructEnd()
12401 
 
12402 
  def write(self, oprot):
12403 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12404 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12405 
      return
12406 
    oprot.writeStructBegin('getRTOrders_result')
12407 
    if self.success is not None:
12408 
      oprot.writeFieldBegin('success', TType.LIST, 0)
12409 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
5031 varun.gupt 12410 
      for iter257 in self.success:
12411 
        iter257.write(oprot)
4910 phani.kuma 12412 
      oprot.writeListEnd()
12413 
      oprot.writeFieldEnd()
12414 
    oprot.writeFieldStop()
12415 
    oprot.writeStructEnd()
12416 
 
12417 
  def validate(self):
12418 
    return
12419 
 
12420 
 
12421 
  def __repr__(self):
12422 
    L = ['%s=%r' % (key, value)
12423 
      for key, value in self.__dict__.iteritems()]
12424 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12425 
 
12426 
  def __eq__(self, other):
12427 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12428 
 
12429 
  def __ne__(self, other):
12430 
    return not (self == other)
12431 
 
3064 chandransh 12432 
class updateNonDeliveryReason_args:
1627 ankur.sing 12433 
  """
12434 
  Attributes:
3064 chandransh 12435 
   - providerId
12436 
   - undeliveredOrders
1627 ankur.sing 12437 
  """
12438 
 
12439 
  thrift_spec = (
3064 chandransh 12440 
    None, # 0
12441 
    (1, TType.I64, 'providerId', None, None, ), # 1
12442 
    (2, TType.MAP, 'undeliveredOrders', (TType.STRING,None,TType.STRING,None), None, ), # 2
1627 ankur.sing 12443 
  )
12444 
 
3064 chandransh 12445 
  def __init__(self, providerId=None, undeliveredOrders=None,):
12446 
    self.providerId = providerId
12447 
    self.undeliveredOrders = undeliveredOrders
1627 ankur.sing 12448 
 
12449 
  def read(self, iprot):
12450 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12451 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12452 
      return
12453 
    iprot.readStructBegin()
12454 
    while True:
12455 
      (fname, ftype, fid) = iprot.readFieldBegin()
12456 
      if ftype == TType.STOP:
12457 
        break
3064 chandransh 12458 
      if fid == 1:
1627 ankur.sing 12459 
        if ftype == TType.I64:
3064 chandransh 12460 
          self.providerId = iprot.readI64();
1627 ankur.sing 12461 
        else:
12462 
          iprot.skip(ftype)
3064 chandransh 12463 
      elif fid == 2:
12464 
        if ftype == TType.MAP:
12465 
          self.undeliveredOrders = {}
5031 varun.gupt 12466 
          (_ktype259, _vtype260, _size258 ) = iprot.readMapBegin()
12467 
          for _i262 in xrange(_size258):
12468 
            _key263 = iprot.readString();
12469 
            _val264 = iprot.readString();
12470 
            self.undeliveredOrders[_key263] = _val264
3064 chandransh 12471 
          iprot.readMapEnd()
12472 
        else:
12473 
          iprot.skip(ftype)
1627 ankur.sing 12474 
      else:
12475 
        iprot.skip(ftype)
12476 
      iprot.readFieldEnd()
12477 
    iprot.readStructEnd()
12478 
 
12479 
  def write(self, oprot):
12480 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12481 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12482 
      return
3064 chandransh 12483 
    oprot.writeStructBegin('updateNonDeliveryReason_args')
3431 rajveer 12484 
    if self.providerId is not None:
3064 chandransh 12485 
      oprot.writeFieldBegin('providerId', TType.I64, 1)
12486 
      oprot.writeI64(self.providerId)
1627 ankur.sing 12487 
      oprot.writeFieldEnd()
3431 rajveer 12488 
    if self.undeliveredOrders is not None:
3064 chandransh 12489 
      oprot.writeFieldBegin('undeliveredOrders', TType.MAP, 2)
12490 
      oprot.writeMapBegin(TType.STRING, TType.STRING, len(self.undeliveredOrders))
5031 varun.gupt 12491 
      for kiter265,viter266 in self.undeliveredOrders.items():
12492 
        oprot.writeString(kiter265)
12493 
        oprot.writeString(viter266)
3064 chandransh 12494 
      oprot.writeMapEnd()
12495 
      oprot.writeFieldEnd()
1627 ankur.sing 12496 
    oprot.writeFieldStop()
12497 
    oprot.writeStructEnd()
12498 
 
3431 rajveer 12499 
  def validate(self):
12500 
    return
12501 
 
12502 
 
1627 ankur.sing 12503 
  def __repr__(self):
12504 
    L = ['%s=%r' % (key, value)
12505 
      for key, value in self.__dict__.iteritems()]
12506 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12507 
 
12508 
  def __eq__(self, other):
12509 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12510 
 
12511 
  def __ne__(self, other):
12512 
    return not (self == other)
12513 
 
3064 chandransh 12514 
class updateNonDeliveryReason_result:
1627 ankur.sing 12515 
  """
12516 
  Attributes:
3064 chandransh 12517 
   - ex
1627 ankur.sing 12518 
  """
12519 
 
12520 
  thrift_spec = (
4910 phani.kuma 12521 
    None, # 0
3064 chandransh 12522 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
1627 ankur.sing 12523 
  )
12524 
 
4910 phani.kuma 12525 
  def __init__(self, ex=None,):
3064 chandransh 12526 
    self.ex = ex
1627 ankur.sing 12527 
 
12528 
  def read(self, iprot):
12529 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12530 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12531 
      return
12532 
    iprot.readStructBegin()
12533 
    while True:
12534 
      (fname, ftype, fid) = iprot.readFieldBegin()
12535 
      if ftype == TType.STOP:
12536 
        break
4910 phani.kuma 12537 
      if fid == 1:
12538 
        if ftype == TType.STRUCT:
12539 
          self.ex = TransactionServiceException()
12540 
          self.ex.read(iprot)
12541 
        else:
12542 
          iprot.skip(ftype)
12543 
      else:
12544 
        iprot.skip(ftype)
12545 
      iprot.readFieldEnd()
12546 
    iprot.readStructEnd()
12547 
 
12548 
  def write(self, oprot):
12549 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12550 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12551 
      return
12552 
    oprot.writeStructBegin('updateNonDeliveryReason_result')
12553 
    if self.ex is not None:
12554 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
12555 
      self.ex.write(oprot)
12556 
      oprot.writeFieldEnd()
12557 
    oprot.writeFieldStop()
12558 
    oprot.writeStructEnd()
12559 
 
12560 
  def validate(self):
12561 
    return
12562 
 
12563 
 
12564 
  def __repr__(self):
12565 
    L = ['%s=%r' % (key, value)
12566 
      for key, value in self.__dict__.iteritems()]
12567 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12568 
 
12569 
  def __eq__(self, other):
12570 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12571 
 
12572 
  def __ne__(self, other):
12573 
    return not (self == other)
12574 
 
12575 
class getNonDeliveredOrdersbyCourier_args:
12576 
  """
12577 
  Attributes:
12578 
   - providerId
12579 
  """
12580 
 
12581 
  thrift_spec = (
12582 
    None, # 0
12583 
    (1, TType.I64, 'providerId', None, None, ), # 1
12584 
  )
12585 
 
12586 
  def __init__(self, providerId=None,):
12587 
    self.providerId = providerId
12588 
 
12589 
  def read(self, iprot):
12590 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12591 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12592 
      return
12593 
    iprot.readStructBegin()
12594 
    while True:
12595 
      (fname, ftype, fid) = iprot.readFieldBegin()
12596 
      if ftype == TType.STOP:
12597 
        break
12598 
      if fid == 1:
12599 
        if ftype == TType.I64:
12600 
          self.providerId = iprot.readI64();
12601 
        else:
12602 
          iprot.skip(ftype)
12603 
      else:
12604 
        iprot.skip(ftype)
12605 
      iprot.readFieldEnd()
12606 
    iprot.readStructEnd()
12607 
 
12608 
  def write(self, oprot):
12609 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12610 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12611 
      return
12612 
    oprot.writeStructBegin('getNonDeliveredOrdersbyCourier_args')
12613 
    if self.providerId is not None:
12614 
      oprot.writeFieldBegin('providerId', TType.I64, 1)
12615 
      oprot.writeI64(self.providerId)
12616 
      oprot.writeFieldEnd()
12617 
    oprot.writeFieldStop()
12618 
    oprot.writeStructEnd()
12619 
 
12620 
  def validate(self):
12621 
    return
12622 
 
12623 
 
12624 
  def __repr__(self):
12625 
    L = ['%s=%r' % (key, value)
12626 
      for key, value in self.__dict__.iteritems()]
12627 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12628 
 
12629 
  def __eq__(self, other):
12630 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12631 
 
12632 
  def __ne__(self, other):
12633 
    return not (self == other)
12634 
 
12635 
class getNonDeliveredOrdersbyCourier_result:
12636 
  """
12637 
  Attributes:
12638 
   - success
12639 
  """
12640 
 
12641 
  thrift_spec = (
12642 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
12643 
  )
12644 
 
12645 
  def __init__(self, success=None,):
12646 
    self.success = success
12647 
 
12648 
  def read(self, iprot):
12649 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12650 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12651 
      return
12652 
    iprot.readStructBegin()
12653 
    while True:
12654 
      (fname, ftype, fid) = iprot.readFieldBegin()
12655 
      if ftype == TType.STOP:
12656 
        break
4581 phani.kuma 12657 
      if fid == 0:
12658 
        if ftype == TType.LIST:
12659 
          self.success = []
5031 varun.gupt 12660 
          (_etype270, _size267) = iprot.readListBegin()
12661 
          for _i271 in xrange(_size267):
12662 
            _elem272 = Order()
12663 
            _elem272.read(iprot)
12664 
            self.success.append(_elem272)
4581 phani.kuma 12665 
          iprot.readListEnd()
12666 
        else:
12667 
          iprot.skip(ftype)
4910 phani.kuma 12668 
      else:
12669 
        iprot.skip(ftype)
12670 
      iprot.readFieldEnd()
12671 
    iprot.readStructEnd()
12672 
 
12673 
  def write(self, oprot):
12674 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12675 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12676 
      return
12677 
    oprot.writeStructBegin('getNonDeliveredOrdersbyCourier_result')
12678 
    if self.success is not None:
12679 
      oprot.writeFieldBegin('success', TType.LIST, 0)
12680 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
5031 varun.gupt 12681 
      for iter273 in self.success:
12682 
        iter273.write(oprot)
4910 phani.kuma 12683 
      oprot.writeListEnd()
12684 
      oprot.writeFieldEnd()
12685 
    oprot.writeFieldStop()
12686 
    oprot.writeStructEnd()
12687 
 
12688 
  def validate(self):
12689 
    return
12690 
 
12691 
 
12692 
  def __repr__(self):
12693 
    L = ['%s=%r' % (key, value)
12694 
      for key, value in self.__dict__.iteritems()]
12695 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12696 
 
12697 
  def __eq__(self, other):
12698 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12699 
 
12700 
  def __ne__(self, other):
12701 
    return not (self == other)
12702 
 
12703 
class markOrdersAsLocalConnected_args:
12704 
  """
12705 
  Attributes:
12706 
   - providerId
12707 
   - local_connected_orders
12708 
  """
12709 
 
12710 
  thrift_spec = (
12711 
    None, # 0
12712 
    (1, TType.I64, 'providerId', None, None, ), # 1
12713 
    (2, TType.MAP, 'local_connected_orders', (TType.STRING,None,TType.STRING,None), None, ), # 2
12714 
  )
12715 
 
12716 
  def __init__(self, providerId=None, local_connected_orders=None,):
12717 
    self.providerId = providerId
12718 
    self.local_connected_orders = local_connected_orders
12719 
 
12720 
  def read(self, iprot):
12721 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12722 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12723 
      return
12724 
    iprot.readStructBegin()
12725 
    while True:
12726 
      (fname, ftype, fid) = iprot.readFieldBegin()
12727 
      if ftype == TType.STOP:
12728 
        break
12729 
      if fid == 1:
12730 
        if ftype == TType.I64:
12731 
          self.providerId = iprot.readI64();
12732 
        else:
12733 
          iprot.skip(ftype)
12734 
      elif fid == 2:
12735 
        if ftype == TType.MAP:
12736 
          self.local_connected_orders = {}
5031 varun.gupt 12737 
          (_ktype275, _vtype276, _size274 ) = iprot.readMapBegin()
12738 
          for _i278 in xrange(_size274):
12739 
            _key279 = iprot.readString();
12740 
            _val280 = iprot.readString();
12741 
            self.local_connected_orders[_key279] = _val280
4910 phani.kuma 12742 
          iprot.readMapEnd()
12743 
        else:
12744 
          iprot.skip(ftype)
12745 
      else:
12746 
        iprot.skip(ftype)
12747 
      iprot.readFieldEnd()
12748 
    iprot.readStructEnd()
12749 
 
12750 
  def write(self, oprot):
12751 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12752 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12753 
      return
12754 
    oprot.writeStructBegin('markOrdersAsLocalConnected_args')
12755 
    if self.providerId is not None:
12756 
      oprot.writeFieldBegin('providerId', TType.I64, 1)
12757 
      oprot.writeI64(self.providerId)
12758 
      oprot.writeFieldEnd()
12759 
    if self.local_connected_orders is not None:
12760 
      oprot.writeFieldBegin('local_connected_orders', TType.MAP, 2)
12761 
      oprot.writeMapBegin(TType.STRING, TType.STRING, len(self.local_connected_orders))
5031 varun.gupt 12762 
      for kiter281,viter282 in self.local_connected_orders.items():
12763 
        oprot.writeString(kiter281)
12764 
        oprot.writeString(viter282)
4910 phani.kuma 12765 
      oprot.writeMapEnd()
12766 
      oprot.writeFieldEnd()
12767 
    oprot.writeFieldStop()
12768 
    oprot.writeStructEnd()
12769 
 
12770 
  def validate(self):
12771 
    return
12772 
 
12773 
 
12774 
  def __repr__(self):
12775 
    L = ['%s=%r' % (key, value)
12776 
      for key, value in self.__dict__.iteritems()]
12777 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12778 
 
12779 
  def __eq__(self, other):
12780 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12781 
 
12782 
  def __ne__(self, other):
12783 
    return not (self == other)
12784 
 
12785 
class markOrdersAsLocalConnected_result:
12786 
  """
12787 
  Attributes:
12788 
   - ex
12789 
  """
12790 
 
12791 
  thrift_spec = (
12792 
    None, # 0
12793 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
12794 
  )
12795 
 
12796 
  def __init__(self, ex=None,):
12797 
    self.ex = ex
12798 
 
12799 
  def read(self, iprot):
12800 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12801 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12802 
      return
12803 
    iprot.readStructBegin()
12804 
    while True:
12805 
      (fname, ftype, fid) = iprot.readFieldBegin()
12806 
      if ftype == TType.STOP:
12807 
        break
12808 
      if fid == 1:
3064 chandransh 12809 
        if ftype == TType.STRUCT:
12810 
          self.ex = TransactionServiceException()
12811 
          self.ex.read(iprot)
1627 ankur.sing 12812 
        else:
12813 
          iprot.skip(ftype)
12814 
      else:
12815 
        iprot.skip(ftype)
12816 
      iprot.readFieldEnd()
12817 
    iprot.readStructEnd()
12818 
 
12819 
  def write(self, oprot):
12820 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12821 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12822 
      return
4910 phani.kuma 12823 
    oprot.writeStructBegin('markOrdersAsLocalConnected_result')
12824 
    if self.ex is not None:
12825 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
12826 
      self.ex.write(oprot)
12827 
      oprot.writeFieldEnd()
12828 
    oprot.writeFieldStop()
12829 
    oprot.writeStructEnd()
12830 
 
12831 
  def validate(self):
12832 
    return
12833 
 
12834 
 
12835 
  def __repr__(self):
12836 
    L = ['%s=%r' % (key, value)
12837 
      for key, value in self.__dict__.iteritems()]
12838 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12839 
 
12840 
  def __eq__(self, other):
12841 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12842 
 
12843 
  def __ne__(self, other):
12844 
    return not (self == other)
12845 
 
12846 
class getOrdersNotLocalConnected_args:
12847 
  """
12848 
  Attributes:
12849 
   - providerId
12850 
  """
12851 
 
12852 
  thrift_spec = (
12853 
    None, # 0
12854 
    (1, TType.I64, 'providerId', None, None, ), # 1
12855 
  )
12856 
 
12857 
  def __init__(self, providerId=None,):
12858 
    self.providerId = providerId
12859 
 
12860 
  def read(self, iprot):
12861 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12862 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12863 
      return
12864 
    iprot.readStructBegin()
12865 
    while True:
12866 
      (fname, ftype, fid) = iprot.readFieldBegin()
12867 
      if ftype == TType.STOP:
12868 
        break
12869 
      if fid == 1:
12870 
        if ftype == TType.I64:
12871 
          self.providerId = iprot.readI64();
12872 
        else:
12873 
          iprot.skip(ftype)
12874 
      else:
12875 
        iprot.skip(ftype)
12876 
      iprot.readFieldEnd()
12877 
    iprot.readStructEnd()
12878 
 
12879 
  def write(self, oprot):
12880 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12881 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12882 
      return
12883 
    oprot.writeStructBegin('getOrdersNotLocalConnected_args')
12884 
    if self.providerId is not None:
12885 
      oprot.writeFieldBegin('providerId', TType.I64, 1)
12886 
      oprot.writeI64(self.providerId)
12887 
      oprot.writeFieldEnd()
12888 
    oprot.writeFieldStop()
12889 
    oprot.writeStructEnd()
12890 
 
12891 
  def validate(self):
12892 
    return
12893 
 
12894 
 
12895 
  def __repr__(self):
12896 
    L = ['%s=%r' % (key, value)
12897 
      for key, value in self.__dict__.iteritems()]
12898 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12899 
 
12900 
  def __eq__(self, other):
12901 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12902 
 
12903 
  def __ne__(self, other):
12904 
    return not (self == other)
12905 
 
12906 
class getOrdersNotLocalConnected_result:
12907 
  """
12908 
  Attributes:
12909 
   - success
12910 
  """
12911 
 
12912 
  thrift_spec = (
12913 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
12914 
  )
12915 
 
12916 
  def __init__(self, success=None,):
12917 
    self.success = success
12918 
 
12919 
  def read(self, iprot):
12920 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12921 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12922 
      return
12923 
    iprot.readStructBegin()
12924 
    while True:
12925 
      (fname, ftype, fid) = iprot.readFieldBegin()
12926 
      if ftype == TType.STOP:
12927 
        break
12928 
      if fid == 0:
12929 
        if ftype == TType.LIST:
12930 
          self.success = []
5031 varun.gupt 12931 
          (_etype286, _size283) = iprot.readListBegin()
12932 
          for _i287 in xrange(_size283):
12933 
            _elem288 = Order()
12934 
            _elem288.read(iprot)
12935 
            self.success.append(_elem288)
4910 phani.kuma 12936 
          iprot.readListEnd()
12937 
        else:
12938 
          iprot.skip(ftype)
12939 
      else:
12940 
        iprot.skip(ftype)
12941 
      iprot.readFieldEnd()
12942 
    iprot.readStructEnd()
12943 
 
12944 
  def write(self, oprot):
12945 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12946 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12947 
      return
12948 
    oprot.writeStructBegin('getOrdersNotLocalConnected_result')
4581 phani.kuma 12949 
    if self.success is not None:
12950 
      oprot.writeFieldBegin('success', TType.LIST, 0)
12951 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
5031 varun.gupt 12952 
      for iter289 in self.success:
12953 
        iter289.write(oprot)
4581 phani.kuma 12954 
      oprot.writeListEnd()
12955 
      oprot.writeFieldEnd()
4910 phani.kuma 12956 
    oprot.writeFieldStop()
12957 
    oprot.writeStructEnd()
12958 
 
12959 
  def validate(self):
12960 
    return
12961 
 
12962 
 
12963 
  def __repr__(self):
12964 
    L = ['%s=%r' % (key, value)
12965 
      for key, value in self.__dict__.iteritems()]
12966 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12967 
 
12968 
  def __eq__(self, other):
12969 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12970 
 
12971 
  def __ne__(self, other):
12972 
    return not (self == other)
12973 
 
12974 
class markOrdersAsDestinationCityReached_args:
12975 
  """
12976 
  Attributes:
12977 
   - providerId
12978 
   - destination_city_reached_orders
12979 
  """
12980 
 
12981 
  thrift_spec = (
12982 
    None, # 0
12983 
    (1, TType.I64, 'providerId', None, None, ), # 1
12984 
    (2, TType.MAP, 'destination_city_reached_orders', (TType.STRING,None,TType.STRING,None), None, ), # 2
12985 
  )
12986 
 
12987 
  def __init__(self, providerId=None, destination_city_reached_orders=None,):
12988 
    self.providerId = providerId
12989 
    self.destination_city_reached_orders = destination_city_reached_orders
12990 
 
12991 
  def read(self, iprot):
12992 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12993 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12994 
      return
12995 
    iprot.readStructBegin()
12996 
    while True:
12997 
      (fname, ftype, fid) = iprot.readFieldBegin()
12998 
      if ftype == TType.STOP:
12999 
        break
13000 
      if fid == 1:
13001 
        if ftype == TType.I64:
13002 
          self.providerId = iprot.readI64();
13003 
        else:
13004 
          iprot.skip(ftype)
13005 
      elif fid == 2:
13006 
        if ftype == TType.MAP:
13007 
          self.destination_city_reached_orders = {}
5031 varun.gupt 13008 
          (_ktype291, _vtype292, _size290 ) = iprot.readMapBegin()
13009 
          for _i294 in xrange(_size290):
13010 
            _key295 = iprot.readString();
13011 
            _val296 = iprot.readString();
13012 
            self.destination_city_reached_orders[_key295] = _val296
4910 phani.kuma 13013 
          iprot.readMapEnd()
13014 
        else:
13015 
          iprot.skip(ftype)
13016 
      else:
13017 
        iprot.skip(ftype)
13018 
      iprot.readFieldEnd()
13019 
    iprot.readStructEnd()
13020 
 
13021 
  def write(self, oprot):
13022 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13023 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13024 
      return
13025 
    oprot.writeStructBegin('markOrdersAsDestinationCityReached_args')
13026 
    if self.providerId is not None:
13027 
      oprot.writeFieldBegin('providerId', TType.I64, 1)
13028 
      oprot.writeI64(self.providerId)
13029 
      oprot.writeFieldEnd()
13030 
    if self.destination_city_reached_orders is not None:
13031 
      oprot.writeFieldBegin('destination_city_reached_orders', TType.MAP, 2)
13032 
      oprot.writeMapBegin(TType.STRING, TType.STRING, len(self.destination_city_reached_orders))
5031 varun.gupt 13033 
      for kiter297,viter298 in self.destination_city_reached_orders.items():
13034 
        oprot.writeString(kiter297)
13035 
        oprot.writeString(viter298)
4910 phani.kuma 13036 
      oprot.writeMapEnd()
13037 
      oprot.writeFieldEnd()
13038 
    oprot.writeFieldStop()
13039 
    oprot.writeStructEnd()
13040 
 
13041 
  def validate(self):
13042 
    return
13043 
 
13044 
 
13045 
  def __repr__(self):
13046 
    L = ['%s=%r' % (key, value)
13047 
      for key, value in self.__dict__.iteritems()]
13048 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13049 
 
13050 
  def __eq__(self, other):
13051 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13052 
 
13053 
  def __ne__(self, other):
13054 
    return not (self == other)
13055 
 
13056 
class markOrdersAsDestinationCityReached_result:
13057 
  """
13058 
  Attributes:
13059 
   - ex
13060 
  """
13061 
 
13062 
  thrift_spec = (
13063 
    None, # 0
13064 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
13065 
  )
13066 
 
13067 
  def __init__(self, ex=None,):
13068 
    self.ex = ex
13069 
 
13070 
  def read(self, iprot):
13071 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13072 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13073 
      return
13074 
    iprot.readStructBegin()
13075 
    while True:
13076 
      (fname, ftype, fid) = iprot.readFieldBegin()
13077 
      if ftype == TType.STOP:
13078 
        break
13079 
      if fid == 1:
13080 
        if ftype == TType.STRUCT:
13081 
          self.ex = TransactionServiceException()
13082 
          self.ex.read(iprot)
13083 
        else:
13084 
          iprot.skip(ftype)
13085 
      else:
13086 
        iprot.skip(ftype)
13087 
      iprot.readFieldEnd()
13088 
    iprot.readStructEnd()
13089 
 
13090 
  def write(self, oprot):
13091 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13092 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13093 
      return
13094 
    oprot.writeStructBegin('markOrdersAsDestinationCityReached_result')
3431 rajveer 13095 
    if self.ex is not None:
3064 chandransh 13096 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
13097 
      self.ex.write(oprot)
1627 ankur.sing 13098 
      oprot.writeFieldEnd()
13099 
    oprot.writeFieldStop()
13100 
    oprot.writeStructEnd()
13101 
 
3431 rajveer 13102 
  def validate(self):
13103 
    return
13104 
 
13105 
 
1627 ankur.sing 13106 
  def __repr__(self):
13107 
    L = ['%s=%r' % (key, value)
13108 
      for key, value in self.__dict__.iteritems()]
13109 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13110 
 
13111 
  def __eq__(self, other):
13112 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13113 
 
13114 
  def __ne__(self, other):
13115 
    return not (self == other)
13116 
 
4910 phani.kuma 13117 
class markOrdersAsFirstDeliveryAttempted_args:
13118 
  """
13119 
  Attributes:
13120 
   - providerId
13121 
   - first_atdl_orders
13122 
  """
13123 
 
13124 
  thrift_spec = (
13125 
    None, # 0
13126 
    (1, TType.I64, 'providerId', None, None, ), # 1
13127 
    (2, TType.MAP, 'first_atdl_orders', (TType.STRING,None,TType.STRING,None), None, ), # 2
13128 
  )
13129 
 
13130 
  def __init__(self, providerId=None, first_atdl_orders=None,):
13131 
    self.providerId = providerId
13132 
    self.first_atdl_orders = first_atdl_orders
13133 
 
13134 
  def read(self, iprot):
13135 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13136 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13137 
      return
13138 
    iprot.readStructBegin()
13139 
    while True:
13140 
      (fname, ftype, fid) = iprot.readFieldBegin()
13141 
      if ftype == TType.STOP:
13142 
        break
13143 
      if fid == 1:
13144 
        if ftype == TType.I64:
13145 
          self.providerId = iprot.readI64();
13146 
        else:
13147 
          iprot.skip(ftype)
13148 
      elif fid == 2:
13149 
        if ftype == TType.MAP:
13150 
          self.first_atdl_orders = {}
5031 varun.gupt 13151 
          (_ktype300, _vtype301, _size299 ) = iprot.readMapBegin()
13152 
          for _i303 in xrange(_size299):
13153 
            _key304 = iprot.readString();
13154 
            _val305 = iprot.readString();
13155 
            self.first_atdl_orders[_key304] = _val305
4910 phani.kuma 13156 
          iprot.readMapEnd()
13157 
        else:
13158 
          iprot.skip(ftype)
13159 
      else:
13160 
        iprot.skip(ftype)
13161 
      iprot.readFieldEnd()
13162 
    iprot.readStructEnd()
13163 
 
13164 
  def write(self, oprot):
13165 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13166 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13167 
      return
13168 
    oprot.writeStructBegin('markOrdersAsFirstDeliveryAttempted_args')
13169 
    if self.providerId is not None:
13170 
      oprot.writeFieldBegin('providerId', TType.I64, 1)
13171 
      oprot.writeI64(self.providerId)
13172 
      oprot.writeFieldEnd()
13173 
    if self.first_atdl_orders is not None:
13174 
      oprot.writeFieldBegin('first_atdl_orders', TType.MAP, 2)
13175 
      oprot.writeMapBegin(TType.STRING, TType.STRING, len(self.first_atdl_orders))
5031 varun.gupt 13176 
      for kiter306,viter307 in self.first_atdl_orders.items():
13177 
        oprot.writeString(kiter306)
13178 
        oprot.writeString(viter307)
4910 phani.kuma 13179 
      oprot.writeMapEnd()
13180 
      oprot.writeFieldEnd()
13181 
    oprot.writeFieldStop()
13182 
    oprot.writeStructEnd()
13183 
 
13184 
  def validate(self):
13185 
    return
13186 
 
13187 
 
13188 
  def __repr__(self):
13189 
    L = ['%s=%r' % (key, value)
13190 
      for key, value in self.__dict__.iteritems()]
13191 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13192 
 
13193 
  def __eq__(self, other):
13194 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13195 
 
13196 
  def __ne__(self, other):
13197 
    return not (self == other)
13198 
 
13199 
class markOrdersAsFirstDeliveryAttempted_result:
13200 
  """
13201 
  Attributes:
13202 
   - ex
13203 
  """
13204 
 
13205 
  thrift_spec = (
13206 
    None, # 0
13207 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
13208 
  )
13209 
 
13210 
  def __init__(self, ex=None,):
13211 
    self.ex = ex
13212 
 
13213 
  def read(self, iprot):
13214 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13215 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13216 
      return
13217 
    iprot.readStructBegin()
13218 
    while True:
13219 
      (fname, ftype, fid) = iprot.readFieldBegin()
13220 
      if ftype == TType.STOP:
13221 
        break
13222 
      if fid == 1:
13223 
        if ftype == TType.STRUCT:
13224 
          self.ex = TransactionServiceException()
13225 
          self.ex.read(iprot)
13226 
        else:
13227 
          iprot.skip(ftype)
13228 
      else:
13229 
        iprot.skip(ftype)
13230 
      iprot.readFieldEnd()
13231 
    iprot.readStructEnd()
13232 
 
13233 
  def write(self, oprot):
13234 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13235 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13236 
      return
13237 
    oprot.writeStructBegin('markOrdersAsFirstDeliveryAttempted_result')
13238 
    if self.ex is not None:
13239 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
13240 
      self.ex.write(oprot)
13241 
      oprot.writeFieldEnd()
13242 
    oprot.writeFieldStop()
13243 
    oprot.writeStructEnd()
13244 
 
13245 
  def validate(self):
13246 
    return
13247 
 
13248 
 
13249 
  def __repr__(self):
13250 
    L = ['%s=%r' % (key, value)
13251 
      for key, value in self.__dict__.iteritems()]
13252 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13253 
 
13254 
  def __eq__(self, other):
13255 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13256 
 
13257 
  def __ne__(self, other):
13258 
    return not (self == other)
13259 
 
3064 chandransh 13260 
class getUndeliveredOrders_args:
1886 ankur.sing 13261 
  """
13262 
  Attributes:
3064 chandransh 13263 
   - providerId
13264 
   - warehouseId
1886 ankur.sing 13265 
  """
1627 ankur.sing 13266 
 
1886 ankur.sing 13267 
  thrift_spec = (
13268 
    None, # 0
3064 chandransh 13269 
    (1, TType.I64, 'providerId', None, None, ), # 1
13270 
    (2, TType.I64, 'warehouseId', None, None, ), # 2
1886 ankur.sing 13271 
  )
13272 
 
3064 chandransh 13273 
  def __init__(self, providerId=None, warehouseId=None,):
13274 
    self.providerId = providerId
13275 
    self.warehouseId = warehouseId
1886 ankur.sing 13276 
 
13277 
  def read(self, iprot):
13278 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13279 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13280 
      return
13281 
    iprot.readStructBegin()
13282 
    while True:
13283 
      (fname, ftype, fid) = iprot.readFieldBegin()
13284 
      if ftype == TType.STOP:
13285 
        break
13286 
      if fid == 1:
13287 
        if ftype == TType.I64:
3064 chandransh 13288 
          self.providerId = iprot.readI64();
1886 ankur.sing 13289 
        else:
13290 
          iprot.skip(ftype)
3064 chandransh 13291 
      elif fid == 2:
13292 
        if ftype == TType.I64:
13293 
          self.warehouseId = iprot.readI64();
13294 
        else:
13295 
          iprot.skip(ftype)
1886 ankur.sing 13296 
      else:
13297 
        iprot.skip(ftype)
13298 
      iprot.readFieldEnd()
13299 
    iprot.readStructEnd()
13300 
 
13301 
  def write(self, oprot):
13302 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13303 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13304 
      return
3064 chandransh 13305 
    oprot.writeStructBegin('getUndeliveredOrders_args')
3431 rajveer 13306 
    if self.providerId is not None:
3064 chandransh 13307 
      oprot.writeFieldBegin('providerId', TType.I64, 1)
13308 
      oprot.writeI64(self.providerId)
1886 ankur.sing 13309 
      oprot.writeFieldEnd()
3431 rajveer 13310 
    if self.warehouseId is not None:
3064 chandransh 13311 
      oprot.writeFieldBegin('warehouseId', TType.I64, 2)
13312 
      oprot.writeI64(self.warehouseId)
13313 
      oprot.writeFieldEnd()
1886 ankur.sing 13314 
    oprot.writeFieldStop()
13315 
    oprot.writeStructEnd()
13316 
 
3431 rajveer 13317 
  def validate(self):
13318 
    return
13319 
 
13320 
 
1886 ankur.sing 13321 
  def __repr__(self):
13322 
    L = ['%s=%r' % (key, value)
13323 
      for key, value in self.__dict__.iteritems()]
13324 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13325 
 
13326 
  def __eq__(self, other):
13327 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13328 
 
13329 
  def __ne__(self, other):
13330 
    return not (self == other)
13331 
 
3064 chandransh 13332 
class getUndeliveredOrders_result:
1886 ankur.sing 13333 
  """
13334 
  Attributes:
13335 
   - success
13336 
  """
13337 
 
13338 
  thrift_spec = (
13339 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
13340 
  )
13341 
 
13342 
  def __init__(self, success=None,):
13343 
    self.success = success
13344 
 
13345 
  def read(self, iprot):
13346 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13347 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13348 
      return
13349 
    iprot.readStructBegin()
13350 
    while True:
13351 
      (fname, ftype, fid) = iprot.readFieldBegin()
13352 
      if ftype == TType.STOP:
13353 
        break
13354 
      if fid == 0:
13355 
        if ftype == TType.LIST:
13356 
          self.success = []
5031 varun.gupt 13357 
          (_etype311, _size308) = iprot.readListBegin()
13358 
          for _i312 in xrange(_size308):
13359 
            _elem313 = Order()
13360 
            _elem313.read(iprot)
13361 
            self.success.append(_elem313)
1886 ankur.sing 13362 
          iprot.readListEnd()
13363 
        else:
13364 
          iprot.skip(ftype)
13365 
      else:
13366 
        iprot.skip(ftype)
13367 
      iprot.readFieldEnd()
13368 
    iprot.readStructEnd()
13369 
 
13370 
  def write(self, oprot):
13371 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13372 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13373 
      return
3064 chandransh 13374 
    oprot.writeStructBegin('getUndeliveredOrders_result')
3431 rajveer 13375 
    if self.success is not None:
1886 ankur.sing 13376 
      oprot.writeFieldBegin('success', TType.LIST, 0)
13377 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
5031 varun.gupt 13378 
      for iter314 in self.success:
13379 
        iter314.write(oprot)
1886 ankur.sing 13380 
      oprot.writeListEnd()
13381 
      oprot.writeFieldEnd()
13382 
    oprot.writeFieldStop()
13383 
    oprot.writeStructEnd()
13384 
 
3431 rajveer 13385 
  def validate(self):
13386 
    return
13387 
 
13388 
 
1886 ankur.sing 13389 
  def __repr__(self):
13390 
    L = ['%s=%r' % (key, value)
13391 
      for key, value in self.__dict__.iteritems()]
13392 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13393 
 
13394 
  def __eq__(self, other):
13395 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13396 
 
13397 
  def __ne__(self, other):
13398 
    return not (self == other)
13399 
 
4783 phani.kuma 13400 
class getUndeliveredOrdersExpectedDeliveryDateNotMet_args:
13401 
 
13402 
  thrift_spec = (
13403 
  )
13404 
 
13405 
  def read(self, iprot):
13406 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13407 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13408 
      return
13409 
    iprot.readStructBegin()
13410 
    while True:
13411 
      (fname, ftype, fid) = iprot.readFieldBegin()
13412 
      if ftype == TType.STOP:
13413 
        break
13414 
      else:
13415 
        iprot.skip(ftype)
13416 
      iprot.readFieldEnd()
13417 
    iprot.readStructEnd()
13418 
 
13419 
  def write(self, oprot):
13420 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13421 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13422 
      return
13423 
    oprot.writeStructBegin('getUndeliveredOrdersExpectedDeliveryDateNotMet_args')
13424 
    oprot.writeFieldStop()
13425 
    oprot.writeStructEnd()
13426 
 
13427 
  def validate(self):
13428 
    return
13429 
 
13430 
 
13431 
  def __repr__(self):
13432 
    L = ['%s=%r' % (key, value)
13433 
      for key, value in self.__dict__.iteritems()]
13434 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13435 
 
13436 
  def __eq__(self, other):
13437 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13438 
 
13439 
  def __ne__(self, other):
13440 
    return not (self == other)
13441 
 
13442 
class getUndeliveredOrdersExpectedDeliveryDateNotMet_result:
13443 
  """
13444 
  Attributes:
13445 
   - success
13446 
  """
13447 
 
13448 
  thrift_spec = (
13449 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
13450 
  )
13451 
 
13452 
  def __init__(self, success=None,):
13453 
    self.success = success
13454 
 
13455 
  def read(self, iprot):
13456 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13457 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13458 
      return
13459 
    iprot.readStructBegin()
13460 
    while True:
13461 
      (fname, ftype, fid) = iprot.readFieldBegin()
13462 
      if ftype == TType.STOP:
13463 
        break
13464 
      if fid == 0:
13465 
        if ftype == TType.LIST:
13466 
          self.success = []
5031 varun.gupt 13467 
          (_etype318, _size315) = iprot.readListBegin()
13468 
          for _i319 in xrange(_size315):
13469 
            _elem320 = Order()
13470 
            _elem320.read(iprot)
13471 
            self.success.append(_elem320)
4783 phani.kuma 13472 
          iprot.readListEnd()
13473 
        else:
13474 
          iprot.skip(ftype)
13475 
      else:
13476 
        iprot.skip(ftype)
13477 
      iprot.readFieldEnd()
13478 
    iprot.readStructEnd()
13479 
 
13480 
  def write(self, oprot):
13481 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13482 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13483 
      return
13484 
    oprot.writeStructBegin('getUndeliveredOrdersExpectedDeliveryDateNotMet_result')
13485 
    if self.success is not None:
13486 
      oprot.writeFieldBegin('success', TType.LIST, 0)
13487 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
5031 varun.gupt 13488 
      for iter321 in self.success:
13489 
        iter321.write(oprot)
4783 phani.kuma 13490 
      oprot.writeListEnd()
13491 
      oprot.writeFieldEnd()
13492 
    oprot.writeFieldStop()
13493 
    oprot.writeStructEnd()
13494 
 
13495 
  def validate(self):
13496 
    return
13497 
 
13498 
 
13499 
  def __repr__(self):
13500 
    L = ['%s=%r' % (key, value)
13501 
      for key, value in self.__dict__.iteritems()]
13502 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13503 
 
13504 
  def __eq__(self, other):
13505 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13506 
 
13507 
  def __ne__(self, other):
13508 
    return not (self == other)
13509 
 
2536 chandransh 13510 
class toggleDOAFlag_args:
13511 
  """
13512 
  Attributes:
13513 
   - orderId
13514 
  """
1886 ankur.sing 13515 
 
2536 chandransh 13516 
  thrift_spec = (
13517 
    None, # 0
13518 
    (1, TType.I64, 'orderId', None, None, ), # 1
13519 
  )
13520 
 
13521 
  def __init__(self, orderId=None,):
13522 
    self.orderId = orderId
13523 
 
13524 
  def read(self, iprot):
13525 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13526 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13527 
      return
13528 
    iprot.readStructBegin()
13529 
    while True:
13530 
      (fname, ftype, fid) = iprot.readFieldBegin()
13531 
      if ftype == TType.STOP:
13532 
        break
13533 
      if fid == 1:
13534 
        if ftype == TType.I64:
13535 
          self.orderId = iprot.readI64();
13536 
        else:
13537 
          iprot.skip(ftype)
13538 
      else:
13539 
        iprot.skip(ftype)
13540 
      iprot.readFieldEnd()
13541 
    iprot.readStructEnd()
13542 
 
13543 
  def write(self, oprot):
13544 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13545 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13546 
      return
13547 
    oprot.writeStructBegin('toggleDOAFlag_args')
3431 rajveer 13548 
    if self.orderId is not None:
2536 chandransh 13549 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
13550 
      oprot.writeI64(self.orderId)
13551 
      oprot.writeFieldEnd()
13552 
    oprot.writeFieldStop()
13553 
    oprot.writeStructEnd()
13554 
 
3431 rajveer 13555 
  def validate(self):
13556 
    return
13557 
 
13558 
 
2536 chandransh 13559 
  def __repr__(self):
13560 
    L = ['%s=%r' % (key, value)
13561 
      for key, value in self.__dict__.iteritems()]
13562 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13563 
 
13564 
  def __eq__(self, other):
13565 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13566 
 
13567 
  def __ne__(self, other):
13568 
    return not (self == other)
13569 
 
13570 
class toggleDOAFlag_result:
13571 
  """
13572 
  Attributes:
13573 
   - success
13574 
   - ex
13575 
  """
13576 
 
13577 
  thrift_spec = (
13578 
    (0, TType.BOOL, 'success', None, None, ), # 0
13579 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
13580 
  )
13581 
 
13582 
  def __init__(self, success=None, ex=None,):
13583 
    self.success = success
13584 
    self.ex = ex
13585 
 
13586 
  def read(self, iprot):
13587 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13588 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13589 
      return
13590 
    iprot.readStructBegin()
13591 
    while True:
13592 
      (fname, ftype, fid) = iprot.readFieldBegin()
13593 
      if ftype == TType.STOP:
13594 
        break
13595 
      if fid == 0:
13596 
        if ftype == TType.BOOL:
13597 
          self.success = iprot.readBool();
13598 
        else:
13599 
          iprot.skip(ftype)
13600 
      elif fid == 1:
13601 
        if ftype == TType.STRUCT:
13602 
          self.ex = TransactionServiceException()
13603 
          self.ex.read(iprot)
13604 
        else:
13605 
          iprot.skip(ftype)
13606 
      else:
13607 
        iprot.skip(ftype)
13608 
      iprot.readFieldEnd()
13609 
    iprot.readStructEnd()
13610 
 
13611 
  def write(self, oprot):
13612 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13613 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13614 
      return
13615 
    oprot.writeStructBegin('toggleDOAFlag_result')
3431 rajveer 13616 
    if self.success is not None:
2536 chandransh 13617 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
13618 
      oprot.writeBool(self.success)
13619 
      oprot.writeFieldEnd()
3431 rajveer 13620 
    if self.ex is not None:
2536 chandransh 13621 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
13622 
      self.ex.write(oprot)
13623 
      oprot.writeFieldEnd()
13624 
    oprot.writeFieldStop()
13625 
    oprot.writeStructEnd()
13626 
 
3431 rajveer 13627 
  def validate(self):
13628 
    return
13629 
 
13630 
 
2536 chandransh 13631 
  def __repr__(self):
13632 
    L = ['%s=%r' % (key, value)
13633 
      for key, value in self.__dict__.iteritems()]
13634 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13635 
 
13636 
  def __eq__(self, other):
13637 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13638 
 
13639 
  def __ne__(self, other):
13640 
    return not (self == other)
13641 
 
4712 rajveer 13642 
class markOrderAsDelivered_args:
13643 
  """
13644 
  Attributes:
13645 
   - orderId
13646 
   - deliveryTimestamp
13647 
   - receiver
13648 
  """
13649 
 
13650 
  thrift_spec = None
13651 
  def __init__(self, orderId=None, deliveryTimestamp=None, receiver=None,):
13652 
    self.orderId = orderId
13653 
    self.deliveryTimestamp = deliveryTimestamp
13654 
    self.receiver = receiver
13655 
 
13656 
  def read(self, iprot):
13657 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13658 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13659 
      return
13660 
    iprot.readStructBegin()
13661 
    while True:
13662 
      (fname, ftype, fid) = iprot.readFieldBegin()
13663 
      if ftype == TType.STOP:
13664 
        break
13665 
      if fid == 1:
13666 
        if ftype == TType.I64:
13667 
          self.orderId = iprot.readI64();
13668 
        else:
13669 
          iprot.skip(ftype)
13670 
      elif fid == 2:
13671 
        if ftype == TType.I64:
13672 
          self.deliveryTimestamp = iprot.readI64();
13673 
        else:
13674 
          iprot.skip(ftype)
13675 
      elif fid == -1:
13676 
        if ftype == TType.STRING:
13677 
          self.receiver = iprot.readString();
13678 
        else:
13679 
          iprot.skip(ftype)
13680 
      else:
13681 
        iprot.skip(ftype)
13682 
      iprot.readFieldEnd()
13683 
    iprot.readStructEnd()
13684 
 
13685 
  def write(self, oprot):
13686 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13687 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13688 
      return
13689 
    oprot.writeStructBegin('markOrderAsDelivered_args')
13690 
    if self.receiver is not None:
13691 
      oprot.writeFieldBegin('receiver', TType.STRING, -1)
13692 
      oprot.writeString(self.receiver)
13693 
      oprot.writeFieldEnd()
13694 
    if self.orderId is not None:
13695 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
13696 
      oprot.writeI64(self.orderId)
13697 
      oprot.writeFieldEnd()
13698 
    if self.deliveryTimestamp is not None:
13699 
      oprot.writeFieldBegin('deliveryTimestamp', TType.I64, 2)
13700 
      oprot.writeI64(self.deliveryTimestamp)
13701 
      oprot.writeFieldEnd()
13702 
    oprot.writeFieldStop()
13703 
    oprot.writeStructEnd()
13704 
 
13705 
  def validate(self):
13706 
    return
13707 
 
13708 
 
13709 
  def __repr__(self):
13710 
    L = ['%s=%r' % (key, value)
13711 
      for key, value in self.__dict__.iteritems()]
13712 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13713 
 
13714 
  def __eq__(self, other):
13715 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13716 
 
13717 
  def __ne__(self, other):
13718 
    return not (self == other)
13719 
 
13720 
class markOrderAsDelivered_result:
13721 
  """
13722 
  Attributes:
13723 
   - ex
13724 
  """
13725 
 
13726 
  thrift_spec = (
13727 
    None, # 0
13728 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
13729 
  )
13730 
 
13731 
  def __init__(self, ex=None,):
13732 
    self.ex = ex
13733 
 
13734 
  def read(self, iprot):
13735 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13736 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13737 
      return
13738 
    iprot.readStructBegin()
13739 
    while True:
13740 
      (fname, ftype, fid) = iprot.readFieldBegin()
13741 
      if ftype == TType.STOP:
13742 
        break
13743 
      if fid == 1:
13744 
        if ftype == TType.STRUCT:
13745 
          self.ex = TransactionServiceException()
13746 
          self.ex.read(iprot)
13747 
        else:
13748 
          iprot.skip(ftype)
13749 
      else:
13750 
        iprot.skip(ftype)
13751 
      iprot.readFieldEnd()
13752 
    iprot.readStructEnd()
13753 
 
13754 
  def write(self, oprot):
13755 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13756 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13757 
      return
13758 
    oprot.writeStructBegin('markOrderAsDelivered_result')
13759 
    if self.ex is not None:
13760 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
13761 
      self.ex.write(oprot)
13762 
      oprot.writeFieldEnd()
13763 
    oprot.writeFieldStop()
13764 
    oprot.writeStructEnd()
13765 
 
13766 
  def validate(self):
13767 
    return
13768 
 
13769 
 
13770 
  def __repr__(self):
13771 
    L = ['%s=%r' % (key, value)
13772 
      for key, value in self.__dict__.iteritems()]
13773 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13774 
 
13775 
  def __eq__(self, other):
13776 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13777 
 
13778 
  def __ne__(self, other):
13779 
    return not (self == other)
13780 
 
4454 rajveer 13781 
class markOrderDoaRequestReceived_args:
13782 
  """
13783 
  Attributes:
13784 
   - orderId
13785 
  """
13786 
 
13787 
  thrift_spec = (
13788 
    None, # 0
13789 
    (1, TType.I64, 'orderId', None, None, ), # 1
13790 
  )
13791 
 
13792 
  def __init__(self, orderId=None,):
13793 
    self.orderId = orderId
13794 
 
13795 
  def read(self, iprot):
13796 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13797 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13798 
      return
13799 
    iprot.readStructBegin()
13800 
    while True:
13801 
      (fname, ftype, fid) = iprot.readFieldBegin()
13802 
      if ftype == TType.STOP:
13803 
        break
13804 
      if fid == 1:
13805 
        if ftype == TType.I64:
13806 
          self.orderId = iprot.readI64();
13807 
        else:
13808 
          iprot.skip(ftype)
13809 
      else:
13810 
        iprot.skip(ftype)
13811 
      iprot.readFieldEnd()
13812 
    iprot.readStructEnd()
13813 
 
13814 
  def write(self, oprot):
13815 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13816 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13817 
      return
13818 
    oprot.writeStructBegin('markOrderDoaRequestReceived_args')
13819 
    if self.orderId is not None:
13820 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
13821 
      oprot.writeI64(self.orderId)
13822 
      oprot.writeFieldEnd()
13823 
    oprot.writeFieldStop()
13824 
    oprot.writeStructEnd()
13825 
 
13826 
  def validate(self):
13827 
    return
13828 
 
13829 
 
13830 
  def __repr__(self):
13831 
    L = ['%s=%r' % (key, value)
13832 
      for key, value in self.__dict__.iteritems()]
13833 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13834 
 
13835 
  def __eq__(self, other):
13836 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13837 
 
13838 
  def __ne__(self, other):
13839 
    return not (self == other)
13840 
 
13841 
class markOrderDoaRequestReceived_result:
13842 
  """
13843 
  Attributes:
13844 
   - success
13845 
   - ex
13846 
  """
13847 
 
13848 
  thrift_spec = (
13849 
    (0, TType.BOOL, 'success', None, None, ), # 0
13850 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
13851 
  )
13852 
 
13853 
  def __init__(self, success=None, ex=None,):
13854 
    self.success = success
13855 
    self.ex = ex
13856 
 
13857 
  def read(self, iprot):
13858 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13859 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13860 
      return
13861 
    iprot.readStructBegin()
13862 
    while True:
13863 
      (fname, ftype, fid) = iprot.readFieldBegin()
13864 
      if ftype == TType.STOP:
13865 
        break
13866 
      if fid == 0:
13867 
        if ftype == TType.BOOL:
13868 
          self.success = iprot.readBool();
13869 
        else:
13870 
          iprot.skip(ftype)
13871 
      elif fid == 1:
13872 
        if ftype == TType.STRUCT:
13873 
          self.ex = TransactionServiceException()
13874 
          self.ex.read(iprot)
13875 
        else:
13876 
          iprot.skip(ftype)
13877 
      else:
13878 
        iprot.skip(ftype)
13879 
      iprot.readFieldEnd()
13880 
    iprot.readStructEnd()
13881 
 
13882 
  def write(self, oprot):
13883 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13884 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13885 
      return
13886 
    oprot.writeStructBegin('markOrderDoaRequestReceived_result')
13887 
    if self.success is not None:
13888 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
13889 
      oprot.writeBool(self.success)
13890 
      oprot.writeFieldEnd()
13891 
    if self.ex is not None:
13892 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
13893 
      self.ex.write(oprot)
13894 
      oprot.writeFieldEnd()
13895 
    oprot.writeFieldStop()
13896 
    oprot.writeStructEnd()
13897 
 
13898 
  def validate(self):
13899 
    return
13900 
 
13901 
 
13902 
  def __repr__(self):
13903 
    L = ['%s=%r' % (key, value)
13904 
      for key, value in self.__dict__.iteritems()]
13905 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13906 
 
13907 
  def __eq__(self, other):
13908 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13909 
 
13910 
  def __ne__(self, other):
13911 
    return not (self == other)
13912 
 
13913 
class markOrderDoaRequestAuthorized_args:
13914 
  """
13915 
  Attributes:
13916 
   - orderId
13917 
   - isAuthorized
13918 
  """
13919 
 
13920 
  thrift_spec = (
13921 
    None, # 0
13922 
    (1, TType.I64, 'orderId', None, None, ), # 1
13923 
    (2, TType.BOOL, 'isAuthorized', None, None, ), # 2
13924 
  )
13925 
 
13926 
  def __init__(self, orderId=None, isAuthorized=None,):
13927 
    self.orderId = orderId
13928 
    self.isAuthorized = isAuthorized
13929 
 
13930 
  def read(self, iprot):
13931 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13932 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13933 
      return
13934 
    iprot.readStructBegin()
13935 
    while True:
13936 
      (fname, ftype, fid) = iprot.readFieldBegin()
13937 
      if ftype == TType.STOP:
13938 
        break
13939 
      if fid == 1:
13940 
        if ftype == TType.I64:
13941 
          self.orderId = iprot.readI64();
13942 
        else:
13943 
          iprot.skip(ftype)
13944 
      elif fid == 2:
13945 
        if ftype == TType.BOOL:
13946 
          self.isAuthorized = iprot.readBool();
13947 
        else:
13948 
          iprot.skip(ftype)
13949 
      else:
13950 
        iprot.skip(ftype)
13951 
      iprot.readFieldEnd()
13952 
    iprot.readStructEnd()
13953 
 
13954 
  def write(self, oprot):
13955 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13956 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13957 
      return
13958 
    oprot.writeStructBegin('markOrderDoaRequestAuthorized_args')
13959 
    if self.orderId is not None:
13960 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
13961 
      oprot.writeI64(self.orderId)
13962 
      oprot.writeFieldEnd()
13963 
    if self.isAuthorized is not None:
13964 
      oprot.writeFieldBegin('isAuthorized', TType.BOOL, 2)
13965 
      oprot.writeBool(self.isAuthorized)
13966 
      oprot.writeFieldEnd()
13967 
    oprot.writeFieldStop()
13968 
    oprot.writeStructEnd()
13969 
 
13970 
  def validate(self):
13971 
    return
13972 
 
13973 
 
13974 
  def __repr__(self):
13975 
    L = ['%s=%r' % (key, value)
13976 
      for key, value in self.__dict__.iteritems()]
13977 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13978 
 
13979 
  def __eq__(self, other):
13980 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13981 
 
13982 
  def __ne__(self, other):
13983 
    return not (self == other)
13984 
 
13985 
class markOrderDoaRequestAuthorized_result:
13986 
  """
13987 
  Attributes:
13988 
   - success
13989 
   - ex
13990 
  """
13991 
 
13992 
  thrift_spec = (
13993 
    (0, TType.BOOL, 'success', None, None, ), # 0
13994 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
13995 
  )
13996 
 
13997 
  def __init__(self, success=None, ex=None,):
13998 
    self.success = success
13999 
    self.ex = ex
14000 
 
14001 
  def read(self, iprot):
14002 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14003 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14004 
      return
14005 
    iprot.readStructBegin()
14006 
    while True:
14007 
      (fname, ftype, fid) = iprot.readFieldBegin()
14008 
      if ftype == TType.STOP:
14009 
        break
14010 
      if fid == 0:
14011 
        if ftype == TType.BOOL:
14012 
          self.success = iprot.readBool();
14013 
        else:
14014 
          iprot.skip(ftype)
14015 
      elif fid == 1:
14016 
        if ftype == TType.STRUCT:
14017 
          self.ex = TransactionServiceException()
14018 
          self.ex.read(iprot)
14019 
        else:
14020 
          iprot.skip(ftype)
14021 
      else:
14022 
        iprot.skip(ftype)
14023 
      iprot.readFieldEnd()
14024 
    iprot.readStructEnd()
14025 
 
14026 
  def write(self, oprot):
14027 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14028 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14029 
      return
14030 
    oprot.writeStructBegin('markOrderDoaRequestAuthorized_result')
14031 
    if self.success is not None:
14032 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
14033 
      oprot.writeBool(self.success)
14034 
      oprot.writeFieldEnd()
14035 
    if self.ex is not None:
14036 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
14037 
      self.ex.write(oprot)
14038 
      oprot.writeFieldEnd()
14039 
    oprot.writeFieldStop()
14040 
    oprot.writeStructEnd()
14041 
 
14042 
  def validate(self):
14043 
    return
14044 
 
14045 
 
14046 
  def __repr__(self):
14047 
    L = ['%s=%r' % (key, value)
14048 
      for key, value in self.__dict__.iteritems()]
14049 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14050 
 
14051 
  def __eq__(self, other):
14052 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14053 
 
14054 
  def __ne__(self, other):
14055 
    return not (self == other)
14056 
 
4488 rajveer 14057 
class markOrderReturnRequestReceived_args:
14058 
  """
14059 
  Attributes:
14060 
   - orderId
14061 
  """
14062 
 
14063 
  thrift_spec = (
14064 
    None, # 0
14065 
    (1, TType.I64, 'orderId', None, None, ), # 1
14066 
  )
14067 
 
14068 
  def __init__(self, orderId=None,):
14069 
    self.orderId = orderId
14070 
 
14071 
  def read(self, iprot):
14072 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14073 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14074 
      return
14075 
    iprot.readStructBegin()
14076 
    while True:
14077 
      (fname, ftype, fid) = iprot.readFieldBegin()
14078 
      if ftype == TType.STOP:
14079 
        break
14080 
      if fid == 1:
14081 
        if ftype == TType.I64:
14082 
          self.orderId = iprot.readI64();
14083 
        else:
14084 
          iprot.skip(ftype)
14085 
      else:
14086 
        iprot.skip(ftype)
14087 
      iprot.readFieldEnd()
14088 
    iprot.readStructEnd()
14089 
 
14090 
  def write(self, oprot):
14091 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14092 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14093 
      return
14094 
    oprot.writeStructBegin('markOrderReturnRequestReceived_args')
14095 
    if self.orderId is not None:
14096 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
14097 
      oprot.writeI64(self.orderId)
14098 
      oprot.writeFieldEnd()
14099 
    oprot.writeFieldStop()
14100 
    oprot.writeStructEnd()
14101 
 
14102 
  def validate(self):
14103 
    return
14104 
 
14105 
 
14106 
  def __repr__(self):
14107 
    L = ['%s=%r' % (key, value)
14108 
      for key, value in self.__dict__.iteritems()]
14109 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14110 
 
14111 
  def __eq__(self, other):
14112 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14113 
 
14114 
  def __ne__(self, other):
14115 
    return not (self == other)
14116 
 
14117 
class markOrderReturnRequestReceived_result:
14118 
  """
14119 
  Attributes:
14120 
   - success
14121 
   - ex
14122 
  """
14123 
 
14124 
  thrift_spec = (
14125 
    (0, TType.BOOL, 'success', None, None, ), # 0
14126 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
14127 
  )
14128 
 
14129 
  def __init__(self, success=None, ex=None,):
14130 
    self.success = success
14131 
    self.ex = ex
14132 
 
14133 
  def read(self, iprot):
14134 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14135 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14136 
      return
14137 
    iprot.readStructBegin()
14138 
    while True:
14139 
      (fname, ftype, fid) = iprot.readFieldBegin()
14140 
      if ftype == TType.STOP:
14141 
        break
14142 
      if fid == 0:
14143 
        if ftype == TType.BOOL:
14144 
          self.success = iprot.readBool();
14145 
        else:
14146 
          iprot.skip(ftype)
14147 
      elif fid == 1:
14148 
        if ftype == TType.STRUCT:
14149 
          self.ex = TransactionServiceException()
14150 
          self.ex.read(iprot)
14151 
        else:
14152 
          iprot.skip(ftype)
14153 
      else:
14154 
        iprot.skip(ftype)
14155 
      iprot.readFieldEnd()
14156 
    iprot.readStructEnd()
14157 
 
14158 
  def write(self, oprot):
14159 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14160 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14161 
      return
14162 
    oprot.writeStructBegin('markOrderReturnRequestReceived_result')
14163 
    if self.success is not None:
14164 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
14165 
      oprot.writeBool(self.success)
14166 
      oprot.writeFieldEnd()
14167 
    if self.ex is not None:
14168 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
14169 
      self.ex.write(oprot)
14170 
      oprot.writeFieldEnd()
14171 
    oprot.writeFieldStop()
14172 
    oprot.writeStructEnd()
14173 
 
14174 
  def validate(self):
14175 
    return
14176 
 
14177 
 
14178 
  def __repr__(self):
14179 
    L = ['%s=%r' % (key, value)
14180 
      for key, value in self.__dict__.iteritems()]
14181 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14182 
 
14183 
  def __eq__(self, other):
14184 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14185 
 
14186 
  def __ne__(self, other):
14187 
    return not (self == other)
14188 
 
14189 
class markOrderReturnRequestAuthorized_args:
14190 
  """
14191 
  Attributes:
14192 
   - orderId
14193 
   - isAuthorized
14194 
  """
14195 
 
14196 
  thrift_spec = (
14197 
    None, # 0
14198 
    (1, TType.I64, 'orderId', None, None, ), # 1
14199 
    (2, TType.BOOL, 'isAuthorized', None, None, ), # 2
14200 
  )
14201 
 
14202 
  def __init__(self, orderId=None, isAuthorized=None,):
14203 
    self.orderId = orderId
14204 
    self.isAuthorized = isAuthorized
14205 
 
14206 
  def read(self, iprot):
14207 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14208 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14209 
      return
14210 
    iprot.readStructBegin()
14211 
    while True:
14212 
      (fname, ftype, fid) = iprot.readFieldBegin()
14213 
      if ftype == TType.STOP:
14214 
        break
14215 
      if fid == 1:
14216 
        if ftype == TType.I64:
14217 
          self.orderId = iprot.readI64();
14218 
        else:
14219 
          iprot.skip(ftype)
14220 
      elif fid == 2:
14221 
        if ftype == TType.BOOL:
14222 
          self.isAuthorized = iprot.readBool();
14223 
        else:
14224 
          iprot.skip(ftype)
14225 
      else:
14226 
        iprot.skip(ftype)
14227 
      iprot.readFieldEnd()
14228 
    iprot.readStructEnd()
14229 
 
14230 
  def write(self, oprot):
14231 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14232 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14233 
      return
14234 
    oprot.writeStructBegin('markOrderReturnRequestAuthorized_args')
14235 
    if self.orderId is not None:
14236 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
14237 
      oprot.writeI64(self.orderId)
14238 
      oprot.writeFieldEnd()
14239 
    if self.isAuthorized is not None:
14240 
      oprot.writeFieldBegin('isAuthorized', TType.BOOL, 2)
14241 
      oprot.writeBool(self.isAuthorized)
14242 
      oprot.writeFieldEnd()
14243 
    oprot.writeFieldStop()
14244 
    oprot.writeStructEnd()
14245 
 
14246 
  def validate(self):
14247 
    return
14248 
 
14249 
 
14250 
  def __repr__(self):
14251 
    L = ['%s=%r' % (key, value)
14252 
      for key, value in self.__dict__.iteritems()]
14253 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14254 
 
14255 
  def __eq__(self, other):
14256 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14257 
 
14258 
  def __ne__(self, other):
14259 
    return not (self == other)
14260 
 
14261 
class markOrderReturnRequestAuthorized_result:
14262 
  """
14263 
  Attributes:
14264 
   - success
14265 
   - ex
14266 
  """
14267 
 
14268 
  thrift_spec = (
14269 
    (0, TType.BOOL, 'success', None, None, ), # 0
14270 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
14271 
  )
14272 
 
14273 
  def __init__(self, success=None, ex=None,):
14274 
    self.success = success
14275 
    self.ex = ex
14276 
 
14277 
  def read(self, iprot):
14278 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14279 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14280 
      return
14281 
    iprot.readStructBegin()
14282 
    while True:
14283 
      (fname, ftype, fid) = iprot.readFieldBegin()
14284 
      if ftype == TType.STOP:
14285 
        break
14286 
      if fid == 0:
14287 
        if ftype == TType.BOOL:
14288 
          self.success = iprot.readBool();
14289 
        else:
14290 
          iprot.skip(ftype)
14291 
      elif fid == 1:
14292 
        if ftype == TType.STRUCT:
14293 
          self.ex = TransactionServiceException()
14294 
          self.ex.read(iprot)
14295 
        else:
14296 
          iprot.skip(ftype)
14297 
      else:
14298 
        iprot.skip(ftype)
14299 
      iprot.readFieldEnd()
14300 
    iprot.readStructEnd()
14301 
 
14302 
  def write(self, oprot):
14303 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14304 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14305 
      return
14306 
    oprot.writeStructBegin('markOrderReturnRequestAuthorized_result')
14307 
    if self.success is not None:
14308 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
14309 
      oprot.writeBool(self.success)
14310 
      oprot.writeFieldEnd()
14311 
    if self.ex is not None:
14312 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
14313 
      self.ex.write(oprot)
14314 
      oprot.writeFieldEnd()
14315 
    oprot.writeFieldStop()
14316 
    oprot.writeStructEnd()
14317 
 
14318 
  def validate(self):
14319 
    return
14320 
 
14321 
 
14322 
  def __repr__(self):
14323 
    L = ['%s=%r' % (key, value)
14324 
      for key, value in self.__dict__.iteritems()]
14325 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14326 
 
14327 
  def __eq__(self, other):
14328 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14329 
 
14330 
  def __ne__(self, other):
14331 
    return not (self == other)
14332 
 
2536 chandransh 14333 
class requestPickupNumber_args:
14334 
  """
14335 
  Attributes:
14336 
   - orderId
4579 rajveer 14337 
   - providerId
2536 chandransh 14338 
  """
14339 
 
14340 
  thrift_spec = (
14341 
    None, # 0
14342 
    (1, TType.I64, 'orderId', None, None, ), # 1
4579 rajveer 14343 
    (2, TType.I64, 'providerId', None, None, ), # 2
2536 chandransh 14344 
  )
14345 
 
4579 rajveer 14346 
  def __init__(self, orderId=None, providerId=None,):
2536 chandransh 14347 
    self.orderId = orderId
4579 rajveer 14348 
    self.providerId = providerId
2536 chandransh 14349 
 
14350 
  def read(self, iprot):
14351 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14352 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14353 
      return
14354 
    iprot.readStructBegin()
14355 
    while True:
14356 
      (fname, ftype, fid) = iprot.readFieldBegin()
14357 
      if ftype == TType.STOP:
14358 
        break
14359 
      if fid == 1:
14360 
        if ftype == TType.I64:
14361 
          self.orderId = iprot.readI64();
14362 
        else:
14363 
          iprot.skip(ftype)
4579 rajveer 14364 
      elif fid == 2:
14365 
        if ftype == TType.I64:
14366 
          self.providerId = iprot.readI64();
14367 
        else:
14368 
          iprot.skip(ftype)
2536 chandransh 14369 
      else:
14370 
        iprot.skip(ftype)
14371 
      iprot.readFieldEnd()
14372 
    iprot.readStructEnd()
14373 
 
14374 
  def write(self, oprot):
14375 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14376 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14377 
      return
14378 
    oprot.writeStructBegin('requestPickupNumber_args')
3431 rajveer 14379 
    if self.orderId is not None:
2536 chandransh 14380 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
14381 
      oprot.writeI64(self.orderId)
14382 
      oprot.writeFieldEnd()
4579 rajveer 14383 
    if self.providerId is not None:
14384 
      oprot.writeFieldBegin('providerId', TType.I64, 2)
14385 
      oprot.writeI64(self.providerId)
14386 
      oprot.writeFieldEnd()
2536 chandransh 14387 
    oprot.writeFieldStop()
14388 
    oprot.writeStructEnd()
14389 
 
3431 rajveer 14390 
  def validate(self):
14391 
    return
14392 
 
14393 
 
2536 chandransh 14394 
  def __repr__(self):
14395 
    L = ['%s=%r' % (key, value)
14396 
      for key, value in self.__dict__.iteritems()]
14397 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14398 
 
14399 
  def __eq__(self, other):
14400 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14401 
 
14402 
  def __ne__(self, other):
14403 
    return not (self == other)
14404 
 
14405 
class requestPickupNumber_result:
14406 
  """
14407 
  Attributes:
14408 
   - success
14409 
   - ex
14410 
  """
14411 
 
14412 
  thrift_spec = (
14413 
    (0, TType.BOOL, 'success', None, None, ), # 0
14414 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
14415 
  )
14416 
 
14417 
  def __init__(self, success=None, ex=None,):
14418 
    self.success = success
14419 
    self.ex = ex
14420 
 
14421 
  def read(self, iprot):
14422 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14423 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14424 
      return
14425 
    iprot.readStructBegin()
14426 
    while True:
14427 
      (fname, ftype, fid) = iprot.readFieldBegin()
14428 
      if ftype == TType.STOP:
14429 
        break
14430 
      if fid == 0:
14431 
        if ftype == TType.BOOL:
14432 
          self.success = iprot.readBool();
14433 
        else:
14434 
          iprot.skip(ftype)
14435 
      elif fid == 1:
14436 
        if ftype == TType.STRUCT:
14437 
          self.ex = TransactionServiceException()
14438 
          self.ex.read(iprot)
14439 
        else:
14440 
          iprot.skip(ftype)
14441 
      else:
14442 
        iprot.skip(ftype)
14443 
      iprot.readFieldEnd()
14444 
    iprot.readStructEnd()
14445 
 
14446 
  def write(self, oprot):
14447 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14448 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14449 
      return
14450 
    oprot.writeStructBegin('requestPickupNumber_result')
3431 rajveer 14451 
    if self.success is not None:
2536 chandransh 14452 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
14453 
      oprot.writeBool(self.success)
14454 
      oprot.writeFieldEnd()
3431 rajveer 14455 
    if self.ex is not None:
2536 chandransh 14456 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
14457 
      self.ex.write(oprot)
14458 
      oprot.writeFieldEnd()
14459 
    oprot.writeFieldStop()
14460 
    oprot.writeStructEnd()
14461 
 
3431 rajveer 14462 
  def validate(self):
14463 
    return
14464 
 
14465 
 
2536 chandransh 14466 
  def __repr__(self):
14467 
    L = ['%s=%r' % (key, value)
14468 
      for key, value in self.__dict__.iteritems()]
14469 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14470 
 
14471 
  def __eq__(self, other):
14472 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14473 
 
14474 
  def __ne__(self, other):
14475 
    return not (self == other)
14476 
 
14477 
class authorizePickup_args:
14478 
  """
14479 
  Attributes:
14480 
   - orderId
14481 
   - pickupNumber
4602 rajveer 14482 
   - providerId
2536 chandransh 14483 
  """
14484 
 
14485 
  thrift_spec = (
14486 
    None, # 0
14487 
    (1, TType.I64, 'orderId', None, None, ), # 1
14488 
    (2, TType.STRING, 'pickupNumber', None, None, ), # 2
4602 rajveer 14489 
    (3, TType.I64, 'providerId', None, None, ), # 3
2536 chandransh 14490 
  )
14491 
 
4602 rajveer 14492 
  def __init__(self, orderId=None, pickupNumber=None, providerId=None,):
2536 chandransh 14493 
    self.orderId = orderId
14494 
    self.pickupNumber = pickupNumber
4602 rajveer 14495 
    self.providerId = providerId
2536 chandransh 14496 
 
14497 
  def read(self, iprot):
14498 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14499 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14500 
      return
14501 
    iprot.readStructBegin()
14502 
    while True:
14503 
      (fname, ftype, fid) = iprot.readFieldBegin()
14504 
      if ftype == TType.STOP:
14505 
        break
14506 
      if fid == 1:
14507 
        if ftype == TType.I64:
14508 
          self.orderId = iprot.readI64();
14509 
        else:
14510 
          iprot.skip(ftype)
14511 
      elif fid == 2:
14512 
        if ftype == TType.STRING:
14513 
          self.pickupNumber = iprot.readString();
14514 
        else:
14515 
          iprot.skip(ftype)
4602 rajveer 14516 
      elif fid == 3:
14517 
        if ftype == TType.I64:
14518 
          self.providerId = iprot.readI64();
14519 
        else:
14520 
          iprot.skip(ftype)
2536 chandransh 14521 
      else:
14522 
        iprot.skip(ftype)
14523 
      iprot.readFieldEnd()
14524 
    iprot.readStructEnd()
14525 
 
14526 
  def write(self, oprot):
14527 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14528 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14529 
      return
14530 
    oprot.writeStructBegin('authorizePickup_args')
3431 rajveer 14531 
    if self.orderId is not None:
2536 chandransh 14532 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
14533 
      oprot.writeI64(self.orderId)
14534 
      oprot.writeFieldEnd()
3431 rajveer 14535 
    if self.pickupNumber is not None:
2536 chandransh 14536 
      oprot.writeFieldBegin('pickupNumber', TType.STRING, 2)
14537 
      oprot.writeString(self.pickupNumber)
14538 
      oprot.writeFieldEnd()
4602 rajveer 14539 
    if self.providerId is not None:
14540 
      oprot.writeFieldBegin('providerId', TType.I64, 3)
14541 
      oprot.writeI64(self.providerId)
14542 
      oprot.writeFieldEnd()
2536 chandransh 14543 
    oprot.writeFieldStop()
14544 
    oprot.writeStructEnd()
14545 
 
3431 rajveer 14546 
  def validate(self):
14547 
    return
14548 
 
14549 
 
2536 chandransh 14550 
  def __repr__(self):
14551 
    L = ['%s=%r' % (key, value)
14552 
      for key, value in self.__dict__.iteritems()]
14553 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14554 
 
14555 
  def __eq__(self, other):
14556 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14557 
 
14558 
  def __ne__(self, other):
14559 
    return not (self == other)
14560 
 
14561 
class authorizePickup_result:
14562 
  """
14563 
  Attributes:
14564 
   - success
14565 
   - ex
14566 
  """
14567 
 
14568 
  thrift_spec = (
14569 
    (0, TType.BOOL, 'success', None, None, ), # 0
14570 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
14571 
  )
14572 
 
14573 
  def __init__(self, success=None, ex=None,):
14574 
    self.success = success
14575 
    self.ex = ex
14576 
 
14577 
  def read(self, iprot):
14578 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14579 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14580 
      return
14581 
    iprot.readStructBegin()
14582 
    while True:
14583 
      (fname, ftype, fid) = iprot.readFieldBegin()
14584 
      if ftype == TType.STOP:
14585 
        break
14586 
      if fid == 0:
14587 
        if ftype == TType.BOOL:
14588 
          self.success = iprot.readBool();
14589 
        else:
14590 
          iprot.skip(ftype)
14591 
      elif fid == 1:
14592 
        if ftype == TType.STRUCT:
14593 
          self.ex = TransactionServiceException()
14594 
          self.ex.read(iprot)
14595 
        else:
14596 
          iprot.skip(ftype)
14597 
      else:
14598 
        iprot.skip(ftype)
14599 
      iprot.readFieldEnd()
14600 
    iprot.readStructEnd()
14601 
 
14602 
  def write(self, oprot):
14603 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14604 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14605 
      return
14606 
    oprot.writeStructBegin('authorizePickup_result')
3431 rajveer 14607 
    if self.success is not None:
2536 chandransh 14608 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
14609 
      oprot.writeBool(self.success)
14610 
      oprot.writeFieldEnd()
3431 rajveer 14611 
    if self.ex is not None:
2536 chandransh 14612 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
14613 
      self.ex.write(oprot)
14614 
      oprot.writeFieldEnd()
14615 
    oprot.writeFieldStop()
14616 
    oprot.writeStructEnd()
14617 
 
3431 rajveer 14618 
  def validate(self):
14619 
    return
14620 
 
14621 
 
2536 chandransh 14622 
  def __repr__(self):
14623 
    L = ['%s=%r' % (key, value)
14624 
      for key, value in self.__dict__.iteritems()]
14625 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14626 
 
14627 
  def __eq__(self, other):
14628 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14629 
 
14630 
  def __ne__(self, other):
14631 
    return not (self == other)
14632 
 
2764 chandransh 14633 
class markDoasAsPickedUp_args:
14634 
  """
14635 
  Attributes:
14636 
   - providerId
14637 
   - pickupDetails
14638 
  """
14639 
 
14640 
  thrift_spec = (
14641 
    None, # 0
14642 
    (1, TType.I64, 'providerId', None, None, ), # 1
14643 
    (2, TType.MAP, 'pickupDetails', (TType.STRING,None,TType.STRING,None), None, ), # 2
14644 
  )
14645 
 
14646 
  def __init__(self, providerId=None, pickupDetails=None,):
14647 
    self.providerId = providerId
14648 
    self.pickupDetails = pickupDetails
14649 
 
14650 
  def read(self, iprot):
14651 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14652 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14653 
      return
14654 
    iprot.readStructBegin()
14655 
    while True:
14656 
      (fname, ftype, fid) = iprot.readFieldBegin()
14657 
      if ftype == TType.STOP:
14658 
        break
14659 
      if fid == 1:
14660 
        if ftype == TType.I64:
14661 
          self.providerId = iprot.readI64();
14662 
        else:
14663 
          iprot.skip(ftype)
14664 
      elif fid == 2:
14665 
        if ftype == TType.MAP:
14666 
          self.pickupDetails = {}
5031 varun.gupt 14667 
          (_ktype323, _vtype324, _size322 ) = iprot.readMapBegin()
14668 
          for _i326 in xrange(_size322):
14669 
            _key327 = iprot.readString();
14670 
            _val328 = iprot.readString();
14671 
            self.pickupDetails[_key327] = _val328
2764 chandransh 14672 
          iprot.readMapEnd()
14673 
        else:
14674 
          iprot.skip(ftype)
14675 
      else:
14676 
        iprot.skip(ftype)
14677 
      iprot.readFieldEnd()
14678 
    iprot.readStructEnd()
14679 
 
14680 
  def write(self, oprot):
14681 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14682 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14683 
      return
14684 
    oprot.writeStructBegin('markDoasAsPickedUp_args')
3431 rajveer 14685 
    if self.providerId is not None:
2764 chandransh 14686 
      oprot.writeFieldBegin('providerId', TType.I64, 1)
14687 
      oprot.writeI64(self.providerId)
14688 
      oprot.writeFieldEnd()
3431 rajveer 14689 
    if self.pickupDetails is not None:
2764 chandransh 14690 
      oprot.writeFieldBegin('pickupDetails', TType.MAP, 2)
14691 
      oprot.writeMapBegin(TType.STRING, TType.STRING, len(self.pickupDetails))
5031 varun.gupt 14692 
      for kiter329,viter330 in self.pickupDetails.items():
14693 
        oprot.writeString(kiter329)
14694 
        oprot.writeString(viter330)
2764 chandransh 14695 
      oprot.writeMapEnd()
14696 
      oprot.writeFieldEnd()
14697 
    oprot.writeFieldStop()
14698 
    oprot.writeStructEnd()
14699 
 
3431 rajveer 14700 
  def validate(self):
14701 
    return
14702 
 
14703 
 
2764 chandransh 14704 
  def __repr__(self):
14705 
    L = ['%s=%r' % (key, value)
14706 
      for key, value in self.__dict__.iteritems()]
14707 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14708 
 
14709 
  def __eq__(self, other):
14710 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14711 
 
14712 
  def __ne__(self, other):
14713 
    return not (self == other)
14714 
 
14715 
class markDoasAsPickedUp_result:
4910 phani.kuma 14716 
 
14717 
  thrift_spec = (
14718 
  )
14719 
 
14720 
  def read(self, iprot):
14721 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14722 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14723 
      return
14724 
    iprot.readStructBegin()
14725 
    while True:
14726 
      (fname, ftype, fid) = iprot.readFieldBegin()
14727 
      if ftype == TType.STOP:
14728 
        break
14729 
      else:
14730 
        iprot.skip(ftype)
14731 
      iprot.readFieldEnd()
14732 
    iprot.readStructEnd()
14733 
 
14734 
  def write(self, oprot):
14735 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14736 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14737 
      return
14738 
    oprot.writeStructBegin('markDoasAsPickedUp_result')
14739 
    oprot.writeFieldStop()
14740 
    oprot.writeStructEnd()
14741 
 
14742 
  def validate(self):
14743 
    return
14744 
 
14745 
 
14746 
  def __repr__(self):
14747 
    L = ['%s=%r' % (key, value)
14748 
      for key, value in self.__dict__.iteritems()]
14749 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14750 
 
14751 
  def __eq__(self, other):
14752 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14753 
 
14754 
  def __ne__(self, other):
14755 
    return not (self == other)
14756 
 
14757 
class getDoasNotPickedUp_args:
2764 chandransh 14758 
  """
14759 
  Attributes:
4910 phani.kuma 14760 
   - providerId
14761 
  """
14762 
 
14763 
  thrift_spec = (
14764 
    None, # 0
14765 
    (1, TType.I64, 'providerId', None, None, ), # 1
14766 
  )
14767 
 
14768 
  def __init__(self, providerId=None,):
14769 
    self.providerId = providerId
14770 
 
14771 
  def read(self, iprot):
14772 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14773 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14774 
      return
14775 
    iprot.readStructBegin()
14776 
    while True:
14777 
      (fname, ftype, fid) = iprot.readFieldBegin()
14778 
      if ftype == TType.STOP:
14779 
        break
14780 
      if fid == 1:
14781 
        if ftype == TType.I64:
14782 
          self.providerId = iprot.readI64();
14783 
        else:
14784 
          iprot.skip(ftype)
14785 
      else:
14786 
        iprot.skip(ftype)
14787 
      iprot.readFieldEnd()
14788 
    iprot.readStructEnd()
14789 
 
14790 
  def write(self, oprot):
14791 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14792 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14793 
      return
14794 
    oprot.writeStructBegin('getDoasNotPickedUp_args')
14795 
    if self.providerId is not None:
14796 
      oprot.writeFieldBegin('providerId', TType.I64, 1)
14797 
      oprot.writeI64(self.providerId)
14798 
      oprot.writeFieldEnd()
14799 
    oprot.writeFieldStop()
14800 
    oprot.writeStructEnd()
14801 
 
14802 
  def validate(self):
14803 
    return
14804 
 
14805 
 
14806 
  def __repr__(self):
14807 
    L = ['%s=%r' % (key, value)
14808 
      for key, value in self.__dict__.iteritems()]
14809 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14810 
 
14811 
  def __eq__(self, other):
14812 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14813 
 
14814 
  def __ne__(self, other):
14815 
    return not (self == other)
14816 
 
14817 
class getDoasNotPickedUp_result:
14818 
  """
14819 
  Attributes:
2764 chandransh 14820 
   - success
14821 
  """
14822 
 
14823 
  thrift_spec = (
14824 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
14825 
  )
14826 
 
14827 
  def __init__(self, success=None,):
14828 
    self.success = success
14829 
 
14830 
  def read(self, iprot):
14831 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14832 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14833 
      return
14834 
    iprot.readStructBegin()
14835 
    while True:
14836 
      (fname, ftype, fid) = iprot.readFieldBegin()
14837 
      if ftype == TType.STOP:
14838 
        break
14839 
      if fid == 0:
14840 
        if ftype == TType.LIST:
14841 
          self.success = []
5031 varun.gupt 14842 
          (_etype334, _size331) = iprot.readListBegin()
14843 
          for _i335 in xrange(_size331):
14844 
            _elem336 = Order()
14845 
            _elem336.read(iprot)
14846 
            self.success.append(_elem336)
2764 chandransh 14847 
          iprot.readListEnd()
14848 
        else:
14849 
          iprot.skip(ftype)
14850 
      else:
14851 
        iprot.skip(ftype)
14852 
      iprot.readFieldEnd()
14853 
    iprot.readStructEnd()
14854 
 
14855 
  def write(self, oprot):
14856 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14857 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14858 
      return
4910 phani.kuma 14859 
    oprot.writeStructBegin('getDoasNotPickedUp_result')
3431 rajveer 14860 
    if self.success is not None:
2764 chandransh 14861 
      oprot.writeFieldBegin('success', TType.LIST, 0)
14862 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
5031 varun.gupt 14863 
      for iter337 in self.success:
14864 
        iter337.write(oprot)
2764 chandransh 14865 
      oprot.writeListEnd()
14866 
      oprot.writeFieldEnd()
14867 
    oprot.writeFieldStop()
14868 
    oprot.writeStructEnd()
14869 
 
3431 rajveer 14870 
  def validate(self):
14871 
    return
14872 
 
14873 
 
2764 chandransh 14874 
  def __repr__(self):
14875 
    L = ['%s=%r' % (key, value)
14876 
      for key, value in self.__dict__.iteritems()]
14877 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14878 
 
14879 
  def __eq__(self, other):
14880 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14881 
 
14882 
  def __ne__(self, other):
14883 
    return not (self == other)
14884 
 
4741 phani.kuma 14885 
class markReturnOrdersAsPickedUp_args:
14886 
  """
14887 
  Attributes:
14888 
   - providerId
14889 
   - pickupDetails
14890 
  """
14891 
 
14892 
  thrift_spec = (
14893 
    None, # 0
14894 
    (1, TType.I64, 'providerId', None, None, ), # 1
14895 
    (2, TType.MAP, 'pickupDetails', (TType.STRING,None,TType.STRING,None), None, ), # 2
14896 
  )
14897 
 
14898 
  def __init__(self, providerId=None, pickupDetails=None,):
14899 
    self.providerId = providerId
14900 
    self.pickupDetails = pickupDetails
14901 
 
14902 
  def read(self, iprot):
14903 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14904 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14905 
      return
14906 
    iprot.readStructBegin()
14907 
    while True:
14908 
      (fname, ftype, fid) = iprot.readFieldBegin()
14909 
      if ftype == TType.STOP:
14910 
        break
14911 
      if fid == 1:
14912 
        if ftype == TType.I64:
14913 
          self.providerId = iprot.readI64();
14914 
        else:
14915 
          iprot.skip(ftype)
14916 
      elif fid == 2:
14917 
        if ftype == TType.MAP:
14918 
          self.pickupDetails = {}
5031 varun.gupt 14919 
          (_ktype339, _vtype340, _size338 ) = iprot.readMapBegin()
14920 
          for _i342 in xrange(_size338):
14921 
            _key343 = iprot.readString();
14922 
            _val344 = iprot.readString();
14923 
            self.pickupDetails[_key343] = _val344
4741 phani.kuma 14924 
          iprot.readMapEnd()
14925 
        else:
14926 
          iprot.skip(ftype)
14927 
      else:
14928 
        iprot.skip(ftype)
14929 
      iprot.readFieldEnd()
14930 
    iprot.readStructEnd()
14931 
 
14932 
  def write(self, oprot):
14933 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14934 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14935 
      return
14936 
    oprot.writeStructBegin('markReturnOrdersAsPickedUp_args')
14937 
    if self.providerId is not None:
14938 
      oprot.writeFieldBegin('providerId', TType.I64, 1)
14939 
      oprot.writeI64(self.providerId)
14940 
      oprot.writeFieldEnd()
14941 
    if self.pickupDetails is not None:
14942 
      oprot.writeFieldBegin('pickupDetails', TType.MAP, 2)
14943 
      oprot.writeMapBegin(TType.STRING, TType.STRING, len(self.pickupDetails))
5031 varun.gupt 14944 
      for kiter345,viter346 in self.pickupDetails.items():
14945 
        oprot.writeString(kiter345)
14946 
        oprot.writeString(viter346)
4741 phani.kuma 14947 
      oprot.writeMapEnd()
14948 
      oprot.writeFieldEnd()
14949 
    oprot.writeFieldStop()
14950 
    oprot.writeStructEnd()
14951 
 
14952 
  def validate(self):
14953 
    return
14954 
 
14955 
 
14956 
  def __repr__(self):
14957 
    L = ['%s=%r' % (key, value)
14958 
      for key, value in self.__dict__.iteritems()]
14959 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14960 
 
14961 
  def __eq__(self, other):
14962 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14963 
 
14964 
  def __ne__(self, other):
14965 
    return not (self == other)
14966 
 
14967 
class markReturnOrdersAsPickedUp_result:
4910 phani.kuma 14968 
 
14969 
  thrift_spec = (
14970 
  )
14971 
 
14972 
  def read(self, iprot):
14973 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14974 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14975 
      return
14976 
    iprot.readStructBegin()
14977 
    while True:
14978 
      (fname, ftype, fid) = iprot.readFieldBegin()
14979 
      if ftype == TType.STOP:
14980 
        break
14981 
      else:
14982 
        iprot.skip(ftype)
14983 
      iprot.readFieldEnd()
14984 
    iprot.readStructEnd()
14985 
 
14986 
  def write(self, oprot):
14987 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14988 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14989 
      return
14990 
    oprot.writeStructBegin('markReturnOrdersAsPickedUp_result')
14991 
    oprot.writeFieldStop()
14992 
    oprot.writeStructEnd()
14993 
 
14994 
  def validate(self):
14995 
    return
14996 
 
14997 
 
14998 
  def __repr__(self):
14999 
    L = ['%s=%r' % (key, value)
15000 
      for key, value in self.__dict__.iteritems()]
15001 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15002 
 
15003 
  def __eq__(self, other):
15004 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15005 
 
15006 
  def __ne__(self, other):
15007 
    return not (self == other)
15008 
 
15009 
class getReturnOrdersNotPickedUp_args:
4741 phani.kuma 15010 
  """
15011 
  Attributes:
4910 phani.kuma 15012 
   - providerId
15013 
  """
15014 
 
15015 
  thrift_spec = (
15016 
    None, # 0
15017 
    (1, TType.I64, 'providerId', None, None, ), # 1
15018 
  )
15019 
 
15020 
  def __init__(self, providerId=None,):
15021 
    self.providerId = providerId
15022 
 
15023 
  def read(self, iprot):
15024 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15025 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15026 
      return
15027 
    iprot.readStructBegin()
15028 
    while True:
15029 
      (fname, ftype, fid) = iprot.readFieldBegin()
15030 
      if ftype == TType.STOP:
15031 
        break
15032 
      if fid == 1:
15033 
        if ftype == TType.I64:
15034 
          self.providerId = iprot.readI64();
15035 
        else:
15036 
          iprot.skip(ftype)
15037 
      else:
15038 
        iprot.skip(ftype)
15039 
      iprot.readFieldEnd()
15040 
    iprot.readStructEnd()
15041 
 
15042 
  def write(self, oprot):
15043 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15044 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15045 
      return
15046 
    oprot.writeStructBegin('getReturnOrdersNotPickedUp_args')
15047 
    if self.providerId is not None:
15048 
      oprot.writeFieldBegin('providerId', TType.I64, 1)
15049 
      oprot.writeI64(self.providerId)
15050 
      oprot.writeFieldEnd()
15051 
    oprot.writeFieldStop()
15052 
    oprot.writeStructEnd()
15053 
 
15054 
  def validate(self):
15055 
    return
15056 
 
15057 
 
15058 
  def __repr__(self):
15059 
    L = ['%s=%r' % (key, value)
15060 
      for key, value in self.__dict__.iteritems()]
15061 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15062 
 
15063 
  def __eq__(self, other):
15064 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15065 
 
15066 
  def __ne__(self, other):
15067 
    return not (self == other)
15068 
 
15069 
class getReturnOrdersNotPickedUp_result:
15070 
  """
15071 
  Attributes:
4741 phani.kuma 15072 
   - success
15073 
  """
15074 
 
15075 
  thrift_spec = (
15076 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
15077 
  )
15078 
 
15079 
  def __init__(self, success=None,):
15080 
    self.success = success
15081 
 
15082 
  def read(self, iprot):
15083 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15084 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15085 
      return
15086 
    iprot.readStructBegin()
15087 
    while True:
15088 
      (fname, ftype, fid) = iprot.readFieldBegin()
15089 
      if ftype == TType.STOP:
15090 
        break
15091 
      if fid == 0:
15092 
        if ftype == TType.LIST:
15093 
          self.success = []
5031 varun.gupt 15094 
          (_etype350, _size347) = iprot.readListBegin()
15095 
          for _i351 in xrange(_size347):
15096 
            _elem352 = Order()
15097 
            _elem352.read(iprot)
15098 
            self.success.append(_elem352)
4741 phani.kuma 15099 
          iprot.readListEnd()
15100 
        else:
15101 
          iprot.skip(ftype)
15102 
      else:
15103 
        iprot.skip(ftype)
15104 
      iprot.readFieldEnd()
15105 
    iprot.readStructEnd()
15106 
 
15107 
  def write(self, oprot):
15108 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15109 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15110 
      return
4910 phani.kuma 15111 
    oprot.writeStructBegin('getReturnOrdersNotPickedUp_result')
4741 phani.kuma 15112 
    if self.success is not None:
15113 
      oprot.writeFieldBegin('success', TType.LIST, 0)
15114 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
5031 varun.gupt 15115 
      for iter353 in self.success:
15116 
        iter353.write(oprot)
4741 phani.kuma 15117 
      oprot.writeListEnd()
15118 
      oprot.writeFieldEnd()
15119 
    oprot.writeFieldStop()
15120 
    oprot.writeStructEnd()
15121 
 
15122 
  def validate(self):
15123 
    return
15124 
 
15125 
 
15126 
  def __repr__(self):
15127 
    L = ['%s=%r' % (key, value)
15128 
      for key, value in self.__dict__.iteritems()]
15129 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15130 
 
15131 
  def __eq__(self, other):
15132 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15133 
 
15134 
  def __ne__(self, other):
15135 
    return not (self == other)
15136 
 
2616 chandransh 15137 
class receiveReturn_args:
2591 chandransh 15138 
  """
15139 
  Attributes:
15140 
   - orderId
4479 rajveer 15141 
   - receiveCondition
2591 chandransh 15142 
  """
2536 chandransh 15143 
 
2591 chandransh 15144 
  thrift_spec = (
15145 
    None, # 0
15146 
    (1, TType.I64, 'orderId', None, None, ), # 1
4479 rajveer 15147 
    (2, TType.I64, 'receiveCondition', None, None, ), # 2
2591 chandransh 15148 
  )
15149 
 
4479 rajveer 15150 
  def __init__(self, orderId=None, receiveCondition=None,):
2591 chandransh 15151 
    self.orderId = orderId
4479 rajveer 15152 
    self.receiveCondition = receiveCondition
2591 chandransh 15153 
 
15154 
  def read(self, iprot):
15155 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15156 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15157 
      return
15158 
    iprot.readStructBegin()
15159 
    while True:
15160 
      (fname, ftype, fid) = iprot.readFieldBegin()
15161 
      if ftype == TType.STOP:
15162 
        break
15163 
      if fid == 1:
15164 
        if ftype == TType.I64:
15165 
          self.orderId = iprot.readI64();
15166 
        else:
15167 
          iprot.skip(ftype)
4479 rajveer 15168 
      elif fid == 2:
15169 
        if ftype == TType.I64:
15170 
          self.receiveCondition = iprot.readI64();
15171 
        else:
15172 
          iprot.skip(ftype)
2591 chandransh 15173 
      else:
15174 
        iprot.skip(ftype)
15175 
      iprot.readFieldEnd()
15176 
    iprot.readStructEnd()
15177 
 
15178 
  def write(self, oprot):
15179 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15180 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15181 
      return
2616 chandransh 15182 
    oprot.writeStructBegin('receiveReturn_args')
3431 rajveer 15183 
    if self.orderId is not None:
2591 chandransh 15184 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
15185 
      oprot.writeI64(self.orderId)
15186 
      oprot.writeFieldEnd()
4479 rajveer 15187 
    if self.receiveCondition is not None:
15188 
      oprot.writeFieldBegin('receiveCondition', TType.I64, 2)
15189 
      oprot.writeI64(self.receiveCondition)
15190 
      oprot.writeFieldEnd()
2591 chandransh 15191 
    oprot.writeFieldStop()
15192 
    oprot.writeStructEnd()
15193 
 
3431 rajveer 15194 
  def validate(self):
15195 
    return
15196 
 
15197 
 
2591 chandransh 15198 
  def __repr__(self):
15199 
    L = ['%s=%r' % (key, value)
15200 
      for key, value in self.__dict__.iteritems()]
15201 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15202 
 
15203 
  def __eq__(self, other):
15204 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15205 
 
15206 
  def __ne__(self, other):
15207 
    return not (self == other)
15208 
 
2616 chandransh 15209 
class receiveReturn_result:
2591 chandransh 15210 
  """
15211 
  Attributes:
15212 
   - success
15213 
   - ex
15214 
  """
15215 
 
15216 
  thrift_spec = (
15217 
    (0, TType.BOOL, 'success', None, None, ), # 0
15218 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
15219 
  )
15220 
 
15221 
  def __init__(self, success=None, ex=None,):
15222 
    self.success = success
15223 
    self.ex = ex
15224 
 
15225 
  def read(self, iprot):
15226 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15227 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15228 
      return
15229 
    iprot.readStructBegin()
15230 
    while True:
15231 
      (fname, ftype, fid) = iprot.readFieldBegin()
15232 
      if ftype == TType.STOP:
15233 
        break
15234 
      if fid == 0:
15235 
        if ftype == TType.BOOL:
15236 
          self.success = iprot.readBool();
15237 
        else:
15238 
          iprot.skip(ftype)
15239 
      elif fid == 1:
15240 
        if ftype == TType.STRUCT:
15241 
          self.ex = TransactionServiceException()
15242 
          self.ex.read(iprot)
15243 
        else:
15244 
          iprot.skip(ftype)
15245 
      else:
15246 
        iprot.skip(ftype)
15247 
      iprot.readFieldEnd()
15248 
    iprot.readStructEnd()
15249 
 
15250 
  def write(self, oprot):
15251 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15252 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15253 
      return
2616 chandransh 15254 
    oprot.writeStructBegin('receiveReturn_result')
3431 rajveer 15255 
    if self.success is not None:
2591 chandransh 15256 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
15257 
      oprot.writeBool(self.success)
15258 
      oprot.writeFieldEnd()
3431 rajveer 15259 
    if self.ex is not None:
2591 chandransh 15260 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
15261 
      self.ex.write(oprot)
15262 
      oprot.writeFieldEnd()
15263 
    oprot.writeFieldStop()
15264 
    oprot.writeStructEnd()
15265 
 
3431 rajveer 15266 
  def validate(self):
15267 
    return
15268 
 
15269 
 
2591 chandransh 15270 
  def __repr__(self):
15271 
    L = ['%s=%r' % (key, value)
15272 
      for key, value in self.__dict__.iteritems()]
15273 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15274 
 
15275 
  def __eq__(self, other):
15276 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15277 
 
15278 
  def __ne__(self, other):
15279 
    return not (self == other)
15280 
 
15281 
class validateDoa_args:
15282 
  """
15283 
  Attributes:
15284 
   - orderId
15285 
   - isValid
15286 
  """
15287 
 
15288 
  thrift_spec = (
15289 
    None, # 0
15290 
    (1, TType.I64, 'orderId', None, None, ), # 1
15291 
    (2, TType.BOOL, 'isValid', None, None, ), # 2
15292 
  )
15293 
 
15294 
  def __init__(self, orderId=None, isValid=None,):
15295 
    self.orderId = orderId
15296 
    self.isValid = isValid
15297 
 
15298 
  def read(self, iprot):
15299 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15300 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15301 
      return
15302 
    iprot.readStructBegin()
15303 
    while True:
15304 
      (fname, ftype, fid) = iprot.readFieldBegin()
15305 
      if ftype == TType.STOP:
15306 
        break
15307 
      if fid == 1:
15308 
        if ftype == TType.I64:
15309 
          self.orderId = iprot.readI64();
15310 
        else:
15311 
          iprot.skip(ftype)
15312 
      elif fid == 2:
15313 
        if ftype == TType.BOOL:
15314 
          self.isValid = iprot.readBool();
15315 
        else:
15316 
          iprot.skip(ftype)
15317 
      else:
15318 
        iprot.skip(ftype)
15319 
      iprot.readFieldEnd()
15320 
    iprot.readStructEnd()
15321 
 
15322 
  def write(self, oprot):
15323 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15324 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15325 
      return
15326 
    oprot.writeStructBegin('validateDoa_args')
3431 rajveer 15327 
    if self.orderId is not None:
2591 chandransh 15328 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
15329 
      oprot.writeI64(self.orderId)
15330 
      oprot.writeFieldEnd()
3431 rajveer 15331 
    if self.isValid is not None:
2591 chandransh 15332 
      oprot.writeFieldBegin('isValid', TType.BOOL, 2)
15333 
      oprot.writeBool(self.isValid)
15334 
      oprot.writeFieldEnd()
15335 
    oprot.writeFieldStop()
15336 
    oprot.writeStructEnd()
15337 
 
3431 rajveer 15338 
  def validate(self):
15339 
    return
15340 
 
15341 
 
2591 chandransh 15342 
  def __repr__(self):
15343 
    L = ['%s=%r' % (key, value)
15344 
      for key, value in self.__dict__.iteritems()]
15345 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15346 
 
15347 
  def __eq__(self, other):
15348 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15349 
 
15350 
  def __ne__(self, other):
15351 
    return not (self == other)
15352 
 
15353 
class validateDoa_result:
15354 
  """
15355 
  Attributes:
15356 
   - success
15357 
   - ex
15358 
  """
15359 
 
15360 
  thrift_spec = (
15361 
    (0, TType.BOOL, 'success', None, None, ), # 0
15362 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
15363 
  )
15364 
 
15365 
  def __init__(self, success=None, ex=None,):
15366 
    self.success = success
15367 
    self.ex = ex
15368 
 
15369 
  def read(self, iprot):
15370 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15371 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15372 
      return
15373 
    iprot.readStructBegin()
15374 
    while True:
15375 
      (fname, ftype, fid) = iprot.readFieldBegin()
15376 
      if ftype == TType.STOP:
15377 
        break
15378 
      if fid == 0:
15379 
        if ftype == TType.BOOL:
15380 
          self.success = iprot.readBool();
15381 
        else:
15382 
          iprot.skip(ftype)
15383 
      elif fid == 1:
15384 
        if ftype == TType.STRUCT:
15385 
          self.ex = TransactionServiceException()
15386 
          self.ex.read(iprot)
15387 
        else:
15388 
          iprot.skip(ftype)
15389 
      else:
15390 
        iprot.skip(ftype)
15391 
      iprot.readFieldEnd()
15392 
    iprot.readStructEnd()
15393 
 
15394 
  def write(self, oprot):
15395 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15396 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15397 
      return
15398 
    oprot.writeStructBegin('validateDoa_result')
3431 rajveer 15399 
    if self.success is not None:
2591 chandransh 15400 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
15401 
      oprot.writeBool(self.success)
15402 
      oprot.writeFieldEnd()
3431 rajveer 15403 
    if self.ex is not None:
2591 chandransh 15404 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
15405 
      self.ex.write(oprot)
15406 
      oprot.writeFieldEnd()
15407 
    oprot.writeFieldStop()
15408 
    oprot.writeStructEnd()
15409 
 
3431 rajveer 15410 
  def validate(self):
15411 
    return
15412 
 
15413 
 
2591 chandransh 15414 
  def __repr__(self):
15415 
    L = ['%s=%r' % (key, value)
15416 
      for key, value in self.__dict__.iteritems()]
15417 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15418 
 
15419 
  def __eq__(self, other):
15420 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15421 
 
15422 
  def __ne__(self, other):
15423 
    return not (self == other)
15424 
 
4495 rajveer 15425 
class validateReturnProduct_args:
15426 
  """
15427 
  Attributes:
15428 
   - orderId
15429 
   - isUsable
15430 
  """
15431 
 
15432 
  thrift_spec = (
15433 
    None, # 0
15434 
    (1, TType.I64, 'orderId', None, None, ), # 1
15435 
    (2, TType.BOOL, 'isUsable', None, None, ), # 2
15436 
  )
15437 
 
15438 
  def __init__(self, orderId=None, isUsable=None,):
15439 
    self.orderId = orderId
15440 
    self.isUsable = isUsable
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 == 1:
15452 
        if ftype == TType.I64:
15453 
          self.orderId = iprot.readI64();
15454 
        else:
15455 
          iprot.skip(ftype)
15456 
      elif fid == 2:
15457 
        if ftype == TType.BOOL:
15458 
          self.isUsable = iprot.readBool();
15459 
        else:
15460 
          iprot.skip(ftype)
15461 
      else:
15462 
        iprot.skip(ftype)
15463 
      iprot.readFieldEnd()
15464 
    iprot.readStructEnd()
15465 
 
15466 
  def write(self, oprot):
15467 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15468 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15469 
      return
15470 
    oprot.writeStructBegin('validateReturnProduct_args')
15471 
    if self.orderId is not None:
15472 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
15473 
      oprot.writeI64(self.orderId)
15474 
      oprot.writeFieldEnd()
15475 
    if self.isUsable is not None:
15476 
      oprot.writeFieldBegin('isUsable', TType.BOOL, 2)
15477 
      oprot.writeBool(self.isUsable)
15478 
      oprot.writeFieldEnd()
15479 
    oprot.writeFieldStop()
15480 
    oprot.writeStructEnd()
15481 
 
15482 
  def validate(self):
15483 
    return
15484 
 
15485 
 
15486 
  def __repr__(self):
15487 
    L = ['%s=%r' % (key, value)
15488 
      for key, value in self.__dict__.iteritems()]
15489 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15490 
 
15491 
  def __eq__(self, other):
15492 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15493 
 
15494 
  def __ne__(self, other):
15495 
    return not (self == other)
15496 
 
15497 
class validateReturnProduct_result:
15498 
  """
15499 
  Attributes:
15500 
   - success
15501 
   - ex
15502 
  """
15503 
 
15504 
  thrift_spec = (
15505 
    (0, TType.BOOL, 'success', None, None, ), # 0
15506 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
15507 
  )
15508 
 
15509 
  def __init__(self, success=None, ex=None,):
15510 
    self.success = success
15511 
    self.ex = ex
15512 
 
15513 
  def read(self, iprot):
15514 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15515 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15516 
      return
15517 
    iprot.readStructBegin()
15518 
    while True:
15519 
      (fname, ftype, fid) = iprot.readFieldBegin()
15520 
      if ftype == TType.STOP:
15521 
        break
15522 
      if fid == 0:
15523 
        if ftype == TType.BOOL:
15524 
          self.success = iprot.readBool();
15525 
        else:
15526 
          iprot.skip(ftype)
15527 
      elif fid == 1:
15528 
        if ftype == TType.STRUCT:
15529 
          self.ex = TransactionServiceException()
15530 
          self.ex.read(iprot)
15531 
        else:
15532 
          iprot.skip(ftype)
15533 
      else:
15534 
        iprot.skip(ftype)
15535 
      iprot.readFieldEnd()
15536 
    iprot.readStructEnd()
15537 
 
15538 
  def write(self, oprot):
15539 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15540 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15541 
      return
15542 
    oprot.writeStructBegin('validateReturnProduct_result')
15543 
    if self.success is not None:
15544 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
15545 
      oprot.writeBool(self.success)
15546 
      oprot.writeFieldEnd()
15547 
    if self.ex is not None:
15548 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
15549 
      self.ex.write(oprot)
15550 
      oprot.writeFieldEnd()
15551 
    oprot.writeFieldStop()
15552 
    oprot.writeStructEnd()
15553 
 
15554 
  def validate(self):
15555 
    return
15556 
 
15557 
 
15558 
  def __repr__(self):
15559 
    L = ['%s=%r' % (key, value)
15560 
      for key, value in self.__dict__.iteritems()]
15561 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15562 
 
15563 
  def __eq__(self, other):
15564 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15565 
 
15566 
  def __ne__(self, other):
15567 
    return not (self == other)
15568 
 
2616 chandransh 15569 
class reshipOrder_args:
15570 
  """
15571 
  Attributes:
15572 
   - orderId
15573 
  """
2591 chandransh 15574 
 
2616 chandransh 15575 
  thrift_spec = (
15576 
    None, # 0
15577 
    (1, TType.I64, 'orderId', None, None, ), # 1
15578 
  )
15579 
 
15580 
  def __init__(self, orderId=None,):
15581 
    self.orderId = orderId
15582 
 
15583 
  def read(self, iprot):
15584 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15585 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15586 
      return
15587 
    iprot.readStructBegin()
15588 
    while True:
15589 
      (fname, ftype, fid) = iprot.readFieldBegin()
15590 
      if ftype == TType.STOP:
15591 
        break
15592 
      if fid == 1:
15593 
        if ftype == TType.I64:
15594 
          self.orderId = iprot.readI64();
15595 
        else:
15596 
          iprot.skip(ftype)
15597 
      else:
15598 
        iprot.skip(ftype)
15599 
      iprot.readFieldEnd()
15600 
    iprot.readStructEnd()
15601 
 
15602 
  def write(self, oprot):
15603 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15604 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15605 
      return
15606 
    oprot.writeStructBegin('reshipOrder_args')
3431 rajveer 15607 
    if self.orderId is not None:
2616 chandransh 15608 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
15609 
      oprot.writeI64(self.orderId)
15610 
      oprot.writeFieldEnd()
15611 
    oprot.writeFieldStop()
15612 
    oprot.writeStructEnd()
15613 
 
3431 rajveer 15614 
  def validate(self):
15615 
    return
15616 
 
15617 
 
2616 chandransh 15618 
  def __repr__(self):
15619 
    L = ['%s=%r' % (key, value)
15620 
      for key, value in self.__dict__.iteritems()]
15621 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15622 
 
15623 
  def __eq__(self, other):
15624 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15625 
 
15626 
  def __ne__(self, other):
15627 
    return not (self == other)
15628 
 
15629 
class reshipOrder_result:
15630 
  """
15631 
  Attributes:
15632 
   - success
15633 
   - ex
15634 
  """
15635 
 
15636 
  thrift_spec = (
15637 
    (0, TType.I64, 'success', None, None, ), # 0
15638 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
15639 
  )
15640 
 
15641 
  def __init__(self, success=None, ex=None,):
15642 
    self.success = success
15643 
    self.ex = ex
15644 
 
15645 
  def read(self, iprot):
15646 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15647 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15648 
      return
15649 
    iprot.readStructBegin()
15650 
    while True:
15651 
      (fname, ftype, fid) = iprot.readFieldBegin()
15652 
      if ftype == TType.STOP:
15653 
        break
15654 
      if fid == 0:
15655 
        if ftype == TType.I64:
15656 
          self.success = iprot.readI64();
15657 
        else:
15658 
          iprot.skip(ftype)
15659 
      elif fid == 1:
15660 
        if ftype == TType.STRUCT:
15661 
          self.ex = TransactionServiceException()
15662 
          self.ex.read(iprot)
15663 
        else:
15664 
          iprot.skip(ftype)
15665 
      else:
15666 
        iprot.skip(ftype)
15667 
      iprot.readFieldEnd()
15668 
    iprot.readStructEnd()
15669 
 
15670 
  def write(self, oprot):
15671 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15672 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15673 
      return
15674 
    oprot.writeStructBegin('reshipOrder_result')
3431 rajveer 15675 
    if self.success is not None:
2616 chandransh 15676 
      oprot.writeFieldBegin('success', TType.I64, 0)
15677 
      oprot.writeI64(self.success)
15678 
      oprot.writeFieldEnd()
3431 rajveer 15679 
    if self.ex is not None:
2616 chandransh 15680 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
15681 
      self.ex.write(oprot)
15682 
      oprot.writeFieldEnd()
15683 
    oprot.writeFieldStop()
15684 
    oprot.writeStructEnd()
15685 
 
3431 rajveer 15686 
  def validate(self):
15687 
    return
15688 
 
15689 
 
2616 chandransh 15690 
  def __repr__(self):
15691 
    L = ['%s=%r' % (key, value)
15692 
      for key, value in self.__dict__.iteritems()]
15693 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15694 
 
15695 
  def __eq__(self, other):
15696 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15697 
 
15698 
  def __ne__(self, other):
15699 
    return not (self == other)
15700 
 
15701 
class refundOrder_args:
15702 
  """
15703 
  Attributes:
15704 
   - orderId
3226 chandransh 15705 
   - refundedBy
15706 
   - reason
2616 chandransh 15707 
  """
15708 
 
15709 
  thrift_spec = (
15710 
    None, # 0
15711 
    (1, TType.I64, 'orderId', None, None, ), # 1
3226 chandransh 15712 
    (2, TType.STRING, 'refundedBy', None, None, ), # 2
15713 
    (3, TType.STRING, 'reason', None, None, ), # 3
2616 chandransh 15714 
  )
15715 
 
3226 chandransh 15716 
  def __init__(self, orderId=None, refundedBy=None, reason=None,):
2616 chandransh 15717 
    self.orderId = orderId
3226 chandransh 15718 
    self.refundedBy = refundedBy
15719 
    self.reason = reason
2616 chandransh 15720 
 
15721 
  def read(self, iprot):
15722 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15723 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15724 
      return
15725 
    iprot.readStructBegin()
15726 
    while True:
15727 
      (fname, ftype, fid) = iprot.readFieldBegin()
15728 
      if ftype == TType.STOP:
15729 
        break
15730 
      if fid == 1:
15731 
        if ftype == TType.I64:
15732 
          self.orderId = iprot.readI64();
15733 
        else:
15734 
          iprot.skip(ftype)
3226 chandransh 15735 
      elif fid == 2:
15736 
        if ftype == TType.STRING:
15737 
          self.refundedBy = iprot.readString();
15738 
        else:
15739 
          iprot.skip(ftype)
15740 
      elif fid == 3:
15741 
        if ftype == TType.STRING:
15742 
          self.reason = iprot.readString();
15743 
        else:
15744 
          iprot.skip(ftype)
2616 chandransh 15745 
      else:
15746 
        iprot.skip(ftype)
15747 
      iprot.readFieldEnd()
15748 
    iprot.readStructEnd()
15749 
 
15750 
  def write(self, oprot):
15751 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15752 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15753 
      return
15754 
    oprot.writeStructBegin('refundOrder_args')
3431 rajveer 15755 
    if self.orderId is not None:
2616 chandransh 15756 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
15757 
      oprot.writeI64(self.orderId)
15758 
      oprot.writeFieldEnd()
3431 rajveer 15759 
    if self.refundedBy is not None:
3226 chandransh 15760 
      oprot.writeFieldBegin('refundedBy', TType.STRING, 2)
15761 
      oprot.writeString(self.refundedBy)
15762 
      oprot.writeFieldEnd()
3431 rajveer 15763 
    if self.reason is not None:
3226 chandransh 15764 
      oprot.writeFieldBegin('reason', TType.STRING, 3)
15765 
      oprot.writeString(self.reason)
15766 
      oprot.writeFieldEnd()
2616 chandransh 15767 
    oprot.writeFieldStop()
15768 
    oprot.writeStructEnd()
15769 
 
3431 rajveer 15770 
  def validate(self):
15771 
    return
15772 
 
15773 
 
2616 chandransh 15774 
  def __repr__(self):
15775 
    L = ['%s=%r' % (key, value)
15776 
      for key, value in self.__dict__.iteritems()]
15777 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15778 
 
15779 
  def __eq__(self, other):
15780 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15781 
 
15782 
  def __ne__(self, other):
15783 
    return not (self == other)
15784 
 
15785 
class refundOrder_result:
15786 
  """
15787 
  Attributes:
15788 
   - success
15789 
   - ex
15790 
  """
15791 
 
15792 
  thrift_spec = (
15793 
    (0, TType.BOOL, 'success', None, None, ), # 0
15794 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
15795 
  )
15796 
 
15797 
  def __init__(self, success=None, ex=None,):
15798 
    self.success = success
15799 
    self.ex = ex
15800 
 
15801 
  def read(self, iprot):
15802 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15803 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15804 
      return
15805 
    iprot.readStructBegin()
15806 
    while True:
15807 
      (fname, ftype, fid) = iprot.readFieldBegin()
15808 
      if ftype == TType.STOP:
15809 
        break
15810 
      if fid == 0:
15811 
        if ftype == TType.BOOL:
15812 
          self.success = iprot.readBool();
15813 
        else:
15814 
          iprot.skip(ftype)
15815 
      elif fid == 1:
15816 
        if ftype == TType.STRUCT:
15817 
          self.ex = TransactionServiceException()
15818 
          self.ex.read(iprot)
15819 
        else:
15820 
          iprot.skip(ftype)
15821 
      else:
15822 
        iprot.skip(ftype)
15823 
      iprot.readFieldEnd()
15824 
    iprot.readStructEnd()
15825 
 
15826 
  def write(self, oprot):
15827 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15828 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15829 
      return
15830 
    oprot.writeStructBegin('refundOrder_result')
3431 rajveer 15831 
    if self.success is not None:
2616 chandransh 15832 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
15833 
      oprot.writeBool(self.success)
15834 
      oprot.writeFieldEnd()
3431 rajveer 15835 
    if self.ex is not None:
2616 chandransh 15836 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
15837 
      self.ex.write(oprot)
15838 
      oprot.writeFieldEnd()
15839 
    oprot.writeFieldStop()
15840 
    oprot.writeStructEnd()
15841 
 
3431 rajveer 15842 
  def validate(self):
15843 
    return
15844 
 
15845 
 
2616 chandransh 15846 
  def __repr__(self):
15847 
    L = ['%s=%r' % (key, value)
15848 
      for key, value in self.__dict__.iteritems()]
15849 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15850 
 
15851 
  def __eq__(self, other):
15852 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15853 
 
15854 
  def __ne__(self, other):
15855 
    return not (self == other)
15856 
 
2690 chandransh 15857 
class getReturnOrders_args:
15858 
  """
15859 
  Attributes:
15860 
   - warehouseId
15861 
   - fromDate
15862 
   - toDate
15863 
  """
2616 chandransh 15864 
 
2690 chandransh 15865 
  thrift_spec = (
15866 
    None, # 0
15867 
    (1, TType.I64, 'warehouseId', None, None, ), # 1
15868 
    (2, TType.I64, 'fromDate', None, None, ), # 2
15869 
    (3, TType.I64, 'toDate', None, None, ), # 3
15870 
  )
15871 
 
15872 
  def __init__(self, warehouseId=None, fromDate=None, toDate=None,):
15873 
    self.warehouseId = warehouseId
15874 
    self.fromDate = fromDate
15875 
    self.toDate = toDate
15876 
 
15877 
  def read(self, iprot):
15878 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15879 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15880 
      return
15881 
    iprot.readStructBegin()
15882 
    while True:
15883 
      (fname, ftype, fid) = iprot.readFieldBegin()
15884 
      if ftype == TType.STOP:
15885 
        break
15886 
      if fid == 1:
15887 
        if ftype == TType.I64:
15888 
          self.warehouseId = iprot.readI64();
15889 
        else:
15890 
          iprot.skip(ftype)
15891 
      elif fid == 2:
15892 
        if ftype == TType.I64:
15893 
          self.fromDate = iprot.readI64();
15894 
        else:
15895 
          iprot.skip(ftype)
15896 
      elif fid == 3:
15897 
        if ftype == TType.I64:
15898 
          self.toDate = iprot.readI64();
15899 
        else:
15900 
          iprot.skip(ftype)
15901 
      else:
15902 
        iprot.skip(ftype)
15903 
      iprot.readFieldEnd()
15904 
    iprot.readStructEnd()
15905 
 
15906 
  def write(self, oprot):
15907 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15908 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15909 
      return
15910 
    oprot.writeStructBegin('getReturnOrders_args')
3431 rajveer 15911 
    if self.warehouseId is not None:
2690 chandransh 15912 
      oprot.writeFieldBegin('warehouseId', TType.I64, 1)
15913 
      oprot.writeI64(self.warehouseId)
15914 
      oprot.writeFieldEnd()
3431 rajveer 15915 
    if self.fromDate is not None:
2690 chandransh 15916 
      oprot.writeFieldBegin('fromDate', TType.I64, 2)
15917 
      oprot.writeI64(self.fromDate)
15918 
      oprot.writeFieldEnd()
3431 rajveer 15919 
    if self.toDate is not None:
2690 chandransh 15920 
      oprot.writeFieldBegin('toDate', TType.I64, 3)
15921 
      oprot.writeI64(self.toDate)
15922 
      oprot.writeFieldEnd()
15923 
    oprot.writeFieldStop()
15924 
    oprot.writeStructEnd()
15925 
 
3431 rajveer 15926 
  def validate(self):
15927 
    return
15928 
 
15929 
 
2690 chandransh 15930 
  def __repr__(self):
15931 
    L = ['%s=%r' % (key, value)
15932 
      for key, value in self.__dict__.iteritems()]
15933 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15934 
 
15935 
  def __eq__(self, other):
15936 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15937 
 
15938 
  def __ne__(self, other):
15939 
    return not (self == other)
15940 
 
15941 
class getReturnOrders_result:
15942 
  """
15943 
  Attributes:
15944 
   - success
15945 
  """
15946 
 
15947 
  thrift_spec = (
15948 
    (0, TType.LIST, 'success', (TType.STRUCT,(ReturnOrder, ReturnOrder.thrift_spec)), None, ), # 0
15949 
  )
15950 
 
15951 
  def __init__(self, success=None,):
15952 
    self.success = success
15953 
 
15954 
  def read(self, iprot):
15955 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15956 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15957 
      return
15958 
    iprot.readStructBegin()
15959 
    while True:
15960 
      (fname, ftype, fid) = iprot.readFieldBegin()
15961 
      if ftype == TType.STOP:
15962 
        break
15963 
      if fid == 0:
15964 
        if ftype == TType.LIST:
15965 
          self.success = []
5031 varun.gupt 15966 
          (_etype357, _size354) = iprot.readListBegin()
15967 
          for _i358 in xrange(_size354):
15968 
            _elem359 = ReturnOrder()
15969 
            _elem359.read(iprot)
15970 
            self.success.append(_elem359)
2690 chandransh 15971 
          iprot.readListEnd()
15972 
        else:
15973 
          iprot.skip(ftype)
15974 
      else:
15975 
        iprot.skip(ftype)
15976 
      iprot.readFieldEnd()
15977 
    iprot.readStructEnd()
15978 
 
15979 
  def write(self, oprot):
15980 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15981 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15982 
      return
15983 
    oprot.writeStructBegin('getReturnOrders_result')
3431 rajveer 15984 
    if self.success is not None:
2690 chandransh 15985 
      oprot.writeFieldBegin('success', TType.LIST, 0)
15986 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
5031 varun.gupt 15987 
      for iter360 in self.success:
15988 
        iter360.write(oprot)
2690 chandransh 15989 
      oprot.writeListEnd()
15990 
      oprot.writeFieldEnd()
15991 
    oprot.writeFieldStop()
15992 
    oprot.writeStructEnd()
15993 
 
3431 rajveer 15994 
  def validate(self):
15995 
    return
15996 
 
15997 
 
2690 chandransh 15998 
  def __repr__(self):
15999 
    L = ['%s=%r' % (key, value)
16000 
      for key, value in self.__dict__.iteritems()]
16001 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16002 
 
16003 
  def __eq__(self, other):
16004 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16005 
 
16006 
  def __ne__(self, other):
16007 
    return not (self == other)
16008 
 
2700 chandransh 16009 
class getReturnOrder_args:
16010 
  """
16011 
  Attributes:
16012 
   - id
16013 
  """
16014 
 
16015 
  thrift_spec = (
16016 
    None, # 0
16017 
    (1, TType.I64, 'id', None, None, ), # 1
16018 
  )
16019 
 
16020 
  def __init__(self, id=None,):
16021 
    self.id = id
16022 
 
16023 
  def read(self, iprot):
16024 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16025 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16026 
      return
16027 
    iprot.readStructBegin()
16028 
    while True:
16029 
      (fname, ftype, fid) = iprot.readFieldBegin()
16030 
      if ftype == TType.STOP:
16031 
        break
16032 
      if fid == 1:
16033 
        if ftype == TType.I64:
16034 
          self.id = iprot.readI64();
16035 
        else:
16036 
          iprot.skip(ftype)
16037 
      else:
16038 
        iprot.skip(ftype)
16039 
      iprot.readFieldEnd()
16040 
    iprot.readStructEnd()
16041 
 
16042 
  def write(self, oprot):
16043 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16044 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16045 
      return
16046 
    oprot.writeStructBegin('getReturnOrder_args')
3431 rajveer 16047 
    if self.id is not None:
2700 chandransh 16048 
      oprot.writeFieldBegin('id', TType.I64, 1)
16049 
      oprot.writeI64(self.id)
16050 
      oprot.writeFieldEnd()
16051 
    oprot.writeFieldStop()
16052 
    oprot.writeStructEnd()
16053 
 
3431 rajveer 16054 
  def validate(self):
16055 
    return
16056 
 
16057 
 
2700 chandransh 16058 
  def __repr__(self):
16059 
    L = ['%s=%r' % (key, value)
16060 
      for key, value in self.__dict__.iteritems()]
16061 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16062 
 
16063 
  def __eq__(self, other):
16064 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16065 
 
16066 
  def __ne__(self, other):
16067 
    return not (self == other)
16068 
 
16069 
class getReturnOrder_result:
16070 
  """
16071 
  Attributes:
16072 
   - success
16073 
   - ex
16074 
  """
16075 
 
16076 
  thrift_spec = (
16077 
    (0, TType.STRUCT, 'success', (ReturnOrder, ReturnOrder.thrift_spec), None, ), # 0
16078 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
16079 
  )
16080 
 
16081 
  def __init__(self, success=None, ex=None,):
16082 
    self.success = success
16083 
    self.ex = ex
16084 
 
16085 
  def read(self, iprot):
16086 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16087 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16088 
      return
16089 
    iprot.readStructBegin()
16090 
    while True:
16091 
      (fname, ftype, fid) = iprot.readFieldBegin()
16092 
      if ftype == TType.STOP:
16093 
        break
16094 
      if fid == 0:
16095 
        if ftype == TType.STRUCT:
16096 
          self.success = ReturnOrder()
16097 
          self.success.read(iprot)
16098 
        else:
16099 
          iprot.skip(ftype)
16100 
      elif fid == 1:
16101 
        if ftype == TType.STRUCT:
16102 
          self.ex = TransactionServiceException()
16103 
          self.ex.read(iprot)
16104 
        else:
16105 
          iprot.skip(ftype)
16106 
      else:
16107 
        iprot.skip(ftype)
16108 
      iprot.readFieldEnd()
16109 
    iprot.readStructEnd()
16110 
 
16111 
  def write(self, oprot):
16112 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16113 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16114 
      return
16115 
    oprot.writeStructBegin('getReturnOrder_result')
3431 rajveer 16116 
    if self.success is not None:
2700 chandransh 16117 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
16118 
      self.success.write(oprot)
16119 
      oprot.writeFieldEnd()
3431 rajveer 16120 
    if self.ex is not None:
2700 chandransh 16121 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
16122 
      self.ex.write(oprot)
16123 
      oprot.writeFieldEnd()
16124 
    oprot.writeFieldStop()
16125 
    oprot.writeStructEnd()
16126 
 
3431 rajveer 16127 
  def validate(self):
16128 
    return
16129 
 
16130 
 
2700 chandransh 16131 
  def __repr__(self):
16132 
    L = ['%s=%r' % (key, value)
16133 
      for key, value in self.__dict__.iteritems()]
16134 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16135 
 
16136 
  def __eq__(self, other):
16137 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16138 
 
16139 
  def __ne__(self, other):
16140 
    return not (self == other)
16141 
 
2690 chandransh 16142 
class processReturn_args:
16143 
  """
16144 
  Attributes:
16145 
   - returnOrderId
16146 
  """
16147 
 
16148 
  thrift_spec = (
16149 
    None, # 0
16150 
    (1, TType.I64, 'returnOrderId', None, None, ), # 1
16151 
  )
16152 
 
16153 
  def __init__(self, returnOrderId=None,):
16154 
    self.returnOrderId = returnOrderId
16155 
 
16156 
  def read(self, iprot):
16157 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16158 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16159 
      return
16160 
    iprot.readStructBegin()
16161 
    while True:
16162 
      (fname, ftype, fid) = iprot.readFieldBegin()
16163 
      if ftype == TType.STOP:
16164 
        break
16165 
      if fid == 1:
16166 
        if ftype == TType.I64:
16167 
          self.returnOrderId = iprot.readI64();
16168 
        else:
16169 
          iprot.skip(ftype)
16170 
      else:
16171 
        iprot.skip(ftype)
16172 
      iprot.readFieldEnd()
16173 
    iprot.readStructEnd()
16174 
 
16175 
  def write(self, oprot):
16176 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16177 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16178 
      return
16179 
    oprot.writeStructBegin('processReturn_args')
3431 rajveer 16180 
    if self.returnOrderId is not None:
2690 chandransh 16181 
      oprot.writeFieldBegin('returnOrderId', TType.I64, 1)
16182 
      oprot.writeI64(self.returnOrderId)
16183 
      oprot.writeFieldEnd()
16184 
    oprot.writeFieldStop()
16185 
    oprot.writeStructEnd()
16186 
 
3431 rajveer 16187 
  def validate(self):
16188 
    return
16189 
 
16190 
 
2690 chandransh 16191 
  def __repr__(self):
16192 
    L = ['%s=%r' % (key, value)
16193 
      for key, value in self.__dict__.iteritems()]
16194 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16195 
 
16196 
  def __eq__(self, other):
16197 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16198 
 
16199 
  def __ne__(self, other):
16200 
    return not (self == other)
16201 
 
16202 
class processReturn_result:
16203 
  """
16204 
  Attributes:
16205 
   - ex
16206 
  """
16207 
 
16208 
  thrift_spec = (
16209 
    None, # 0
16210 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
16211 
  )
16212 
 
16213 
  def __init__(self, ex=None,):
16214 
    self.ex = ex
16215 
 
16216 
  def read(self, iprot):
16217 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16218 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16219 
      return
16220 
    iprot.readStructBegin()
16221 
    while True:
16222 
      (fname, ftype, fid) = iprot.readFieldBegin()
16223 
      if ftype == TType.STOP:
16224 
        break
16225 
      if fid == 1:
16226 
        if ftype == TType.STRUCT:
16227 
          self.ex = TransactionServiceException()
16228 
          self.ex.read(iprot)
16229 
        else:
16230 
          iprot.skip(ftype)
16231 
      else:
16232 
        iprot.skip(ftype)
16233 
      iprot.readFieldEnd()
16234 
    iprot.readStructEnd()
16235 
 
16236 
  def write(self, oprot):
16237 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16238 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16239 
      return
16240 
    oprot.writeStructBegin('processReturn_result')
3431 rajveer 16241 
    if self.ex is not None:
2690 chandransh 16242 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
16243 
      self.ex.write(oprot)
16244 
      oprot.writeFieldEnd()
16245 
    oprot.writeFieldStop()
16246 
    oprot.writeStructEnd()
16247 
 
3431 rajveer 16248 
  def validate(self):
16249 
    return
16250 
 
16251 
 
2690 chandransh 16252 
  def __repr__(self):
16253 
    L = ['%s=%r' % (key, value)
16254 
      for key, value in self.__dict__.iteritems()]
16255 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16256 
 
16257 
  def __eq__(self, other):
16258 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16259 
 
16260 
  def __ne__(self, other):
16261 
    return not (self == other)
16262 
 
3451 chandransh 16263 
class updateWeight_args:
16264 
  """
16265 
  Attributes:
16266 
   - orderId
16267 
   - weight
16268 
  """
16269 
 
16270 
  thrift_spec = (
16271 
    None, # 0
16272 
    (1, TType.I64, 'orderId', None, None, ), # 1
16273 
    (2, TType.DOUBLE, 'weight', None, None, ), # 2
16274 
  )
16275 
 
16276 
  def __init__(self, orderId=None, weight=None,):
16277 
    self.orderId = orderId
16278 
    self.weight = weight
16279 
 
16280 
  def read(self, iprot):
16281 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16282 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16283 
      return
16284 
    iprot.readStructBegin()
16285 
    while True:
16286 
      (fname, ftype, fid) = iprot.readFieldBegin()
16287 
      if ftype == TType.STOP:
16288 
        break
16289 
      if fid == 1:
16290 
        if ftype == TType.I64:
16291 
          self.orderId = iprot.readI64();
16292 
        else:
16293 
          iprot.skip(ftype)
16294 
      elif fid == 2:
16295 
        if ftype == TType.DOUBLE:
16296 
          self.weight = iprot.readDouble();
16297 
        else:
16298 
          iprot.skip(ftype)
16299 
      else:
16300 
        iprot.skip(ftype)
16301 
      iprot.readFieldEnd()
16302 
    iprot.readStructEnd()
16303 
 
16304 
  def write(self, oprot):
16305 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16306 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16307 
      return
16308 
    oprot.writeStructBegin('updateWeight_args')
16309 
    if self.orderId is not None:
16310 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
16311 
      oprot.writeI64(self.orderId)
16312 
      oprot.writeFieldEnd()
16313 
    if self.weight is not None:
16314 
      oprot.writeFieldBegin('weight', TType.DOUBLE, 2)
16315 
      oprot.writeDouble(self.weight)
16316 
      oprot.writeFieldEnd()
16317 
    oprot.writeFieldStop()
16318 
    oprot.writeStructEnd()
16319 
 
16320 
  def validate(self):
16321 
    return
16322 
 
16323 
 
16324 
  def __repr__(self):
16325 
    L = ['%s=%r' % (key, value)
16326 
      for key, value in self.__dict__.iteritems()]
16327 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16328 
 
16329 
  def __eq__(self, other):
16330 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16331 
 
16332 
  def __ne__(self, other):
16333 
    return not (self == other)
16334 
 
16335 
class updateWeight_result:
16336 
  """
16337 
  Attributes:
16338 
   - success
16339 
   - ex
16340 
  """
16341 
 
16342 
  thrift_spec = (
16343 
    (0, TType.STRUCT, 'success', (Order, Order.thrift_spec), None, ), # 0
16344 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
16345 
  )
16346 
 
16347 
  def __init__(self, success=None, ex=None,):
16348 
    self.success = success
16349 
    self.ex = ex
16350 
 
16351 
  def read(self, iprot):
16352 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16353 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16354 
      return
16355 
    iprot.readStructBegin()
16356 
    while True:
16357 
      (fname, ftype, fid) = iprot.readFieldBegin()
16358 
      if ftype == TType.STOP:
16359 
        break
16360 
      if fid == 0:
16361 
        if ftype == TType.STRUCT:
16362 
          self.success = Order()
16363 
          self.success.read(iprot)
16364 
        else:
16365 
          iprot.skip(ftype)
16366 
      elif fid == 1:
16367 
        if ftype == TType.STRUCT:
16368 
          self.ex = TransactionServiceException()
16369 
          self.ex.read(iprot)
16370 
        else:
16371 
          iprot.skip(ftype)
16372 
      else:
16373 
        iprot.skip(ftype)
16374 
      iprot.readFieldEnd()
16375 
    iprot.readStructEnd()
16376 
 
16377 
  def write(self, oprot):
16378 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16379 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16380 
      return
16381 
    oprot.writeStructBegin('updateWeight_result')
16382 
    if self.success is not None:
16383 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
16384 
      self.success.write(oprot)
16385 
      oprot.writeFieldEnd()
16386 
    if self.ex is not None:
16387 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
16388 
      self.ex.write(oprot)
16389 
      oprot.writeFieldEnd()
16390 
    oprot.writeFieldStop()
16391 
    oprot.writeStructEnd()
16392 
 
16393 
  def validate(self):
16394 
    return
16395 
 
16396 
 
16397 
  def __repr__(self):
16398 
    L = ['%s=%r' % (key, value)
16399 
      for key, value in self.__dict__.iteritems()]
16400 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16401 
 
16402 
  def __eq__(self, other):
16403 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16404 
 
16405 
  def __ne__(self, other):
16406 
    return not (self == other)
3469 chandransh 16407 
 
16408 
class changeItem_args:
16409 
  """
16410 
  Attributes:
16411 
   - orderId
16412 
   - itemId
16413 
  """
16414 
 
16415 
  thrift_spec = (
16416 
    None, # 0
16417 
    (1, TType.I64, 'orderId', None, None, ), # 1
16418 
    (2, TType.I64, 'itemId', None, None, ), # 2
16419 
  )
16420 
 
16421 
  def __init__(self, orderId=None, itemId=None,):
16422 
    self.orderId = orderId
16423 
    self.itemId = itemId
16424 
 
16425 
  def read(self, iprot):
16426 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16427 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16428 
      return
16429 
    iprot.readStructBegin()
16430 
    while True:
16431 
      (fname, ftype, fid) = iprot.readFieldBegin()
16432 
      if ftype == TType.STOP:
16433 
        break
16434 
      if fid == 1:
16435 
        if ftype == TType.I64:
16436 
          self.orderId = iprot.readI64();
16437 
        else:
16438 
          iprot.skip(ftype)
16439 
      elif fid == 2:
16440 
        if ftype == TType.I64:
16441 
          self.itemId = iprot.readI64();
16442 
        else:
16443 
          iprot.skip(ftype)
16444 
      else:
16445 
        iprot.skip(ftype)
16446 
      iprot.readFieldEnd()
16447 
    iprot.readStructEnd()
16448 
 
16449 
  def write(self, oprot):
16450 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16451 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16452 
      return
16453 
    oprot.writeStructBegin('changeItem_args')
16454 
    if self.orderId is not None:
16455 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
16456 
      oprot.writeI64(self.orderId)
16457 
      oprot.writeFieldEnd()
16458 
    if self.itemId is not None:
16459 
      oprot.writeFieldBegin('itemId', TType.I64, 2)
16460 
      oprot.writeI64(self.itemId)
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)
16479 
 
16480 
class changeItem_result:
16481 
  """
16482 
  Attributes:
16483 
   - success
16484 
   - ex
16485 
  """
16486 
 
16487 
  thrift_spec = (
16488 
    (0, TType.STRUCT, 'success', (Order, Order.thrift_spec), None, ), # 0
16489 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
16490 
  )
16491 
 
16492 
  def __init__(self, success=None, ex=None,):
16493 
    self.success = success
16494 
    self.ex = ex
16495 
 
16496 
  def read(self, iprot):
16497 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16498 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16499 
      return
16500 
    iprot.readStructBegin()
16501 
    while True:
16502 
      (fname, ftype, fid) = iprot.readFieldBegin()
16503 
      if ftype == TType.STOP:
16504 
        break
16505 
      if fid == 0:
16506 
        if ftype == TType.STRUCT:
16507 
          self.success = Order()
16508 
          self.success.read(iprot)
16509 
        else:
16510 
          iprot.skip(ftype)
16511 
      elif fid == 1:
16512 
        if ftype == TType.STRUCT:
16513 
          self.ex = TransactionServiceException()
16514 
          self.ex.read(iprot)
16515 
        else:
16516 
          iprot.skip(ftype)
16517 
      else:
16518 
        iprot.skip(ftype)
16519 
      iprot.readFieldEnd()
16520 
    iprot.readStructEnd()
16521 
 
16522 
  def write(self, oprot):
16523 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16524 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16525 
      return
16526 
    oprot.writeStructBegin('changeItem_result')
16527 
    if self.success is not None:
16528 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
16529 
      self.success.write(oprot)
16530 
      oprot.writeFieldEnd()
16531 
    if self.ex is not None:
16532 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
16533 
      self.ex.write(oprot)
16534 
      oprot.writeFieldEnd()
16535 
    oprot.writeFieldStop()
16536 
    oprot.writeStructEnd()
16537 
 
16538 
  def validate(self):
16539 
    return
16540 
 
16541 
 
16542 
  def __repr__(self):
16543 
    L = ['%s=%r' % (key, value)
16544 
      for key, value in self.__dict__.iteritems()]
16545 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16546 
 
16547 
  def __eq__(self, other):
16548 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16549 
 
16550 
  def __ne__(self, other):
16551 
    return not (self == other)
16552 
 
16553 
class shiftToWarehouse_args:
16554 
  """
16555 
  Attributes:
16556 
   - orderId
16557 
   - warehouseId
16558 
  """
16559 
 
16560 
  thrift_spec = (
16561 
    None, # 0
16562 
    (1, TType.I64, 'orderId', None, None, ), # 1
16563 
    (2, TType.I64, 'warehouseId', None, None, ), # 2
16564 
  )
16565 
 
16566 
  def __init__(self, orderId=None, warehouseId=None,):
16567 
    self.orderId = orderId
16568 
    self.warehouseId = warehouseId
16569 
 
16570 
  def read(self, iprot):
16571 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16572 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16573 
      return
16574 
    iprot.readStructBegin()
16575 
    while True:
16576 
      (fname, ftype, fid) = iprot.readFieldBegin()
16577 
      if ftype == TType.STOP:
16578 
        break
16579 
      if fid == 1:
16580 
        if ftype == TType.I64:
16581 
          self.orderId = iprot.readI64();
16582 
        else:
16583 
          iprot.skip(ftype)
16584 
      elif fid == 2:
16585 
        if ftype == TType.I64:
16586 
          self.warehouseId = iprot.readI64();
16587 
        else:
16588 
          iprot.skip(ftype)
16589 
      else:
16590 
        iprot.skip(ftype)
16591 
      iprot.readFieldEnd()
16592 
    iprot.readStructEnd()
16593 
 
16594 
  def write(self, oprot):
16595 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16596 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16597 
      return
16598 
    oprot.writeStructBegin('shiftToWarehouse_args')
16599 
    if self.orderId is not None:
16600 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
16601 
      oprot.writeI64(self.orderId)
16602 
      oprot.writeFieldEnd()
16603 
    if self.warehouseId is not None:
16604 
      oprot.writeFieldBegin('warehouseId', TType.I64, 2)
16605 
      oprot.writeI64(self.warehouseId)
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)
16624 
 
16625 
class shiftToWarehouse_result:
16626 
  """
16627 
  Attributes:
16628 
   - success
16629 
   - ex
16630 
  """
16631 
 
16632 
  thrift_spec = (
16633 
    (0, TType.STRUCT, 'success', (Order, Order.thrift_spec), None, ), # 0
16634 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
16635 
  )
16636 
 
16637 
  def __init__(self, success=None, ex=None,):
16638 
    self.success = success
16639 
    self.ex = ex
16640 
 
16641 
  def read(self, iprot):
16642 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16643 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16644 
      return
16645 
    iprot.readStructBegin()
16646 
    while True:
16647 
      (fname, ftype, fid) = iprot.readFieldBegin()
16648 
      if ftype == TType.STOP:
16649 
        break
16650 
      if fid == 0:
16651 
        if ftype == TType.STRUCT:
16652 
          self.success = Order()
16653 
          self.success.read(iprot)
16654 
        else:
16655 
          iprot.skip(ftype)
16656 
      elif fid == 1:
16657 
        if ftype == TType.STRUCT:
16658 
          self.ex = TransactionServiceException()
16659 
          self.ex.read(iprot)
16660 
        else:
16661 
          iprot.skip(ftype)
16662 
      else:
16663 
        iprot.skip(ftype)
16664 
      iprot.readFieldEnd()
16665 
    iprot.readStructEnd()
16666 
 
16667 
  def write(self, oprot):
16668 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16669 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16670 
      return
16671 
    oprot.writeStructBegin('shiftToWarehouse_result')
16672 
    if self.success is not None:
16673 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
16674 
      self.success.write(oprot)
16675 
      oprot.writeFieldEnd()
16676 
    if self.ex is not None:
16677 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
16678 
      self.ex.write(oprot)
16679 
      oprot.writeFieldEnd()
16680 
    oprot.writeFieldStop()
16681 
    oprot.writeStructEnd()
16682 
 
16683 
  def validate(self):
16684 
    return
16685 
 
16686 
 
16687 
  def __repr__(self):
16688 
    L = ['%s=%r' % (key, value)
16689 
      for key, value in self.__dict__.iteritems()]
16690 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16691 
 
16692 
  def __eq__(self, other):
16693 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16694 
 
16695 
  def __ne__(self, other):
16696 
    return not (self == other)
3553 chandransh 16697 
 
16698 
class addDelayReason_args:
16699 
  """
16700 
  Attributes:
16701 
   - orderId
16702 
   - delayReason
3986 chandransh 16703 
   - furtherDelay
4647 rajveer 16704 
   - delayReasonText
3553 chandransh 16705 
  """
16706 
 
16707 
  thrift_spec = (
16708 
    None, # 0
16709 
    (1, TType.I64, 'orderId', None, None, ), # 1
16710 
    (2, TType.I32, 'delayReason', None, None, ), # 2
3986 chandransh 16711 
    (3, TType.I64, 'furtherDelay', None, None, ), # 3
4647 rajveer 16712 
    (4, TType.STRING, 'delayReasonText', None, None, ), # 4
3553 chandransh 16713 
  )
16714 
 
4647 rajveer 16715 
  def __init__(self, orderId=None, delayReason=None, furtherDelay=None, delayReasonText=None,):
3553 chandransh 16716 
    self.orderId = orderId
16717 
    self.delayReason = delayReason
3986 chandransh 16718 
    self.furtherDelay = furtherDelay
4647 rajveer 16719 
    self.delayReasonText = delayReasonText
3553 chandransh 16720 
 
16721 
  def read(self, iprot):
16722 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16723 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16724 
      return
16725 
    iprot.readStructBegin()
16726 
    while True:
16727 
      (fname, ftype, fid) = iprot.readFieldBegin()
16728 
      if ftype == TType.STOP:
16729 
        break
16730 
      if fid == 1:
16731 
        if ftype == TType.I64:
16732 
          self.orderId = iprot.readI64();
16733 
        else:
16734 
          iprot.skip(ftype)
16735 
      elif fid == 2:
16736 
        if ftype == TType.I32:
16737 
          self.delayReason = iprot.readI32();
16738 
        else:
16739 
          iprot.skip(ftype)
3986 chandransh 16740 
      elif fid == 3:
16741 
        if ftype == TType.I64:
16742 
          self.furtherDelay = iprot.readI64();
16743 
        else:
16744 
          iprot.skip(ftype)
4647 rajveer 16745 
      elif fid == 4:
16746 
        if ftype == TType.STRING:
16747 
          self.delayReasonText = iprot.readString();
16748 
        else:
16749 
          iprot.skip(ftype)
3553 chandransh 16750 
      else:
16751 
        iprot.skip(ftype)
16752 
      iprot.readFieldEnd()
16753 
    iprot.readStructEnd()
16754 
 
16755 
  def write(self, oprot):
16756 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16757 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16758 
      return
16759 
    oprot.writeStructBegin('addDelayReason_args')
16760 
    if self.orderId is not None:
16761 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
16762 
      oprot.writeI64(self.orderId)
16763 
      oprot.writeFieldEnd()
16764 
    if self.delayReason is not None:
16765 
      oprot.writeFieldBegin('delayReason', TType.I32, 2)
16766 
      oprot.writeI32(self.delayReason)
16767 
      oprot.writeFieldEnd()
3986 chandransh 16768 
    if self.furtherDelay is not None:
16769 
      oprot.writeFieldBegin('furtherDelay', TType.I64, 3)
16770 
      oprot.writeI64(self.furtherDelay)
16771 
      oprot.writeFieldEnd()
4647 rajveer 16772 
    if self.delayReasonText is not None:
16773 
      oprot.writeFieldBegin('delayReasonText', TType.STRING, 4)
16774 
      oprot.writeString(self.delayReasonText)
16775 
      oprot.writeFieldEnd()
3553 chandransh 16776 
    oprot.writeFieldStop()
16777 
    oprot.writeStructEnd()
16778 
 
16779 
  def validate(self):
16780 
    return
16781 
 
16782 
 
16783 
  def __repr__(self):
16784 
    L = ['%s=%r' % (key, value)
16785 
      for key, value in self.__dict__.iteritems()]
16786 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16787 
 
16788 
  def __eq__(self, other):
16789 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16790 
 
16791 
  def __ne__(self, other):
16792 
    return not (self == other)
16793 
 
16794 
class addDelayReason_result:
16795 
  """
16796 
  Attributes:
16797 
   - success
16798 
   - ex
16799 
  """
16800 
 
16801 
  thrift_spec = (
16802 
    (0, TType.BOOL, 'success', None, None, ), # 0
16803 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
16804 
  )
16805 
 
16806 
  def __init__(self, success=None, ex=None,):
16807 
    self.success = success
16808 
    self.ex = ex
16809 
 
16810 
  def read(self, iprot):
16811 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16812 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16813 
      return
16814 
    iprot.readStructBegin()
16815 
    while True:
16816 
      (fname, ftype, fid) = iprot.readFieldBegin()
16817 
      if ftype == TType.STOP:
16818 
        break
16819 
      if fid == 0:
16820 
        if ftype == TType.BOOL:
16821 
          self.success = iprot.readBool();
16822 
        else:
16823 
          iprot.skip(ftype)
16824 
      elif fid == 1:
16825 
        if ftype == TType.STRUCT:
16826 
          self.ex = TransactionServiceException()
16827 
          self.ex.read(iprot)
16828 
        else:
16829 
          iprot.skip(ftype)
16830 
      else:
16831 
        iprot.skip(ftype)
16832 
      iprot.readFieldEnd()
16833 
    iprot.readStructEnd()
16834 
 
16835 
  def write(self, oprot):
16836 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16837 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16838 
      return
16839 
    oprot.writeStructBegin('addDelayReason_result')
16840 
    if self.success is not None:
16841 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
16842 
      oprot.writeBool(self.success)
16843 
      oprot.writeFieldEnd()
16844 
    if self.ex is not None:
16845 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
16846 
      self.ex.write(oprot)
16847 
      oprot.writeFieldEnd()
16848 
    oprot.writeFieldStop()
16849 
    oprot.writeStructEnd()
16850 
 
16851 
  def validate(self):
16852 
    return
16853 
 
16854 
 
16855 
  def __repr__(self):
16856 
    L = ['%s=%r' % (key, value)
16857 
      for key, value in self.__dict__.iteritems()]
16858 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16859 
 
16860 
  def __eq__(self, other):
16861 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16862 
 
16863 
  def __ne__(self, other):
16864 
    return not (self == other)
3956 chandransh 16865 
 
16866 
class reconcileCodCollection_args:
16867 
  """
16868 
  Attributes:
16869 
   - collectedAmountMap
16870 
   - xferBy
16871 
   - xferTxnId
16872 
   - xferDate
16873 
  """
16874 
 
16875 
  thrift_spec = (
16876 
    None, # 0
16877 
    (1, TType.MAP, 'collectedAmountMap', (TType.STRING,None,TType.DOUBLE,None), None, ), # 1
16878 
    (2, TType.STRING, 'xferBy', None, None, ), # 2
16879 
    (3, TType.STRING, 'xferTxnId', None, None, ), # 3
16880 
    (4, TType.I64, 'xferDate', None, None, ), # 4
16881 
  )
16882 
 
16883 
  def __init__(self, collectedAmountMap=None, xferBy=None, xferTxnId=None, xferDate=None,):
16884 
    self.collectedAmountMap = collectedAmountMap
16885 
    self.xferBy = xferBy
16886 
    self.xferTxnId = xferTxnId
16887 
    self.xferDate = xferDate
16888 
 
16889 
  def read(self, iprot):
16890 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16891 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16892 
      return
16893 
    iprot.readStructBegin()
16894 
    while True:
16895 
      (fname, ftype, fid) = iprot.readFieldBegin()
16896 
      if ftype == TType.STOP:
16897 
        break
16898 
      if fid == 1:
16899 
        if ftype == TType.MAP:
16900 
          self.collectedAmountMap = {}
5031 varun.gupt 16901 
          (_ktype362, _vtype363, _size361 ) = iprot.readMapBegin()
16902 
          for _i365 in xrange(_size361):
16903 
            _key366 = iprot.readString();
16904 
            _val367 = iprot.readDouble();
16905 
            self.collectedAmountMap[_key366] = _val367
3956 chandransh 16906 
          iprot.readMapEnd()
16907 
        else:
16908 
          iprot.skip(ftype)
16909 
      elif fid == 2:
16910 
        if ftype == TType.STRING:
16911 
          self.xferBy = iprot.readString();
16912 
        else:
16913 
          iprot.skip(ftype)
16914 
      elif fid == 3:
16915 
        if ftype == TType.STRING:
16916 
          self.xferTxnId = iprot.readString();
16917 
        else:
16918 
          iprot.skip(ftype)
16919 
      elif fid == 4:
16920 
        if ftype == TType.I64:
16921 
          self.xferDate = iprot.readI64();
16922 
        else:
16923 
          iprot.skip(ftype)
16924 
      else:
16925 
        iprot.skip(ftype)
16926 
      iprot.readFieldEnd()
16927 
    iprot.readStructEnd()
16928 
 
16929 
  def write(self, oprot):
16930 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16931 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16932 
      return
16933 
    oprot.writeStructBegin('reconcileCodCollection_args')
16934 
    if self.collectedAmountMap is not None:
16935 
      oprot.writeFieldBegin('collectedAmountMap', TType.MAP, 1)
16936 
      oprot.writeMapBegin(TType.STRING, TType.DOUBLE, len(self.collectedAmountMap))
5031 varun.gupt 16937 
      for kiter368,viter369 in self.collectedAmountMap.items():
16938 
        oprot.writeString(kiter368)
16939 
        oprot.writeDouble(viter369)
3956 chandransh 16940 
      oprot.writeMapEnd()
16941 
      oprot.writeFieldEnd()
16942 
    if self.xferBy is not None:
16943 
      oprot.writeFieldBegin('xferBy', TType.STRING, 2)
16944 
      oprot.writeString(self.xferBy)
16945 
      oprot.writeFieldEnd()
16946 
    if self.xferTxnId is not None:
16947 
      oprot.writeFieldBegin('xferTxnId', TType.STRING, 3)
16948 
      oprot.writeString(self.xferTxnId)
16949 
      oprot.writeFieldEnd()
16950 
    if self.xferDate is not None:
16951 
      oprot.writeFieldBegin('xferDate', TType.I64, 4)
16952 
      oprot.writeI64(self.xferDate)
16953 
      oprot.writeFieldEnd()
16954 
    oprot.writeFieldStop()
16955 
    oprot.writeStructEnd()
16956 
 
16957 
  def validate(self):
16958 
    return
16959 
 
16960 
 
16961 
  def __repr__(self):
16962 
    L = ['%s=%r' % (key, value)
16963 
      for key, value in self.__dict__.iteritems()]
16964 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16965 
 
16966 
  def __eq__(self, other):
16967 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16968 
 
16969 
  def __ne__(self, other):
16970 
    return not (self == other)
16971 
 
16972 
class reconcileCodCollection_result:
16973 
  """
16974 
  Attributes:
16975 
   - success
16976 
   - ex
16977 
  """
16978 
 
16979 
  thrift_spec = (
16980 
    (0, TType.MAP, 'success', (TType.STRING,None,TType.STRING,None), None, ), # 0
16981 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
16982 
  )
16983 
 
16984 
  def __init__(self, success=None, ex=None,):
16985 
    self.success = success
16986 
    self.ex = ex
16987 
 
16988 
  def read(self, iprot):
16989 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16990 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16991 
      return
16992 
    iprot.readStructBegin()
16993 
    while True:
16994 
      (fname, ftype, fid) = iprot.readFieldBegin()
16995 
      if ftype == TType.STOP:
16996 
        break
16997 
      if fid == 0:
16998 
        if ftype == TType.MAP:
16999 
          self.success = {}
5031 varun.gupt 17000 
          (_ktype371, _vtype372, _size370 ) = iprot.readMapBegin()
17001 
          for _i374 in xrange(_size370):
17002 
            _key375 = iprot.readString();
17003 
            _val376 = iprot.readString();
17004 
            self.success[_key375] = _val376
3956 chandransh 17005 
          iprot.readMapEnd()
17006 
        else:
17007 
          iprot.skip(ftype)
17008 
      elif fid == 1:
17009 
        if ftype == TType.STRUCT:
17010 
          self.ex = TransactionServiceException()
17011 
          self.ex.read(iprot)
17012 
        else:
17013 
          iprot.skip(ftype)
17014 
      else:
17015 
        iprot.skip(ftype)
17016 
      iprot.readFieldEnd()
17017 
    iprot.readStructEnd()
17018 
 
17019 
  def write(self, oprot):
17020 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
17021 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
17022 
      return
17023 
    oprot.writeStructBegin('reconcileCodCollection_result')
17024 
    if self.success is not None:
17025 
      oprot.writeFieldBegin('success', TType.MAP, 0)
17026 
      oprot.writeMapBegin(TType.STRING, TType.STRING, len(self.success))
5031 varun.gupt 17027 
      for kiter377,viter378 in self.success.items():
17028 
        oprot.writeString(kiter377)
17029 
        oprot.writeString(viter378)
3956 chandransh 17030 
      oprot.writeMapEnd()
17031 
      oprot.writeFieldEnd()
17032 
    if self.ex is not None:
17033 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
17034 
      self.ex.write(oprot)
17035 
      oprot.writeFieldEnd()
17036 
    oprot.writeFieldStop()
17037 
    oprot.writeStructEnd()
17038 
 
17039 
  def validate(self):
17040 
    return
17041 
 
17042 
 
17043 
  def __repr__(self):
17044 
    L = ['%s=%r' % (key, value)
17045 
      for key, value in self.__dict__.iteritems()]
17046 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
17047 
 
17048 
  def __eq__(self, other):
17049 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
17050 
 
17051 
  def __ne__(self, other):
17052 
    return not (self == other)
4008 mandeep.dh 17053 
 
17054 
class getTransactionsRequiringExtraProcessing_args:
17055 
  """
17056 
  Attributes:
17057 
   - category
17058 
  """
17059 
 
17060 
  thrift_spec = (
17061 
    None, # 0
17062 
    (1, TType.I32, 'category', None, None, ), # 1
17063 
  )
17064 
 
17065 
  def __init__(self, category=None,):
17066 
    self.category = category
17067 
 
17068 
  def read(self, iprot):
17069 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
17070 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
17071 
      return
17072 
    iprot.readStructBegin()
17073 
    while True:
17074 
      (fname, ftype, fid) = iprot.readFieldBegin()
17075 
      if ftype == TType.STOP:
17076 
        break
17077 
      if fid == 1:
17078 
        if ftype == TType.I32:
17079 
          self.category = iprot.readI32();
17080 
        else:
17081 
          iprot.skip(ftype)
17082 
      else:
17083 
        iprot.skip(ftype)
17084 
      iprot.readFieldEnd()
17085 
    iprot.readStructEnd()
17086 
 
17087 
  def write(self, oprot):
17088 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
17089 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
17090 
      return
17091 
    oprot.writeStructBegin('getTransactionsRequiringExtraProcessing_args')
17092 
    if self.category is not None:
17093 
      oprot.writeFieldBegin('category', TType.I32, 1)
17094 
      oprot.writeI32(self.category)
17095 
      oprot.writeFieldEnd()
17096 
    oprot.writeFieldStop()
17097 
    oprot.writeStructEnd()
17098 
 
17099 
  def validate(self):
17100 
    return
17101 
 
17102 
 
17103 
  def __repr__(self):
17104 
    L = ['%s=%r' % (key, value)
17105 
      for key, value in self.__dict__.iteritems()]
17106 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
17107 
 
17108 
  def __eq__(self, other):
17109 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
17110 
 
17111 
  def __ne__(self, other):
17112 
    return not (self == other)
17113 
 
17114 
class getTransactionsRequiringExtraProcessing_result:
17115 
  """
17116 
  Attributes:
17117 
   - success
17118 
  """
17119 
 
17120 
  thrift_spec = (
17121 
    (0, TType.LIST, 'success', (TType.I64,None), None, ), # 0
17122 
  )
17123 
 
17124 
  def __init__(self, success=None,):
17125 
    self.success = success
17126 
 
17127 
  def read(self, iprot):
17128 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
17129 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
17130 
      return
17131 
    iprot.readStructBegin()
17132 
    while True:
17133 
      (fname, ftype, fid) = iprot.readFieldBegin()
17134 
      if ftype == TType.STOP:
17135 
        break
17136 
      if fid == 0:
17137 
        if ftype == TType.LIST:
17138 
          self.success = []
5031 varun.gupt 17139 
          (_etype382, _size379) = iprot.readListBegin()
17140 
          for _i383 in xrange(_size379):
17141 
            _elem384 = iprot.readI64();
17142 
            self.success.append(_elem384)
4008 mandeep.dh 17143 
          iprot.readListEnd()
17144 
        else:
17145 
          iprot.skip(ftype)
17146 
      else:
17147 
        iprot.skip(ftype)
17148 
      iprot.readFieldEnd()
17149 
    iprot.readStructEnd()
17150 
 
17151 
  def write(self, oprot):
17152 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
17153 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
17154 
      return
17155 
    oprot.writeStructBegin('getTransactionsRequiringExtraProcessing_result')
17156 
    if self.success is not None:
17157 
      oprot.writeFieldBegin('success', TType.LIST, 0)
17158 
      oprot.writeListBegin(TType.I64, len(self.success))
5031 varun.gupt 17159 
      for iter385 in self.success:
17160 
        oprot.writeI64(iter385)
4008 mandeep.dh 17161 
      oprot.writeListEnd()
17162 
      oprot.writeFieldEnd()
17163 
    oprot.writeFieldStop()
17164 
    oprot.writeStructEnd()
17165 
 
17166 
  def validate(self):
17167 
    return
17168 
 
17169 
 
17170 
  def __repr__(self):
17171 
    L = ['%s=%r' % (key, value)
17172 
      for key, value in self.__dict__.iteritems()]
17173 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
17174 
 
17175 
  def __eq__(self, other):
17176 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
17177 
 
17178 
  def __ne__(self, other):
17179 
    return not (self == other)
17180 
 
17181 
class markTransactionAsProcessed_args:
17182 
  """
17183 
  Attributes:
17184 
   - transactionId
17185 
   - category
17186 
  """
17187 
 
17188 
  thrift_spec = (
17189 
    None, # 0
17190 
    (1, TType.I64, 'transactionId', None, None, ), # 1
17191 
    (2, TType.I32, 'category', None, None, ), # 2
17192 
  )
17193 
 
17194 
  def __init__(self, transactionId=None, category=None,):
17195 
    self.transactionId = transactionId
17196 
    self.category = category
17197 
 
17198 
  def read(self, iprot):
17199 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
17200 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
17201 
      return
17202 
    iprot.readStructBegin()
17203 
    while True:
17204 
      (fname, ftype, fid) = iprot.readFieldBegin()
17205 
      if ftype == TType.STOP:
17206 
        break
17207 
      if fid == 1:
17208 
        if ftype == TType.I64:
17209 
          self.transactionId = iprot.readI64();
17210 
        else:
17211 
          iprot.skip(ftype)
17212 
      elif fid == 2:
17213 
        if ftype == TType.I32:
17214 
          self.category = iprot.readI32();
17215 
        else:
17216 
          iprot.skip(ftype)
17217 
      else:
17218 
        iprot.skip(ftype)
17219 
      iprot.readFieldEnd()
17220 
    iprot.readStructEnd()
17221 
 
17222 
  def write(self, oprot):
17223 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
17224 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
17225 
      return
17226 
    oprot.writeStructBegin('markTransactionAsProcessed_args')
17227 
    if self.transactionId is not None:
17228 
      oprot.writeFieldBegin('transactionId', TType.I64, 1)
17229 
      oprot.writeI64(self.transactionId)
17230 
      oprot.writeFieldEnd()
17231 
    if self.category is not None:
17232 
      oprot.writeFieldBegin('category', TType.I32, 2)
17233 
      oprot.writeI32(self.category)
17234 
      oprot.writeFieldEnd()
17235 
    oprot.writeFieldStop()
17236 
    oprot.writeStructEnd()
17237 
 
17238 
  def validate(self):
17239 
    return
17240 
 
17241 
 
17242 
  def __repr__(self):
17243 
    L = ['%s=%r' % (key, value)
17244 
      for key, value in self.__dict__.iteritems()]
17245 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
17246 
 
17247 
  def __eq__(self, other):
17248 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
17249 
 
17250 
  def __ne__(self, other):
17251 
    return not (self == other)
17252 
 
17253 
class markTransactionAsProcessed_result:
17254 
 
17255 
  thrift_spec = (
17256 
  )
17257 
 
17258 
  def read(self, iprot):
17259 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
17260 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
17261 
      return
17262 
    iprot.readStructBegin()
17263 
    while True:
17264 
      (fname, ftype, fid) = iprot.readFieldBegin()
17265 
      if ftype == TType.STOP:
17266 
        break
17267 
      else:
17268 
        iprot.skip(ftype)
17269 
      iprot.readFieldEnd()
17270 
    iprot.readStructEnd()
17271 
 
17272 
  def write(self, oprot):
17273 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
17274 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
17275 
      return
17276 
    oprot.writeStructBegin('markTransactionAsProcessed_result')
17277 
    oprot.writeFieldStop()
17278 
    oprot.writeStructEnd()
17279 
 
17280 
  def validate(self):
17281 
    return
17282 
 
17283 
 
17284 
  def __repr__(self):
17285 
    L = ['%s=%r' % (key, value)
17286 
      for key, value in self.__dict__.iteritems()]
17287 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
17288 
 
17289 
  def __eq__(self, other):
17290 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
17291 
 
17292 
  def __ne__(self, other):
17293 
    return not (self == other)
4018 chandransh 17294 
 
17295 
class getItemWiseRiskyOrdersCount_args:
17296 
 
17297 
  thrift_spec = (
17298 
  )
17299 
 
17300 
  def read(self, iprot):
17301 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
17302 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
17303 
      return
17304 
    iprot.readStructBegin()
17305 
    while True:
17306 
      (fname, ftype, fid) = iprot.readFieldBegin()
17307 
      if ftype == TType.STOP:
17308 
        break
17309 
      else:
17310 
        iprot.skip(ftype)
17311 
      iprot.readFieldEnd()
17312 
    iprot.readStructEnd()
17313 
 
17314 
  def write(self, oprot):
17315 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
17316 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
17317 
      return
17318 
    oprot.writeStructBegin('getItemWiseRiskyOrdersCount_args')
17319 
    oprot.writeFieldStop()
17320 
    oprot.writeStructEnd()
17321 
 
17322 
  def validate(self):
17323 
    return
17324 
 
17325 
 
17326 
  def __repr__(self):
17327 
    L = ['%s=%r' % (key, value)
17328 
      for key, value in self.__dict__.iteritems()]
17329 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
17330 
 
17331 
  def __eq__(self, other):
17332 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
17333 
 
17334 
  def __ne__(self, other):
17335 
    return not (self == other)
17336 
 
17337 
class getItemWiseRiskyOrdersCount_result:
17338 
  """
17339 
  Attributes:
17340 
   - success
17341 
  """
17342 
 
17343 
  thrift_spec = (
17344 
    (0, TType.MAP, 'success', (TType.I64,None,TType.I64,None), None, ), # 0
17345 
  )
17346 
 
17347 
  def __init__(self, success=None,):
17348 
    self.success = success
17349 
 
17350 
  def read(self, iprot):
17351 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
17352 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
17353 
      return
17354 
    iprot.readStructBegin()
17355 
    while True:
17356 
      (fname, ftype, fid) = iprot.readFieldBegin()
17357 
      if ftype == TType.STOP:
17358 
        break
17359 
      if fid == 0:
17360 
        if ftype == TType.MAP:
17361 
          self.success = {}
5031 varun.gupt 17362 
          (_ktype387, _vtype388, _size386 ) = iprot.readMapBegin()
17363 
          for _i390 in xrange(_size386):
17364 
            _key391 = iprot.readI64();
17365 
            _val392 = iprot.readI64();
17366 
            self.success[_key391] = _val392
4018 chandransh 17367 
          iprot.readMapEnd()
17368 
        else:
17369 
          iprot.skip(ftype)
17370 
      else:
17371 
        iprot.skip(ftype)
17372 
      iprot.readFieldEnd()
17373 
    iprot.readStructEnd()
17374 
 
17375 
  def write(self, oprot):
17376 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
17377 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
17378 
      return
17379 
    oprot.writeStructBegin('getItemWiseRiskyOrdersCount_result')
17380 
    if self.success is not None:
17381 
      oprot.writeFieldBegin('success', TType.MAP, 0)
17382 
      oprot.writeMapBegin(TType.I64, TType.I64, len(self.success))
5031 varun.gupt 17383 
      for kiter393,viter394 in self.success.items():
17384 
        oprot.writeI64(kiter393)
17385 
        oprot.writeI64(viter394)
4018 chandransh 17386 
      oprot.writeMapEnd()
17387 
      oprot.writeFieldEnd()
17388 
    oprot.writeFieldStop()
17389 
    oprot.writeStructEnd()
17390 
 
17391 
  def validate(self):
17392 
    return
17393 
 
17394 
 
17395 
  def __repr__(self):
17396 
    L = ['%s=%r' % (key, value)
17397 
      for key, value in self.__dict__.iteritems()]
17398 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
17399 
 
17400 
  def __eq__(self, other):
17401 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
17402 
 
17403 
  def __ne__(self, other):
17404 
    return not (self == other)
4247 rajveer 17405 
 
4295 varun.gupt 17406 
class getOrdersForItemIds_args:
17407 
  """
17408 
  Attributes:
17409 
   - itemIds
17410 
  """
17411 
 
17412 
  thrift_spec = (
17413 
    None, # 0
17414 
    (1, TType.LIST, 'itemIds', (TType.I64,None), None, ), # 1
17415 
  )
17416 
 
17417 
  def __init__(self, itemIds=None,):
17418 
    self.itemIds = itemIds
17419 
 
17420 
  def read(self, iprot):
17421 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
17422 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
17423 
      return
17424 
    iprot.readStructBegin()
17425 
    while True:
17426 
      (fname, ftype, fid) = iprot.readFieldBegin()
17427 
      if ftype == TType.STOP:
17428 
        break
17429 
      if fid == 1:
17430 
        if ftype == TType.LIST:
17431 
          self.itemIds = []
5031 varun.gupt 17432 
          (_etype398, _size395) = iprot.readListBegin()
17433 
          for _i399 in xrange(_size395):
17434 
            _elem400 = iprot.readI64();
17435 
            self.itemIds.append(_elem400)
4295 varun.gupt 17436 
          iprot.readListEnd()
17437 
        else:
17438 
          iprot.skip(ftype)
17439 
      else:
17440 
        iprot.skip(ftype)
17441 
      iprot.readFieldEnd()
17442 
    iprot.readStructEnd()
17443 
 
17444 
  def write(self, oprot):
17445 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
17446 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
17447 
      return
17448 
    oprot.writeStructBegin('getOrdersForItemIds_args')
17449 
    if self.itemIds is not None:
17450 
      oprot.writeFieldBegin('itemIds', TType.LIST, 1)
17451 
      oprot.writeListBegin(TType.I64, len(self.itemIds))
5031 varun.gupt 17452 
      for iter401 in self.itemIds:
17453 
        oprot.writeI64(iter401)
4295 varun.gupt 17454 
      oprot.writeListEnd()
17455 
      oprot.writeFieldEnd()
17456 
    oprot.writeFieldStop()
17457 
    oprot.writeStructEnd()
17458 
 
17459 
  def validate(self):
17460 
    return
17461 
 
17462 
 
17463 
  def __repr__(self):
17464 
    L = ['%s=%r' % (key, value)
17465 
      for key, value in self.__dict__.iteritems()]
17466 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
17467 
 
17468 
  def __eq__(self, other):
17469 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
17470 
 
17471 
  def __ne__(self, other):
17472 
    return not (self == other)
17473 
 
17474 
class getOrdersForItemIds_result:
17475 
  """
17476 
  Attributes:
17477 
   - success
17478 
  """
17479 
 
17480 
  thrift_spec = (
17481 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
17482 
  )
17483 
 
17484 
  def __init__(self, success=None,):
17485 
    self.success = success
17486 
 
17487 
  def read(self, iprot):
17488 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
17489 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
17490 
      return
17491 
    iprot.readStructBegin()
17492 
    while True:
17493 
      (fname, ftype, fid) = iprot.readFieldBegin()
17494 
      if ftype == TType.STOP:
17495 
        break
17496 
      if fid == 0:
17497 
        if ftype == TType.LIST:
17498 
          self.success = []
5031 varun.gupt 17499 
          (_etype405, _size402) = iprot.readListBegin()
17500 
          for _i406 in xrange(_size402):
17501 
            _elem407 = Order()
17502 
            _elem407.read(iprot)
17503 
            self.success.append(_elem407)
4295 varun.gupt 17504 
          iprot.readListEnd()
17505 
        else:
17506 
          iprot.skip(ftype)
17507 
      else:
17508 
        iprot.skip(ftype)
17509 
      iprot.readFieldEnd()
17510 
    iprot.readStructEnd()
17511 
 
17512 
  def write(self, oprot):
17513 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
17514 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
17515 
      return
17516 
    oprot.writeStructBegin('getOrdersForItemIds_result')
17517 
    if self.success is not None:
17518 
      oprot.writeFieldBegin('success', TType.LIST, 0)
17519 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
5031 varun.gupt 17520 
      for iter408 in self.success:
17521 
        iter408.write(oprot)
4295 varun.gupt 17522 
      oprot.writeListEnd()
17523 
      oprot.writeFieldEnd()
17524 
    oprot.writeFieldStop()
17525 
    oprot.writeStructEnd()
17526 
 
17527 
  def validate(self):
17528 
    return
17529 
 
17530 
 
17531 
  def __repr__(self):
17532 
    L = ['%s=%r' % (key, value)
17533 
      for key, value in self.__dict__.iteritems()]
17534 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
17535 
 
17536 
  def __eq__(self, other):
17537 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
17538 
 
17539 
  def __ne__(self, other):
17540 
    return not (self == other)
17541 
 
4247 rajveer 17542 
class markOrderCancellationRequestReceived_args:
17543 
  """
17544 
  Attributes:
17545 
   - orderId
17546 
  """
17547 
 
17548 
  thrift_spec = (
17549 
    None, # 0
17550 
    (1, TType.I64, 'orderId', None, None, ), # 1
17551 
  )
17552 
 
17553 
  def __init__(self, orderId=None,):
17554 
    self.orderId = orderId
17555 
 
17556 
  def read(self, iprot):
17557 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
17558 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
17559 
      return
17560 
    iprot.readStructBegin()
17561 
    while True:
17562 
      (fname, ftype, fid) = iprot.readFieldBegin()
17563 
      if ftype == TType.STOP:
17564 
        break
17565 
      if fid == 1:
17566 
        if ftype == TType.I64:
17567 
          self.orderId = iprot.readI64();
17568 
        else:
17569 
          iprot.skip(ftype)
17570 
      else:
17571 
        iprot.skip(ftype)
17572 
      iprot.readFieldEnd()
17573 
    iprot.readStructEnd()
17574 
 
17575 
  def write(self, oprot):
17576 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
17577 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
17578 
      return
17579 
    oprot.writeStructBegin('markOrderCancellationRequestReceived_args')
17580 
    if self.orderId is not None:
17581 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
17582 
      oprot.writeI64(self.orderId)
17583 
      oprot.writeFieldEnd()
17584 
    oprot.writeFieldStop()
17585 
    oprot.writeStructEnd()
17586 
 
17587 
  def validate(self):
17588 
    return
17589 
 
17590 
 
17591 
  def __repr__(self):
17592 
    L = ['%s=%r' % (key, value)
17593 
      for key, value in self.__dict__.iteritems()]
17594 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
17595 
 
17596 
  def __eq__(self, other):
17597 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
17598 
 
17599 
  def __ne__(self, other):
17600 
    return not (self == other)
17601 
 
17602 
class markOrderCancellationRequestReceived_result:
17603 
  """
17604 
  Attributes:
17605 
   - ex
17606 
  """
17607 
 
17608 
  thrift_spec = (
17609 
    None, # 0
17610 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
17611 
  )
17612 
 
17613 
  def __init__(self, ex=None,):
17614 
    self.ex = ex
17615 
 
17616 
  def read(self, iprot):
17617 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
17618 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
17619 
      return
17620 
    iprot.readStructBegin()
17621 
    while True:
17622 
      (fname, ftype, fid) = iprot.readFieldBegin()
17623 
      if ftype == TType.STOP:
17624 
        break
17625 
      if fid == 1:
17626 
        if ftype == TType.STRUCT:
17627 
          self.ex = TransactionServiceException()
17628 
          self.ex.read(iprot)
17629 
        else:
17630 
          iprot.skip(ftype)
17631 
      else:
17632 
        iprot.skip(ftype)
17633 
      iprot.readFieldEnd()
17634 
    iprot.readStructEnd()
17635 
 
17636 
  def write(self, oprot):
17637 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
17638 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
17639 
      return
17640 
    oprot.writeStructBegin('markOrderCancellationRequestReceived_result')
17641 
    if self.ex is not None:
17642 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
17643 
      self.ex.write(oprot)
17644 
      oprot.writeFieldEnd()
17645 
    oprot.writeFieldStop()
17646 
    oprot.writeStructEnd()
17647 
 
17648 
  def validate(self):
17649 
    return
17650 
 
17651 
 
17652 
  def __repr__(self):
17653 
    L = ['%s=%r' % (key, value)
17654 
      for key, value in self.__dict__.iteritems()]
17655 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
17656 
 
17657 
  def __eq__(self, other):
17658 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
17659 
 
17660 
  def __ne__(self, other):
17661 
    return not (self == other)
17662 
 
17663 
class markOrderCancellationRequestConfirmed_args:
17664 
  """
17665 
  Attributes:
17666 
   - orderId
17667 
  """
17668 
 
17669 
  thrift_spec = (
17670 
    None, # 0
17671 
    (1, TType.I64, 'orderId', None, None, ), # 1
17672 
  )
17673 
 
17674 
  def __init__(self, orderId=None,):
17675 
    self.orderId = orderId
17676 
 
17677 
  def read(self, iprot):
17678 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
17679 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
17680 
      return
17681 
    iprot.readStructBegin()
17682 
    while True:
17683 
      (fname, ftype, fid) = iprot.readFieldBegin()
17684 
      if ftype == TType.STOP:
17685 
        break
17686 
      if fid == 1:
17687 
        if ftype == TType.I64:
17688 
          self.orderId = iprot.readI64();
17689 
        else:
17690 
          iprot.skip(ftype)
17691 
      else:
17692 
        iprot.skip(ftype)
17693 
      iprot.readFieldEnd()
17694 
    iprot.readStructEnd()
17695 
 
17696 
  def write(self, oprot):
17697 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
17698 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
17699 
      return
17700 
    oprot.writeStructBegin('markOrderCancellationRequestConfirmed_args')
17701 
    if self.orderId is not None:
17702 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
17703 
      oprot.writeI64(self.orderId)
17704 
      oprot.writeFieldEnd()
17705 
    oprot.writeFieldStop()
17706 
    oprot.writeStructEnd()
17707 
 
17708 
  def validate(self):
17709 
    return
17710 
 
17711 
 
17712 
  def __repr__(self):
17713 
    L = ['%s=%r' % (key, value)
17714 
      for key, value in self.__dict__.iteritems()]
17715 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
17716 
 
17717 
  def __eq__(self, other):
17718 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
17719 
 
17720 
  def __ne__(self, other):
17721 
    return not (self == other)
17722 
 
17723 
class markOrderCancellationRequestConfirmed_result:
17724 
  """
17725 
  Attributes:
17726 
   - ex
17727 
  """
17728 
 
17729 
  thrift_spec = (
17730 
    None, # 0
17731 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
17732 
  )
17733 
 
17734 
  def __init__(self, ex=None,):
17735 
    self.ex = ex
17736 
 
17737 
  def read(self, iprot):
17738 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
17739 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
17740 
      return
17741 
    iprot.readStructBegin()
17742 
    while True:
17743 
      (fname, ftype, fid) = iprot.readFieldBegin()
17744 
      if ftype == TType.STOP:
17745 
        break
17746 
      if fid == 1:
17747 
        if ftype == TType.STRUCT:
17748 
          self.ex = TransactionServiceException()
17749 
          self.ex.read(iprot)
17750 
        else:
17751 
          iprot.skip(ftype)
17752 
      else:
17753 
        iprot.skip(ftype)
17754 
      iprot.readFieldEnd()
17755 
    iprot.readStructEnd()
17756 
 
17757 
  def write(self, oprot):
17758 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
17759 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
17760 
      return
17761 
    oprot.writeStructBegin('markOrderCancellationRequestConfirmed_result')
17762 
    if self.ex is not None:
17763 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
17764 
      self.ex.write(oprot)
17765 
      oprot.writeFieldEnd()
17766 
    oprot.writeFieldStop()
17767 
    oprot.writeStructEnd()
17768 
 
17769 
  def validate(self):
17770 
    return
17771 
 
17772 
 
17773 
  def __repr__(self):
17774 
    L = ['%s=%r' % (key, value)
17775 
      for key, value in self.__dict__.iteritems()]
17776 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
17777 
 
17778 
  def __eq__(self, other):
17779 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
17780 
 
17781 
  def __ne__(self, other):
17782 
    return not (self == other)
17783 
 
17784 
class markOrderCancellationRequestDenied_args:
17785 
  """
17786 
  Attributes:
17787 
   - orderId
17788 
  """
17789 
 
17790 
  thrift_spec = (
17791 
    None, # 0
17792 
    (1, TType.I64, 'orderId', None, None, ), # 1
17793 
  )
17794 
 
17795 
  def __init__(self, orderId=None,):
17796 
    self.orderId = orderId
17797 
 
17798 
  def read(self, iprot):
17799 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
17800 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
17801 
      return
17802 
    iprot.readStructBegin()
17803 
    while True:
17804 
      (fname, ftype, fid) = iprot.readFieldBegin()
17805 
      if ftype == TType.STOP:
17806 
        break
17807 
      if fid == 1:
17808 
        if ftype == TType.I64:
17809 
          self.orderId = iprot.readI64();
17810 
        else:
17811 
          iprot.skip(ftype)
17812 
      else:
17813 
        iprot.skip(ftype)
17814 
      iprot.readFieldEnd()
17815 
    iprot.readStructEnd()
17816 
 
17817 
  def write(self, oprot):
17818 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
17819 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
17820 
      return
17821 
    oprot.writeStructBegin('markOrderCancellationRequestDenied_args')
17822 
    if self.orderId is not None:
17823 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
17824 
      oprot.writeI64(self.orderId)
17825 
      oprot.writeFieldEnd()
17826 
    oprot.writeFieldStop()
17827 
    oprot.writeStructEnd()
17828 
 
17829 
  def validate(self):
17830 
    return
17831 
 
17832 
 
17833 
  def __repr__(self):
17834 
    L = ['%s=%r' % (key, value)
17835 
      for key, value in self.__dict__.iteritems()]
17836 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
17837 
 
17838 
  def __eq__(self, other):
17839 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
17840 
 
17841 
  def __ne__(self, other):
17842 
    return not (self == other)
17843 
 
17844 
class markOrderCancellationRequestDenied_result:
17845 
  """
17846 
  Attributes:
17847 
   - ex
17848 
  """
17849 
 
17850 
  thrift_spec = (
17851 
    None, # 0
17852 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
17853 
  )
17854 
 
17855 
  def __init__(self, ex=None,):
17856 
    self.ex = ex
17857 
 
17858 
  def read(self, iprot):
17859 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
17860 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
17861 
      return
17862 
    iprot.readStructBegin()
17863 
    while True:
17864 
      (fname, ftype, fid) = iprot.readFieldBegin()
17865 
      if ftype == TType.STOP:
17866 
        break
17867 
      if fid == 1:
17868 
        if ftype == TType.STRUCT:
17869 
          self.ex = TransactionServiceException()
17870 
          self.ex.read(iprot)
17871 
        else:
17872 
          iprot.skip(ftype)
17873 
      else:
17874 
        iprot.skip(ftype)
17875 
      iprot.readFieldEnd()
17876 
    iprot.readStructEnd()
17877 
 
17878 
  def write(self, oprot):
17879 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
17880 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
17881 
      return
17882 
    oprot.writeStructBegin('markOrderCancellationRequestDenied_result')
17883 
    if self.ex is not None:
17884 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
17885 
      self.ex.write(oprot)
17886 
      oprot.writeFieldEnd()
17887 
    oprot.writeFieldStop()
17888 
    oprot.writeStructEnd()
17889 
 
17890 
  def validate(self):
17891 
    return
17892 
 
17893 
 
17894 
  def __repr__(self):
17895 
    L = ['%s=%r' % (key, value)
17896 
      for key, value in self.__dict__.iteritems()]
17897 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
17898 
 
17899 
  def __eq__(self, other):
17900 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
17901 
 
17902 
  def __ne__(self, other):
17903 
    return not (self == other)
17904 
 
4258 rajveer 17905 
class markTransactionAsPaymentFlagRemoved_args:
4247 rajveer 17906 
  """
17907 
  Attributes:
4258 rajveer 17908 
   - transactionId
4247 rajveer 17909 
  """
17910 
 
17911 
  thrift_spec = (
17912 
    None, # 0
4258 rajveer 17913 
    (1, TType.I64, 'transactionId', None, None, ), # 1
4247 rajveer 17914 
  )
17915 
 
4258 rajveer 17916 
  def __init__(self, transactionId=None,):
17917 
    self.transactionId = transactionId
4247 rajveer 17918 
 
17919 
  def read(self, iprot):
17920 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
17921 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
17922 
      return
17923 
    iprot.readStructBegin()
17924 
    while True:
17925 
      (fname, ftype, fid) = iprot.readFieldBegin()
17926 
      if ftype == TType.STOP:
17927 
        break
17928 
      if fid == 1:
17929 
        if ftype == TType.I64:
4258 rajveer 17930 
          self.transactionId = iprot.readI64();
4247 rajveer 17931 
        else:
17932 
          iprot.skip(ftype)
17933 
      else:
17934 
        iprot.skip(ftype)
17935 
      iprot.readFieldEnd()
17936 
    iprot.readStructEnd()
17937 
 
17938 
  def write(self, oprot):
17939 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
17940 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
17941 
      return
4258 rajveer 17942 
    oprot.writeStructBegin('markTransactionAsPaymentFlagRemoved_args')
17943 
    if self.transactionId is not None:
17944 
      oprot.writeFieldBegin('transactionId', TType.I64, 1)
17945 
      oprot.writeI64(self.transactionId)
4247 rajveer 17946 
      oprot.writeFieldEnd()
17947 
    oprot.writeFieldStop()
17948 
    oprot.writeStructEnd()
17949 
 
17950 
  def validate(self):
17951 
    return
17952 
 
17953 
 
17954 
  def __repr__(self):
17955 
    L = ['%s=%r' % (key, value)
17956 
      for key, value in self.__dict__.iteritems()]
17957 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
17958 
 
17959 
  def __eq__(self, other):
17960 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
17961 
 
17962 
  def __ne__(self, other):
17963 
    return not (self == other)
17964 
 
4258 rajveer 17965 
class markTransactionAsPaymentFlagRemoved_result:
4247 rajveer 17966 
  """
17967 
  Attributes:
17968 
   - ex
17969 
  """
17970 
 
17971 
  thrift_spec = (
17972 
    None, # 0
17973 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
17974 
  )
17975 
 
17976 
  def __init__(self, ex=None,):
17977 
    self.ex = ex
17978 
 
17979 
  def read(self, iprot):
17980 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
17981 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
17982 
      return
17983 
    iprot.readStructBegin()
17984 
    while True:
17985 
      (fname, ftype, fid) = iprot.readFieldBegin()
17986 
      if ftype == TType.STOP:
17987 
        break
17988 
      if fid == 1:
17989 
        if ftype == TType.STRUCT:
17990 
          self.ex = TransactionServiceException()
17991 
          self.ex.read(iprot)
17992 
        else:
17993 
          iprot.skip(ftype)
17994 
      else:
17995 
        iprot.skip(ftype)
17996 
      iprot.readFieldEnd()
17997 
    iprot.readStructEnd()
17998 
 
17999 
  def write(self, oprot):
18000 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
18001 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
18002 
      return
4258 rajveer 18003 
    oprot.writeStructBegin('markTransactionAsPaymentFlagRemoved_result')
4247 rajveer 18004 
    if self.ex is not None:
18005 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
18006 
      self.ex.write(oprot)
18007 
      oprot.writeFieldEnd()
18008 
    oprot.writeFieldStop()
18009 
    oprot.writeStructEnd()
18010 
 
18011 
  def validate(self):
18012 
    return
18013 
 
18014 
 
18015 
  def __repr__(self):
18016 
    L = ['%s=%r' % (key, value)
18017 
      for key, value in self.__dict__.iteritems()]
18018 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
18019 
 
18020 
  def __eq__(self, other):
18021 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
18022 
 
18023 
  def __ne__(self, other):
18024 
    return not (self == other)
4259 anupam.sin 18025 
 
18026 
class refundTransaction_args:
18027 
  """
18028 
  Attributes:
18029 
   - transactionId
18030 
   - refundedBy
18031 
   - reason
18032 
  """
18033 
 
18034 
  thrift_spec = (
18035 
    None, # 0
18036 
    (1, TType.I64, 'transactionId', None, None, ), # 1
18037 
    (2, TType.STRING, 'refundedBy', None, None, ), # 2
18038 
    (3, TType.STRING, 'reason', None, None, ), # 3
18039 
  )
18040 
 
18041 
  def __init__(self, transactionId=None, refundedBy=None, reason=None,):
18042 
    self.transactionId = transactionId
18043 
    self.refundedBy = refundedBy
18044 
    self.reason = reason
18045 
 
18046 
  def read(self, iprot):
18047 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
18048 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
18049 
      return
18050 
    iprot.readStructBegin()
18051 
    while True:
18052 
      (fname, ftype, fid) = iprot.readFieldBegin()
18053 
      if ftype == TType.STOP:
18054 
        break
18055 
      if fid == 1:
18056 
        if ftype == TType.I64:
18057 
          self.transactionId = iprot.readI64();
18058 
        else:
18059 
          iprot.skip(ftype)
18060 
      elif fid == 2:
18061 
        if ftype == TType.STRING:
18062 
          self.refundedBy = iprot.readString();
18063 
        else:
18064 
          iprot.skip(ftype)
18065 
      elif fid == 3:
18066 
        if ftype == TType.STRING:
18067 
          self.reason = iprot.readString();
18068 
        else:
18069 
          iprot.skip(ftype)
18070 
      else:
18071 
        iprot.skip(ftype)
18072 
      iprot.readFieldEnd()
18073 
    iprot.readStructEnd()
18074 
 
18075 
  def write(self, oprot):
18076 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
18077 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
18078 
      return
18079 
    oprot.writeStructBegin('refundTransaction_args')
18080 
    if self.transactionId is not None:
18081 
      oprot.writeFieldBegin('transactionId', TType.I64, 1)
18082 
      oprot.writeI64(self.transactionId)
18083 
      oprot.writeFieldEnd()
18084 
    if self.refundedBy is not None:
18085 
      oprot.writeFieldBegin('refundedBy', TType.STRING, 2)
18086 
      oprot.writeString(self.refundedBy)
18087 
      oprot.writeFieldEnd()
18088 
    if self.reason is not None:
18089 
      oprot.writeFieldBegin('reason', TType.STRING, 3)
18090 
      oprot.writeString(self.reason)
18091 
      oprot.writeFieldEnd()
18092 
    oprot.writeFieldStop()
18093 
    oprot.writeStructEnd()
18094 
 
18095 
  def validate(self):
18096 
    return
18097 
 
18098 
 
18099 
  def __repr__(self):
18100 
    L = ['%s=%r' % (key, value)
18101 
      for key, value in self.__dict__.iteritems()]
18102 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
18103 
 
18104 
  def __eq__(self, other):
18105 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
18106 
 
18107 
  def __ne__(self, other):
18108 
    return not (self == other)
18109 
 
18110 
class refundTransaction_result:
18111 
  """
18112 
  Attributes:
18113 
   - ex
18114 
  """
18115 
 
18116 
  thrift_spec = (
18117 
    None, # 0
18118 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
18119 
  )
18120 
 
18121 
  def __init__(self, ex=None,):
18122 
    self.ex = ex
18123 
 
18124 
  def read(self, iprot):
18125 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
18126 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
18127 
      return
18128 
    iprot.readStructBegin()
18129 
    while True:
18130 
      (fname, ftype, fid) = iprot.readFieldBegin()
18131 
      if ftype == TType.STOP:
18132 
        break
18133 
      if fid == 1:
18134 
        if ftype == TType.STRUCT:
18135 
          self.ex = TransactionServiceException()
18136 
          self.ex.read(iprot)
18137 
        else:
18138 
          iprot.skip(ftype)
18139 
      else:
18140 
        iprot.skip(ftype)
18141 
      iprot.readFieldEnd()
18142 
    iprot.readStructEnd()
18143 
 
18144 
  def write(self, oprot):
18145 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
18146 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
18147 
      return
18148 
    oprot.writeStructBegin('refundTransaction_result')
18149 
    if self.ex is not None:
18150 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
18151 
      self.ex.write(oprot)
18152 
      oprot.writeFieldEnd()
18153 
    oprot.writeFieldStop()
18154 
    oprot.writeStructEnd()
18155 
 
18156 
  def validate(self):
18157 
    return
18158 
 
18159 
 
18160 
  def __repr__(self):
18161 
    L = ['%s=%r' % (key, value)
18162 
      for key, value in self.__dict__.iteritems()]
18163 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
18164 
 
18165 
  def __eq__(self, other):
18166 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
18167 
 
18168 
  def __ne__(self, other):
18169 
    return not (self == other)
4285 rajveer 18170 
 
4324 mandeep.dh 18171 
class updateShipmentAddress_args:
18172 
  """
18173 
  Attributes:
18174 
   - orderId
18175 
   - addressId
18176 
  """
18177 
 
18178 
  thrift_spec = (
18179 
    None, # 0
18180 
    (1, TType.I64, 'orderId', None, None, ), # 1
18181 
    (2, TType.I64, 'addressId', None, None, ), # 2
18182 
  )
18183 
 
18184 
  def __init__(self, orderId=None, addressId=None,):
18185 
    self.orderId = orderId
18186 
    self.addressId = addressId
18187 
 
18188 
  def read(self, iprot):
18189 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
18190 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
18191 
      return
18192 
    iprot.readStructBegin()
18193 
    while True:
18194 
      (fname, ftype, fid) = iprot.readFieldBegin()
18195 
      if ftype == TType.STOP:
18196 
        break
18197 
      if fid == 1:
18198 
        if ftype == TType.I64:
18199 
          self.orderId = iprot.readI64();
18200 
        else:
18201 
          iprot.skip(ftype)
18202 
      elif fid == 2:
18203 
        if ftype == TType.I64:
18204 
          self.addressId = iprot.readI64();
18205 
        else:
18206 
          iprot.skip(ftype)
18207 
      else:
18208 
        iprot.skip(ftype)
18209 
      iprot.readFieldEnd()
18210 
    iprot.readStructEnd()
18211 
 
18212 
  def write(self, oprot):
18213 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
18214 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
18215 
      return
18216 
    oprot.writeStructBegin('updateShipmentAddress_args')
18217 
    if self.orderId is not None:
18218 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
18219 
      oprot.writeI64(self.orderId)
18220 
      oprot.writeFieldEnd()
18221 
    if self.addressId is not None:
18222 
      oprot.writeFieldBegin('addressId', TType.I64, 2)
18223 
      oprot.writeI64(self.addressId)
18224 
      oprot.writeFieldEnd()
18225 
    oprot.writeFieldStop()
18226 
    oprot.writeStructEnd()
18227 
 
18228 
  def validate(self):
18229 
    return
18230 
 
18231 
 
18232 
  def __repr__(self):
18233 
    L = ['%s=%r' % (key, value)
18234 
      for key, value in self.__dict__.iteritems()]
18235 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
18236 
 
18237 
  def __eq__(self, other):
18238 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
18239 
 
18240 
  def __ne__(self, other):
18241 
    return not (self == other)
18242 
 
18243 
class updateShipmentAddress_result:
18244 
  """
18245 
  Attributes:
18246 
   - ex
18247 
  """
18248 
 
18249 
  thrift_spec = (
18250 
    None, # 0
18251 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
18252 
  )
18253 
 
18254 
  def __init__(self, ex=None,):
18255 
    self.ex = ex
18256 
 
18257 
  def read(self, iprot):
18258 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
18259 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
18260 
      return
18261 
    iprot.readStructBegin()
18262 
    while True:
18263 
      (fname, ftype, fid) = iprot.readFieldBegin()
18264 
      if ftype == TType.STOP:
18265 
        break
18266 
      if fid == 1:
18267 
        if ftype == TType.STRUCT:
18268 
          self.ex = TransactionServiceException()
18269 
          self.ex.read(iprot)
18270 
        else:
18271 
          iprot.skip(ftype)
18272 
      else:
18273 
        iprot.skip(ftype)
18274 
      iprot.readFieldEnd()
18275 
    iprot.readStructEnd()
18276 
 
18277 
  def write(self, oprot):
18278 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
18279 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
18280 
      return
18281 
    oprot.writeStructBegin('updateShipmentAddress_result')
18282 
    if self.ex is not None:
18283 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
18284 
      self.ex.write(oprot)
18285 
      oprot.writeFieldEnd()
18286 
    oprot.writeFieldStop()
18287 
    oprot.writeStructEnd()
18288 
 
18289 
  def validate(self):
18290 
    return
18291 
 
18292 
 
18293 
  def __repr__(self):
18294 
    L = ['%s=%r' % (key, value)
18295 
      for key, value in self.__dict__.iteritems()]
18296 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
18297 
 
18298 
  def __eq__(self, other):
18299 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
18300 
 
18301 
  def __ne__(self, other):
18302 
    return not (self == other)
18303 
 
4285 rajveer 18304 
class acceptOrdersForItemId_args:
18305 
  """
18306 
  Attributes:
18307 
   - itemId
18308 
   - inventory
18309 
  """
18310 
 
18311 
  thrift_spec = (
18312 
    None, # 0
18313 
    (1, TType.I64, 'itemId', None, None, ), # 1
18314 
    (2, TType.I64, 'inventory', None, None, ), # 2
18315 
  )
18316 
 
18317 
  def __init__(self, itemId=None, inventory=None,):
18318 
    self.itemId = itemId
18319 
    self.inventory = inventory
18320 
 
18321 
  def read(self, iprot):
18322 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
18323 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
18324 
      return
18325 
    iprot.readStructBegin()
18326 
    while True:
18327 
      (fname, ftype, fid) = iprot.readFieldBegin()
18328 
      if ftype == TType.STOP:
18329 
        break
18330 
      if fid == 1:
18331 
        if ftype == TType.I64:
18332 
          self.itemId = iprot.readI64();
18333 
        else:
18334 
          iprot.skip(ftype)
18335 
      elif fid == 2:
18336 
        if ftype == TType.I64:
18337 
          self.inventory = iprot.readI64();
18338 
        else:
18339 
          iprot.skip(ftype)
18340 
      else:
18341 
        iprot.skip(ftype)
18342 
      iprot.readFieldEnd()
18343 
    iprot.readStructEnd()
18344 
 
18345 
  def write(self, oprot):
18346 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
18347 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
18348 
      return
18349 
    oprot.writeStructBegin('acceptOrdersForItemId_args')
18350 
    if self.itemId is not None:
18351 
      oprot.writeFieldBegin('itemId', TType.I64, 1)
18352 
      oprot.writeI64(self.itemId)
18353 
      oprot.writeFieldEnd()
18354 
    if self.inventory is not None:
18355 
      oprot.writeFieldBegin('inventory', TType.I64, 2)
18356 
      oprot.writeI64(self.inventory)
18357 
      oprot.writeFieldEnd()
18358 
    oprot.writeFieldStop()
18359 
    oprot.writeStructEnd()
18360 
 
18361 
  def validate(self):
18362 
    return
18363 
 
18364 
 
18365 
  def __repr__(self):
18366 
    L = ['%s=%r' % (key, value)
18367 
      for key, value in self.__dict__.iteritems()]
18368 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
18369 
 
18370 
  def __eq__(self, other):
18371 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
18372 
 
18373 
  def __ne__(self, other):
18374 
    return not (self == other)
18375 
 
18376 
class acceptOrdersForItemId_result:
18377 
  """
18378 
  Attributes:
18379 
   - success
18380 
   - ex
18381 
  """
18382 
 
18383 
  thrift_spec = (
18384 
    (0, TType.BOOL, 'success', None, None, ), # 0
18385 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
18386 
  )
18387 
 
18388 
  def __init__(self, success=None, ex=None,):
18389 
    self.success = success
18390 
    self.ex = ex
18391 
 
18392 
  def read(self, iprot):
18393 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
18394 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
18395 
      return
18396 
    iprot.readStructBegin()
18397 
    while True:
18398 
      (fname, ftype, fid) = iprot.readFieldBegin()
18399 
      if ftype == TType.STOP:
18400 
        break
18401 
      if fid == 0:
18402 
        if ftype == TType.BOOL:
18403 
          self.success = iprot.readBool();
18404 
        else:
18405 
          iprot.skip(ftype)
18406 
      elif fid == 1:
18407 
        if ftype == TType.STRUCT:
18408 
          self.ex = TransactionServiceException()
18409 
          self.ex.read(iprot)
18410 
        else:
18411 
          iprot.skip(ftype)
18412 
      else:
18413 
        iprot.skip(ftype)
18414 
      iprot.readFieldEnd()
18415 
    iprot.readStructEnd()
18416 
 
18417 
  def write(self, oprot):
18418 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
18419 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
18420 
      return
18421 
    oprot.writeStructBegin('acceptOrdersForItemId_result')
18422 
    if self.success is not None:
18423 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
18424 
      oprot.writeBool(self.success)
18425 
      oprot.writeFieldEnd()
18426 
    if self.ex is not None:
18427 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
18428 
      self.ex.write(oprot)
18429 
      oprot.writeFieldEnd()
18430 
    oprot.writeFieldStop()
18431 
    oprot.writeStructEnd()
18432 
 
18433 
  def validate(self):
18434 
    return
18435 
 
18436 
 
18437 
  def __repr__(self):
18438 
    L = ['%s=%r' % (key, value)
18439 
      for key, value in self.__dict__.iteritems()]
18440 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
18441 
 
18442 
  def __eq__(self, other):
18443 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
18444 
 
18445 
  def __ne__(self, other):
18446 
    return not (self == other)
4303 rajveer 18447 
 
18448 
class markOrdersAsPORaised_args:
18449 
  """
18450 
  Attributes:
18451 
   - vendorId
18452 
   - itemId
18453 
   - quantity
18454 
   - estimate
4369 rajveer 18455 
   - isReminder
4303 rajveer 18456 
  """
18457 
 
18458 
  thrift_spec = (
18459 
    None, # 0
18460 
    (1, TType.I64, 'vendorId', None, None, ), # 1
18461 
    (2, TType.I64, 'itemId', None, None, ), # 2
18462 
    (3, TType.I64, 'quantity', None, None, ), # 3
18463 
    (4, TType.I64, 'estimate', None, None, ), # 4
4369 rajveer 18464 
    (5, TType.BOOL, 'isReminder', None, None, ), # 5
4303 rajveer 18465 
  )
18466 
 
4369 rajveer 18467 
  def __init__(self, vendorId=None, itemId=None, quantity=None, estimate=None, isReminder=None,):
4303 rajveer 18468 
    self.vendorId = vendorId
18469 
    self.itemId = itemId
18470 
    self.quantity = quantity
18471 
    self.estimate = estimate
4369 rajveer 18472 
    self.isReminder = isReminder
4303 rajveer 18473 
 
18474 
  def read(self, iprot):
18475 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
18476 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
18477 
      return
18478 
    iprot.readStructBegin()
18479 
    while True:
18480 
      (fname, ftype, fid) = iprot.readFieldBegin()
18481 
      if ftype == TType.STOP:
18482 
        break
18483 
      if fid == 1:
18484 
        if ftype == TType.I64:
18485 
          self.vendorId = iprot.readI64();
18486 
        else:
18487 
          iprot.skip(ftype)
18488 
      elif fid == 2:
18489 
        if ftype == TType.I64:
18490 
          self.itemId = iprot.readI64();
18491 
        else:
18492 
          iprot.skip(ftype)
18493 
      elif fid == 3:
18494 
        if ftype == TType.I64:
18495 
          self.quantity = iprot.readI64();
18496 
        else:
18497 
          iprot.skip(ftype)
18498 
      elif fid == 4:
18499 
        if ftype == TType.I64:
18500 
          self.estimate = iprot.readI64();
18501 
        else:
18502 
          iprot.skip(ftype)
4369 rajveer 18503 
      elif fid == 5:
18504 
        if ftype == TType.BOOL:
18505 
          self.isReminder = iprot.readBool();
18506 
        else:
18507 
          iprot.skip(ftype)
4303 rajveer 18508 
      else:
18509 
        iprot.skip(ftype)
18510 
      iprot.readFieldEnd()
18511 
    iprot.readStructEnd()
18512 
 
18513 
  def write(self, oprot):
18514 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
18515 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
18516 
      return
18517 
    oprot.writeStructBegin('markOrdersAsPORaised_args')
18518 
    if self.vendorId is not None:
18519 
      oprot.writeFieldBegin('vendorId', TType.I64, 1)
18520 
      oprot.writeI64(self.vendorId)
18521 
      oprot.writeFieldEnd()
18522 
    if self.itemId is not None:
18523 
      oprot.writeFieldBegin('itemId', TType.I64, 2)
18524 
      oprot.writeI64(self.itemId)
18525 
      oprot.writeFieldEnd()
18526 
    if self.quantity is not None:
18527 
      oprot.writeFieldBegin('quantity', TType.I64, 3)
18528 
      oprot.writeI64(self.quantity)
18529 
      oprot.writeFieldEnd()
18530 
    if self.estimate is not None:
18531 
      oprot.writeFieldBegin('estimate', TType.I64, 4)
18532 
      oprot.writeI64(self.estimate)
18533 
      oprot.writeFieldEnd()
4369 rajveer 18534 
    if self.isReminder is not None:
18535 
      oprot.writeFieldBegin('isReminder', TType.BOOL, 5)
18536 
      oprot.writeBool(self.isReminder)
18537 
      oprot.writeFieldEnd()
4303 rajveer 18538 
    oprot.writeFieldStop()
18539 
    oprot.writeStructEnd()
18540 
 
18541 
  def validate(self):
18542 
    return
18543 
 
18544 
 
18545 
  def __repr__(self):
18546 
    L = ['%s=%r' % (key, value)
18547 
      for key, value in self.__dict__.iteritems()]
18548 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
18549 
 
18550 
  def __eq__(self, other):
18551 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
18552 
 
18553 
  def __ne__(self, other):
18554 
    return not (self == other)
18555 
 
18556 
class markOrdersAsPORaised_result:
18557 
  """
18558 
  Attributes:
18559 
   - ex
18560 
  """
18561 
 
18562 
  thrift_spec = (
18563 
    None, # 0
18564 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
18565 
  )
18566 
 
18567 
  def __init__(self, ex=None,):
18568 
    self.ex = ex
18569 
 
18570 
  def read(self, iprot):
18571 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
18572 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
18573 
      return
18574 
    iprot.readStructBegin()
18575 
    while True:
18576 
      (fname, ftype, fid) = iprot.readFieldBegin()
18577 
      if ftype == TType.STOP:
18578 
        break
18579 
      if fid == 1:
18580 
        if ftype == TType.STRUCT:
18581 
          self.ex = TransactionServiceException()
18582 
          self.ex.read(iprot)
18583 
        else:
18584 
          iprot.skip(ftype)
18585 
      else:
18586 
        iprot.skip(ftype)
18587 
      iprot.readFieldEnd()
18588 
    iprot.readStructEnd()
18589 
 
18590 
  def write(self, oprot):
18591 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
18592 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
18593 
      return
18594 
    oprot.writeStructBegin('markOrdersAsPORaised_result')
18595 
    if self.ex is not None:
18596 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
18597 
      self.ex.write(oprot)
18598 
      oprot.writeFieldEnd()
18599 
    oprot.writeFieldStop()
18600 
    oprot.writeStructEnd()
18601 
 
18602 
  def validate(self):
18603 
    return
18604 
 
18605 
 
18606 
  def __repr__(self):
18607 
    L = ['%s=%r' % (key, value)
18608 
      for key, value in self.__dict__.iteritems()]
18609 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
18610 
 
18611 
  def __eq__(self, other):
18612 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
18613 
 
18614 
  def __ne__(self, other):
18615 
    return not (self == other)
18616 
 
18617 
class markOrdersAsReversalInitiated_args:
18618 
  """
18619 
  Attributes:
18620 
   - vendorId
18621 
   - itemId
18622 
   - quantity
18623 
   - estimate
4369 rajveer 18624 
   - isReminder
4303 rajveer 18625 
  """
18626 
 
18627 
  thrift_spec = (
18628 
    None, # 0
18629 
    (1, TType.I64, 'vendorId', None, None, ), # 1
18630 
    (2, TType.I64, 'itemId', None, None, ), # 2
18631 
    (3, TType.I64, 'quantity', None, None, ), # 3
18632 
    (4, TType.I64, 'estimate', None, None, ), # 4
4369 rajveer 18633 
    (5, TType.BOOL, 'isReminder', None, None, ), # 5
4303 rajveer 18634 
  )
18635 
 
4369 rajveer 18636 
  def __init__(self, vendorId=None, itemId=None, quantity=None, estimate=None, isReminder=None,):
4303 rajveer 18637 
    self.vendorId = vendorId
18638 
    self.itemId = itemId
18639 
    self.quantity = quantity
18640 
    self.estimate = estimate
4369 rajveer 18641 
    self.isReminder = isReminder
4303 rajveer 18642 
 
18643 
  def read(self, iprot):
18644 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
18645 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
18646 
      return
18647 
    iprot.readStructBegin()
18648 
    while True:
18649 
      (fname, ftype, fid) = iprot.readFieldBegin()
18650 
      if ftype == TType.STOP:
18651 
        break
18652 
      if fid == 1:
18653 
        if ftype == TType.I64:
18654 
          self.vendorId = iprot.readI64();
18655 
        else:
18656 
          iprot.skip(ftype)
18657 
      elif fid == 2:
18658 
        if ftype == TType.I64:
18659 
          self.itemId = iprot.readI64();
18660 
        else:
18661 
          iprot.skip(ftype)
18662 
      elif fid == 3:
18663 
        if ftype == TType.I64:
18664 
          self.quantity = iprot.readI64();
18665 
        else:
18666 
          iprot.skip(ftype)
18667 
      elif fid == 4:
18668 
        if ftype == TType.I64:
18669 
          self.estimate = iprot.readI64();
18670 
        else:
18671 
          iprot.skip(ftype)
4369 rajveer 18672 
      elif fid == 5:
18673 
        if ftype == TType.BOOL:
18674 
          self.isReminder = iprot.readBool();
18675 
        else:
18676 
          iprot.skip(ftype)
4303 rajveer 18677 
      else:
18678 
        iprot.skip(ftype)
18679 
      iprot.readFieldEnd()
18680 
    iprot.readStructEnd()
18681 
 
18682 
  def write(self, oprot):
18683 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
18684 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
18685 
      return
18686 
    oprot.writeStructBegin('markOrdersAsReversalInitiated_args')
18687 
    if self.vendorId is not None:
18688 
      oprot.writeFieldBegin('vendorId', TType.I64, 1)
18689 
      oprot.writeI64(self.vendorId)
18690 
      oprot.writeFieldEnd()
18691 
    if self.itemId is not None:
18692 
      oprot.writeFieldBegin('itemId', TType.I64, 2)
18693 
      oprot.writeI64(self.itemId)
18694 
      oprot.writeFieldEnd()
18695 
    if self.quantity is not None:
18696 
      oprot.writeFieldBegin('quantity', TType.I64, 3)
18697 
      oprot.writeI64(self.quantity)
18698 
      oprot.writeFieldEnd()
18699 
    if self.estimate is not None:
18700 
      oprot.writeFieldBegin('estimate', TType.I64, 4)
18701 
      oprot.writeI64(self.estimate)
18702 
      oprot.writeFieldEnd()
4369 rajveer 18703 
    if self.isReminder is not None:
18704 
      oprot.writeFieldBegin('isReminder', TType.BOOL, 5)
18705 
      oprot.writeBool(self.isReminder)
18706 
      oprot.writeFieldEnd()
4303 rajveer 18707 
    oprot.writeFieldStop()
18708 
    oprot.writeStructEnd()
18709 
 
18710 
  def validate(self):
18711 
    return
18712 
 
18713 
 
18714 
  def __repr__(self):
18715 
    L = ['%s=%r' % (key, value)
18716 
      for key, value in self.__dict__.iteritems()]
18717 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
18718 
 
18719 
  def __eq__(self, other):
18720 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
18721 
 
18722 
  def __ne__(self, other):
18723 
    return not (self == other)
18724 
 
18725 
class markOrdersAsReversalInitiated_result:
18726 
  """
18727 
  Attributes:
18728 
   - ex
18729 
  """
18730 
 
18731 
  thrift_spec = (
18732 
    None, # 0
18733 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
18734 
  )
18735 
 
18736 
  def __init__(self, ex=None,):
18737 
    self.ex = ex
18738 
 
18739 
  def read(self, iprot):
18740 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
18741 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
18742 
      return
18743 
    iprot.readStructBegin()
18744 
    while True:
18745 
      (fname, ftype, fid) = iprot.readFieldBegin()
18746 
      if ftype == TType.STOP:
18747 
        break
18748 
      if fid == 1:
18749 
        if ftype == TType.STRUCT:
18750 
          self.ex = TransactionServiceException()
18751 
          self.ex.read(iprot)
18752 
        else:
18753 
          iprot.skip(ftype)
18754 
      else:
18755 
        iprot.skip(ftype)
18756 
      iprot.readFieldEnd()
18757 
    iprot.readStructEnd()
18758 
 
18759 
  def write(self, oprot):
18760 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
18761 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
18762 
      return
18763 
    oprot.writeStructBegin('markOrdersAsReversalInitiated_result')
18764 
    if self.ex is not None:
18765 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
18766 
      self.ex.write(oprot)
18767 
      oprot.writeFieldEnd()
18768 
    oprot.writeFieldStop()
18769 
    oprot.writeStructEnd()
18770 
 
18771 
  def validate(self):
18772 
    return
18773 
 
18774 
 
18775 
  def __repr__(self):
18776 
    L = ['%s=%r' % (key, value)
18777 
      for key, value in self.__dict__.iteritems()]
18778 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
18779 
 
18780 
  def __eq__(self, other):
18781 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
18782 
 
18783 
  def __ne__(self, other):
18784 
    return not (self == other)
18785 
 
18786 
class markOrdersAsNotAvailabke_args:
18787 
  """
18788 
  Attributes:
18789 
   - vendorId
18790 
   - itemId
18791 
   - quantity
18792 
   - estimate
4369 rajveer 18793 
   - isReminder
4303 rajveer 18794 
  """
18795 
 
18796 
  thrift_spec = (
18797 
    None, # 0
18798 
    (1, TType.I64, 'vendorId', None, None, ), # 1
18799 
    (2, TType.I64, 'itemId', None, None, ), # 2
18800 
    (3, TType.I64, 'quantity', None, None, ), # 3
18801 
    (4, TType.I64, 'estimate', None, None, ), # 4
4369 rajveer 18802 
    (5, TType.BOOL, 'isReminder', None, None, ), # 5
4303 rajveer 18803 
  )
18804 
 
4369 rajveer 18805 
  def __init__(self, vendorId=None, itemId=None, quantity=None, estimate=None, isReminder=None,):
4303 rajveer 18806 
    self.vendorId = vendorId
18807 
    self.itemId = itemId
18808 
    self.quantity = quantity
18809 
    self.estimate = estimate
4369 rajveer 18810 
    self.isReminder = isReminder
4303 rajveer 18811 
 
18812 
  def read(self, iprot):
18813 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
18814 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
18815 
      return
18816 
    iprot.readStructBegin()
18817 
    while True:
18818 
      (fname, ftype, fid) = iprot.readFieldBegin()
18819 
      if ftype == TType.STOP:
18820 
        break
18821 
      if fid == 1:
18822 
        if ftype == TType.I64:
18823 
          self.vendorId = iprot.readI64();
18824 
        else:
18825 
          iprot.skip(ftype)
18826 
      elif fid == 2:
18827 
        if ftype == TType.I64:
18828 
          self.itemId = iprot.readI64();
18829 
        else:
18830 
          iprot.skip(ftype)
18831 
      elif fid == 3:
18832 
        if ftype == TType.I64:
18833 
          self.quantity = iprot.readI64();
18834 
        else:
18835 
          iprot.skip(ftype)
18836 
      elif fid == 4:
18837 
        if ftype == TType.I64:
18838 
          self.estimate = iprot.readI64();
18839 
        else:
18840 
          iprot.skip(ftype)
4369 rajveer 18841 
      elif fid == 5:
18842 
        if ftype == TType.BOOL:
18843 
          self.isReminder = iprot.readBool();
18844 
        else:
18845 
          iprot.skip(ftype)
4303 rajveer 18846 
      else:
18847 
        iprot.skip(ftype)
18848 
      iprot.readFieldEnd()
18849 
    iprot.readStructEnd()
18850 
 
18851 
  def write(self, oprot):
18852 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
18853 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
18854 
      return
18855 
    oprot.writeStructBegin('markOrdersAsNotAvailabke_args')
18856 
    if self.vendorId is not None:
18857 
      oprot.writeFieldBegin('vendorId', TType.I64, 1)
18858 
      oprot.writeI64(self.vendorId)
18859 
      oprot.writeFieldEnd()
18860 
    if self.itemId is not None:
18861 
      oprot.writeFieldBegin('itemId', TType.I64, 2)
18862 
      oprot.writeI64(self.itemId)
18863 
      oprot.writeFieldEnd()
18864 
    if self.quantity is not None:
18865 
      oprot.writeFieldBegin('quantity', TType.I64, 3)
18866 
      oprot.writeI64(self.quantity)
18867 
      oprot.writeFieldEnd()
18868 
    if self.estimate is not None:
18869 
      oprot.writeFieldBegin('estimate', TType.I64, 4)
18870 
      oprot.writeI64(self.estimate)
18871 
      oprot.writeFieldEnd()
4369 rajveer 18872 
    if self.isReminder is not None:
18873 
      oprot.writeFieldBegin('isReminder', TType.BOOL, 5)
18874 
      oprot.writeBool(self.isReminder)
18875 
      oprot.writeFieldEnd()
4303 rajveer 18876 
    oprot.writeFieldStop()
18877 
    oprot.writeStructEnd()
18878 
 
18879 
  def validate(self):
18880 
    return
18881 
 
18882 
 
18883 
  def __repr__(self):
18884 
    L = ['%s=%r' % (key, value)
18885 
      for key, value in self.__dict__.iteritems()]
18886 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
18887 
 
18888 
  def __eq__(self, other):
18889 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
18890 
 
18891 
  def __ne__(self, other):
18892 
    return not (self == other)
18893 
 
18894 
class markOrdersAsNotAvailabke_result:
18895 
  """
18896 
  Attributes:
18897 
   - ex
18898 
  """
18899 
 
18900 
  thrift_spec = (
18901 
    None, # 0
18902 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
18903 
  )
18904 
 
18905 
  def __init__(self, ex=None,):
18906 
    self.ex = ex
18907 
 
18908 
  def read(self, iprot):
18909 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
18910 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
18911 
      return
18912 
    iprot.readStructBegin()
18913 
    while True:
18914 
      (fname, ftype, fid) = iprot.readFieldBegin()
18915 
      if ftype == TType.STOP:
18916 
        break
18917 
      if fid == 1:
18918 
        if ftype == TType.STRUCT:
18919 
          self.ex = TransactionServiceException()
18920 
          self.ex.read(iprot)
18921 
        else:
18922 
          iprot.skip(ftype)
18923 
      else:
18924 
        iprot.skip(ftype)
18925 
      iprot.readFieldEnd()
18926 
    iprot.readStructEnd()
18927 
 
18928 
  def write(self, oprot):
18929 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
18930 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
18931 
      return
18932 
    oprot.writeStructBegin('markOrdersAsNotAvailabke_result')
18933 
    if self.ex is not None:
18934 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
18935 
      self.ex.write(oprot)
18936 
      oprot.writeFieldEnd()
18937 
    oprot.writeFieldStop()
18938 
    oprot.writeStructEnd()
18939 
 
18940 
  def validate(self):
18941 
    return
18942 
 
18943 
 
18944 
  def __repr__(self):
18945 
    L = ['%s=%r' % (key, value)
18946 
      for key, value in self.__dict__.iteritems()]
18947 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
18948 
 
18949 
  def __eq__(self, other):
18950 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
18951 
 
18952 
  def __ne__(self, other):
18953 
    return not (self == other)
4369 rajveer 18954 
 
18955 
class markOrdersAsTimeout_args:
18956 
  """
18957 
  Attributes:
18958 
   - vendorId
18959 
  """
18960 
 
18961 
  thrift_spec = (
18962 
    None, # 0
18963 
    (1, TType.I64, 'vendorId', None, None, ), # 1
18964 
  )
18965 
 
18966 
  def __init__(self, vendorId=None,):
18967 
    self.vendorId = vendorId
18968 
 
18969 
  def read(self, iprot):
18970 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
18971 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
18972 
      return
18973 
    iprot.readStructBegin()
18974 
    while True:
18975 
      (fname, ftype, fid) = iprot.readFieldBegin()
18976 
      if ftype == TType.STOP:
18977 
        break
18978 
      if fid == 1:
18979 
        if ftype == TType.I64:
18980 
          self.vendorId = iprot.readI64();
18981 
        else:
18982 
          iprot.skip(ftype)
18983 
      else:
18984 
        iprot.skip(ftype)
18985 
      iprot.readFieldEnd()
18986 
    iprot.readStructEnd()
18987 
 
18988 
  def write(self, oprot):
18989 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
18990 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
18991 
      return
18992 
    oprot.writeStructBegin('markOrdersAsTimeout_args')
18993 
    if self.vendorId is not None:
18994 
      oprot.writeFieldBegin('vendorId', TType.I64, 1)
18995 
      oprot.writeI64(self.vendorId)
18996 
      oprot.writeFieldEnd()
18997 
    oprot.writeFieldStop()
18998 
    oprot.writeStructEnd()
18999 
 
19000 
  def validate(self):
19001 
    return
19002 
 
19003 
 
19004 
  def __repr__(self):
19005 
    L = ['%s=%r' % (key, value)
19006 
      for key, value in self.__dict__.iteritems()]
19007 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
19008 
 
19009 
  def __eq__(self, other):
19010 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
19011 
 
19012 
  def __ne__(self, other):
19013 
    return not (self == other)
19014 
 
19015 
class markOrdersAsTimeout_result:
19016 
  """
19017 
  Attributes:
19018 
   - success
19019 
   - ex
19020 
  """
19021 
 
19022 
  thrift_spec = (
19023 
    (0, TType.MAP, 'success', (TType.I32,None,TType.STRUCT,(TimeoutSummary, TimeoutSummary.thrift_spec)), None, ), # 0
19024 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
19025 
  )
19026 
 
19027 
  def __init__(self, success=None, ex=None,):
19028 
    self.success = success
19029 
    self.ex = ex
19030 
 
19031 
  def read(self, iprot):
19032 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
19033 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
19034 
      return
19035 
    iprot.readStructBegin()
19036 
    while True:
19037 
      (fname, ftype, fid) = iprot.readFieldBegin()
19038 
      if ftype == TType.STOP:
19039 
        break
19040 
      if fid == 0:
19041 
        if ftype == TType.MAP:
19042 
          self.success = {}
5031 varun.gupt 19043 
          (_ktype410, _vtype411, _size409 ) = iprot.readMapBegin()
19044 
          for _i413 in xrange(_size409):
19045 
            _key414 = iprot.readI32();
19046 
            _val415 = TimeoutSummary()
19047 
            _val415.read(iprot)
19048 
            self.success[_key414] = _val415
4369 rajveer 19049 
          iprot.readMapEnd()
19050 
        else:
19051 
          iprot.skip(ftype)
19052 
      elif fid == 1:
19053 
        if ftype == TType.STRUCT:
19054 
          self.ex = TransactionServiceException()
19055 
          self.ex.read(iprot)
19056 
        else:
19057 
          iprot.skip(ftype)
19058 
      else:
19059 
        iprot.skip(ftype)
19060 
      iprot.readFieldEnd()
19061 
    iprot.readStructEnd()
19062 
 
19063 
  def write(self, oprot):
19064 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
19065 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
19066 
      return
19067 
    oprot.writeStructBegin('markOrdersAsTimeout_result')
19068 
    if self.success is not None:
19069 
      oprot.writeFieldBegin('success', TType.MAP, 0)
19070 
      oprot.writeMapBegin(TType.I32, TType.STRUCT, len(self.success))
5031 varun.gupt 19071 
      for kiter416,viter417 in self.success.items():
19072 
        oprot.writeI32(kiter416)
19073 
        viter417.write(oprot)
4369 rajveer 19074 
      oprot.writeMapEnd()
19075 
      oprot.writeFieldEnd()
19076 
    if self.ex is not None:
19077 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
19078 
      self.ex.write(oprot)
19079 
      oprot.writeFieldEnd()
19080 
    oprot.writeFieldStop()
19081 
    oprot.writeStructEnd()
19082 
 
19083 
  def validate(self):
19084 
    return
19085 
 
19086 
 
19087 
  def __repr__(self):
19088 
    L = ['%s=%r' % (key, value)
19089 
      for key, value in self.__dict__.iteritems()]
19090 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
19091 
 
19092 
  def __eq__(self, other):
19093 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
19094 
 
19095 
  def __ne__(self, other):
19096 
    return not (self == other)
4386 anupam.sin 19097 
 
4662 rajveer 19098 
class markOrderAsLostInTransit_args:
19099 
  """
19100 
  Attributes:
19101 
   - orderId
19102 
  """
19103 
 
19104 
  thrift_spec = (
19105 
    None, # 0
19106 
    (1, TType.I64, 'orderId', None, None, ), # 1
19107 
  )
19108 
 
19109 
  def __init__(self, orderId=None,):
19110 
    self.orderId = orderId
19111 
 
19112 
  def read(self, iprot):
19113 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
19114 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
19115 
      return
19116 
    iprot.readStructBegin()
19117 
    while True:
19118 
      (fname, ftype, fid) = iprot.readFieldBegin()
19119 
      if ftype == TType.STOP:
19120 
        break
19121 
      if fid == 1:
19122 
        if ftype == TType.I64:
19123 
          self.orderId = iprot.readI64();
19124 
        else:
19125 
          iprot.skip(ftype)
19126 
      else:
19127 
        iprot.skip(ftype)
19128 
      iprot.readFieldEnd()
19129 
    iprot.readStructEnd()
19130 
 
19131 
  def write(self, oprot):
19132 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
19133 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
19134 
      return
19135 
    oprot.writeStructBegin('markOrderAsLostInTransit_args')
19136 
    if self.orderId is not None:
19137 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
19138 
      oprot.writeI64(self.orderId)
19139 
      oprot.writeFieldEnd()
19140 
    oprot.writeFieldStop()
19141 
    oprot.writeStructEnd()
19142 
 
19143 
  def validate(self):
19144 
    return
19145 
 
19146 
 
19147 
  def __repr__(self):
19148 
    L = ['%s=%r' % (key, value)
19149 
      for key, value in self.__dict__.iteritems()]
19150 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
19151 
 
19152 
  def __eq__(self, other):
19153 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
19154 
 
19155 
  def __ne__(self, other):
19156 
    return not (self == other)
19157 
 
19158 
class markOrderAsLostInTransit_result:
19159 
  """
19160 
  Attributes:
19161 
   - success
19162 
   - ex
19163 
  """
19164 
 
19165 
  thrift_spec = (
19166 
    (0, TType.BOOL, 'success', None, None, ), # 0
19167 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
19168 
  )
19169 
 
19170 
  def __init__(self, success=None, ex=None,):
19171 
    self.success = success
19172 
    self.ex = ex
19173 
 
19174 
  def read(self, iprot):
19175 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
19176 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
19177 
      return
19178 
    iprot.readStructBegin()
19179 
    while True:
19180 
      (fname, ftype, fid) = iprot.readFieldBegin()
19181 
      if ftype == TType.STOP:
19182 
        break
19183 
      if fid == 0:
19184 
        if ftype == TType.BOOL:
19185 
          self.success = iprot.readBool();
19186 
        else:
19187 
          iprot.skip(ftype)
19188 
      elif fid == 1:
19189 
        if ftype == TType.STRUCT:
19190 
          self.ex = TransactionServiceException()
19191 
          self.ex.read(iprot)
19192 
        else:
19193 
          iprot.skip(ftype)
19194 
      else:
19195 
        iprot.skip(ftype)
19196 
      iprot.readFieldEnd()
19197 
    iprot.readStructEnd()
19198 
 
19199 
  def write(self, oprot):
19200 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
19201 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
19202 
      return
19203 
    oprot.writeStructBegin('markOrderAsLostInTransit_result')
19204 
    if self.success is not None:
19205 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
19206 
      oprot.writeBool(self.success)
19207 
      oprot.writeFieldEnd()
19208 
    if self.ex is not None:
19209 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
19210 
      self.ex.write(oprot)
19211 
      oprot.writeFieldEnd()
19212 
    oprot.writeFieldStop()
19213 
    oprot.writeStructEnd()
19214 
 
19215 
  def validate(self):
19216 
    return
19217 
 
19218 
 
19219 
  def __repr__(self):
19220 
    L = ['%s=%r' % (key, value)
19221 
      for key, value in self.__dict__.iteritems()]
19222 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
19223 
 
19224 
  def __eq__(self, other):
19225 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
19226 
 
19227 
  def __ne__(self, other):
19228 
    return not (self == other)
19229 
 
4386 anupam.sin 19230 
class getOrderForAwb_args:
19231 
  """
19232 
  Attributes:
19233 
   - awb
19234 
  """
19235 
 
19236 
  thrift_spec = (
19237 
    None, # 0
19238 
    (1, TType.STRING, 'awb', None, None, ), # 1
19239 
  )
19240 
 
19241 
  def __init__(self, awb=None,):
19242 
    self.awb = awb
19243 
 
19244 
  def read(self, iprot):
19245 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
19246 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
19247 
      return
19248 
    iprot.readStructBegin()
19249 
    while True:
19250 
      (fname, ftype, fid) = iprot.readFieldBegin()
19251 
      if ftype == TType.STOP:
19252 
        break
19253 
      if fid == 1:
19254 
        if ftype == TType.STRING:
19255 
          self.awb = iprot.readString();
19256 
        else:
19257 
          iprot.skip(ftype)
19258 
      else:
19259 
        iprot.skip(ftype)
19260 
      iprot.readFieldEnd()
19261 
    iprot.readStructEnd()
19262 
 
19263 
  def write(self, oprot):
19264 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
19265 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
19266 
      return
19267 
    oprot.writeStructBegin('getOrderForAwb_args')
19268 
    if self.awb is not None:
19269 
      oprot.writeFieldBegin('awb', TType.STRING, 1)
19270 
      oprot.writeString(self.awb)
19271 
      oprot.writeFieldEnd()
19272 
    oprot.writeFieldStop()
19273 
    oprot.writeStructEnd()
19274 
 
19275 
  def validate(self):
19276 
    return
19277 
 
19278 
 
19279 
  def __repr__(self):
19280 
    L = ['%s=%r' % (key, value)
19281 
      for key, value in self.__dict__.iteritems()]
19282 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
19283 
 
19284 
  def __eq__(self, other):
19285 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
19286 
 
19287 
  def __ne__(self, other):
19288 
    return not (self == other)
19289 
 
19290 
class getOrderForAwb_result:
19291 
  """
19292 
  Attributes:
19293 
   - success
19294 
   - ex
19295 
  """
19296 
 
19297 
  thrift_spec = (
19298 
    (0, TType.STRUCT, 'success', (Order, Order.thrift_spec), None, ), # 0
19299 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
19300 
  )
19301 
 
19302 
  def __init__(self, success=None, ex=None,):
19303 
    self.success = success
19304 
    self.ex = ex
19305 
 
19306 
  def read(self, iprot):
19307 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
19308 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
19309 
      return
19310 
    iprot.readStructBegin()
19311 
    while True:
19312 
      (fname, ftype, fid) = iprot.readFieldBegin()
19313 
      if ftype == TType.STOP:
19314 
        break
19315 
      if fid == 0:
19316 
        if ftype == TType.STRUCT:
19317 
          self.success = Order()
19318 
          self.success.read(iprot)
19319 
        else:
19320 
          iprot.skip(ftype)
19321 
      elif fid == 1:
19322 
        if ftype == TType.STRUCT:
19323 
          self.ex = TransactionServiceException()
19324 
          self.ex.read(iprot)
19325 
        else:
19326 
          iprot.skip(ftype)
19327 
      else:
19328 
        iprot.skip(ftype)
19329 
      iprot.readFieldEnd()
19330 
    iprot.readStructEnd()
19331 
 
19332 
  def write(self, oprot):
19333 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
19334 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
19335 
      return
19336 
    oprot.writeStructBegin('getOrderForAwb_result')
19337 
    if self.success is not None:
19338 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
19339 
      self.success.write(oprot)
19340 
      oprot.writeFieldEnd()
19341 
    if self.ex is not None:
19342 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
19343 
      self.ex.write(oprot)
19344 
      oprot.writeFieldEnd()
19345 
    oprot.writeFieldStop()
19346 
    oprot.writeStructEnd()
19347 
 
19348 
  def validate(self):
19349 
    return
19350 
 
19351 
 
19352 
  def __repr__(self):
19353 
    L = ['%s=%r' % (key, value)
19354 
      for key, value in self.__dict__.iteritems()]
19355 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
19356 
 
19357 
  def __eq__(self, other):
19358 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
19359 
 
19360 
  def __ne__(self, other):
19361 
    return not (self == other)
4506 phani.kuma 19362 
 
19363 
class getOrdersForProviderForStatus_args:
19364 
  """
19365 
  Attributes:
19366 
   - logistics_provider_id
4910 phani.kuma 19367 
   - order_status_list
4506 phani.kuma 19368 
  """
19369 
 
19370 
  thrift_spec = (
19371 
    None, # 0
19372 
    (1, TType.I64, 'logistics_provider_id', None, None, ), # 1
4910 phani.kuma 19373 
    (2, TType.LIST, 'order_status_list', (TType.I32,None), None, ), # 2
4506 phani.kuma 19374 
  )
19375 
 
4910 phani.kuma 19376 
  def __init__(self, logistics_provider_id=None, order_status_list=None,):
4506 phani.kuma 19377 
    self.logistics_provider_id = logistics_provider_id
4910 phani.kuma 19378 
    self.order_status_list = order_status_list
4506 phani.kuma 19379 
 
19380 
  def read(self, iprot):
19381 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
19382 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
19383 
      return
19384 
    iprot.readStructBegin()
19385 
    while True:
19386 
      (fname, ftype, fid) = iprot.readFieldBegin()
19387 
      if ftype == TType.STOP:
19388 
        break
19389 
      if fid == 1:
19390 
        if ftype == TType.I64:
19391 
          self.logistics_provider_id = iprot.readI64();
19392 
        else:
19393 
          iprot.skip(ftype)
19394 
      elif fid == 2:
4910 phani.kuma 19395 
        if ftype == TType.LIST:
19396 
          self.order_status_list = []
5031 varun.gupt 19397 
          (_etype421, _size418) = iprot.readListBegin()
19398 
          for _i422 in xrange(_size418):
19399 
            _elem423 = iprot.readI32();
19400 
            self.order_status_list.append(_elem423)
4910 phani.kuma 19401 
          iprot.readListEnd()
4506 phani.kuma 19402 
        else:
19403 
          iprot.skip(ftype)
19404 
      else:
19405 
        iprot.skip(ftype)
19406 
      iprot.readFieldEnd()
19407 
    iprot.readStructEnd()
19408 
 
19409 
  def write(self, oprot):
19410 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
19411 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
19412 
      return
19413 
    oprot.writeStructBegin('getOrdersForProviderForStatus_args')
19414 
    if self.logistics_provider_id is not None:
19415 
      oprot.writeFieldBegin('logistics_provider_id', TType.I64, 1)
19416 
      oprot.writeI64(self.logistics_provider_id)
19417 
      oprot.writeFieldEnd()
4910 phani.kuma 19418 
    if self.order_status_list is not None:
19419 
      oprot.writeFieldBegin('order_status_list', TType.LIST, 2)
19420 
      oprot.writeListBegin(TType.I32, len(self.order_status_list))
5031 varun.gupt 19421 
      for iter424 in self.order_status_list:
19422 
        oprot.writeI32(iter424)
4910 phani.kuma 19423 
      oprot.writeListEnd()
4506 phani.kuma 19424 
      oprot.writeFieldEnd()
19425 
    oprot.writeFieldStop()
19426 
    oprot.writeStructEnd()
19427 
 
19428 
  def validate(self):
19429 
    return
19430 
 
19431 
 
19432 
  def __repr__(self):
19433 
    L = ['%s=%r' % (key, value)
19434 
      for key, value in self.__dict__.iteritems()]
19435 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
19436 
 
19437 
  def __eq__(self, other):
19438 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
19439 
 
19440 
  def __ne__(self, other):
19441 
    return not (self == other)
19442 
 
19443 
class getOrdersForProviderForStatus_result:
19444 
  """
19445 
  Attributes:
19446 
   - success
19447 
   - ex
19448 
  """
19449 
 
19450 
  thrift_spec = (
19451 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
19452 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
19453 
  )
19454 
 
19455 
  def __init__(self, success=None, ex=None,):
19456 
    self.success = success
19457 
    self.ex = ex
19458 
 
19459 
  def read(self, iprot):
19460 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
19461 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
19462 
      return
19463 
    iprot.readStructBegin()
19464 
    while True:
19465 
      (fname, ftype, fid) = iprot.readFieldBegin()
19466 
      if ftype == TType.STOP:
19467 
        break
19468 
      if fid == 0:
19469 
        if ftype == TType.LIST:
19470 
          self.success = []
5031 varun.gupt 19471 
          (_etype428, _size425) = iprot.readListBegin()
19472 
          for _i429 in xrange(_size425):
19473 
            _elem430 = Order()
19474 
            _elem430.read(iprot)
19475 
            self.success.append(_elem430)
4506 phani.kuma 19476 
          iprot.readListEnd()
19477 
        else:
19478 
          iprot.skip(ftype)
19479 
      elif fid == 1:
19480 
        if ftype == TType.STRUCT:
19481 
          self.ex = TransactionServiceException()
19482 
          self.ex.read(iprot)
19483 
        else:
19484 
          iprot.skip(ftype)
19485 
      else:
19486 
        iprot.skip(ftype)
19487 
      iprot.readFieldEnd()
19488 
    iprot.readStructEnd()
19489 
 
19490 
  def write(self, oprot):
19491 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
19492 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
19493 
      return
19494 
    oprot.writeStructBegin('getOrdersForProviderForStatus_result')
19495 
    if self.success is not None:
19496 
      oprot.writeFieldBegin('success', TType.LIST, 0)
19497 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
5031 varun.gupt 19498 
      for iter431 in self.success:
19499 
        iter431.write(oprot)
4506 phani.kuma 19500 
      oprot.writeListEnd()
19501 
      oprot.writeFieldEnd()
19502 
    if self.ex is not None:
19503 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
19504 
      self.ex.write(oprot)
19505 
      oprot.writeFieldEnd()
19506 
    oprot.writeFieldStop()
19507 
    oprot.writeStructEnd()
19508 
 
19509 
  def validate(self):
19510 
    return
19511 
 
19512 
 
19513 
  def __repr__(self):
19514 
    L = ['%s=%r' % (key, value)
19515 
      for key, value in self.__dict__.iteritems()]
19516 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
19517 
 
19518 
  def __eq__(self, other):
19519 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
19520 
 
19521 
  def __ne__(self, other):
19522 
    return not (self == other)
4600 varun.gupt 19523 
 
19524 
class getBilledOrdersForVendor_args:
19525 
  """
19526 
  Attributes:
19527 
   - vendorId
19528 
   - billingDateFrom
19529 
   - billingDateTo
19530 
  """
19531 
 
19532 
  thrift_spec = (
19533 
    None, # 0
19534 
    (1, TType.I64, 'vendorId', None, None, ), # 1
19535 
    (2, TType.I64, 'billingDateFrom', None, None, ), # 2
19536 
    (3, TType.I64, 'billingDateTo', None, None, ), # 3
19537 
  )
19538 
 
19539 
  def __init__(self, vendorId=None, billingDateFrom=None, billingDateTo=None,):
19540 
    self.vendorId = vendorId
19541 
    self.billingDateFrom = billingDateFrom
19542 
    self.billingDateTo = billingDateTo
19543 
 
19544 
  def read(self, iprot):
19545 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
19546 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
19547 
      return
19548 
    iprot.readStructBegin()
19549 
    while True:
19550 
      (fname, ftype, fid) = iprot.readFieldBegin()
19551 
      if ftype == TType.STOP:
19552 
        break
19553 
      if fid == 1:
19554 
        if ftype == TType.I64:
19555 
          self.vendorId = iprot.readI64();
19556 
        else:
19557 
          iprot.skip(ftype)
19558 
      elif fid == 2:
19559 
        if ftype == TType.I64:
19560 
          self.billingDateFrom = iprot.readI64();
19561 
        else:
19562 
          iprot.skip(ftype)
19563 
      elif fid == 3:
19564 
        if ftype == TType.I64:
19565 
          self.billingDateTo = iprot.readI64();
19566 
        else:
19567 
          iprot.skip(ftype)
19568 
      else:
19569 
        iprot.skip(ftype)
19570 
      iprot.readFieldEnd()
19571 
    iprot.readStructEnd()
19572 
 
19573 
  def write(self, oprot):
19574 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
19575 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
19576 
      return
19577 
    oprot.writeStructBegin('getBilledOrdersForVendor_args')
19578 
    if self.vendorId is not None:
19579 
      oprot.writeFieldBegin('vendorId', TType.I64, 1)
19580 
      oprot.writeI64(self.vendorId)
19581 
      oprot.writeFieldEnd()
19582 
    if self.billingDateFrom is not None:
19583 
      oprot.writeFieldBegin('billingDateFrom', TType.I64, 2)
19584 
      oprot.writeI64(self.billingDateFrom)
19585 
      oprot.writeFieldEnd()
19586 
    if self.billingDateTo is not None:
19587 
      oprot.writeFieldBegin('billingDateTo', TType.I64, 3)
19588 
      oprot.writeI64(self.billingDateTo)
19589 
      oprot.writeFieldEnd()
19590 
    oprot.writeFieldStop()
19591 
    oprot.writeStructEnd()
19592 
 
19593 
  def validate(self):
19594 
    return
19595 
 
19596 
 
19597 
  def __repr__(self):
19598 
    L = ['%s=%r' % (key, value)
19599 
      for key, value in self.__dict__.iteritems()]
19600 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
19601 
 
19602 
  def __eq__(self, other):
19603 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
19604 
 
19605 
  def __ne__(self, other):
19606 
    return not (self == other)
19607 
 
19608 
class getBilledOrdersForVendor_result:
19609 
  """
19610 
  Attributes:
19611 
   - success
19612 
   - ex
19613 
  """
19614 
 
19615 
  thrift_spec = (
19616 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
19617 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
19618 
  )
19619 
 
19620 
  def __init__(self, success=None, ex=None,):
19621 
    self.success = success
19622 
    self.ex = ex
19623 
 
19624 
  def read(self, iprot):
19625 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
19626 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
19627 
      return
19628 
    iprot.readStructBegin()
19629 
    while True:
19630 
      (fname, ftype, fid) = iprot.readFieldBegin()
19631 
      if ftype == TType.STOP:
19632 
        break
19633 
      if fid == 0:
19634 
        if ftype == TType.LIST:
19635 
          self.success = []
5031 varun.gupt 19636 
          (_etype435, _size432) = iprot.readListBegin()
19637 
          for _i436 in xrange(_size432):
19638 
            _elem437 = Order()
19639 
            _elem437.read(iprot)
19640 
            self.success.append(_elem437)
4600 varun.gupt 19641 
          iprot.readListEnd()
19642 
        else:
19643 
          iprot.skip(ftype)
19644 
      elif fid == 1:
19645 
        if ftype == TType.STRUCT:
19646 
          self.ex = TransactionServiceException()
19647 
          self.ex.read(iprot)
19648 
        else:
19649 
          iprot.skip(ftype)
19650 
      else:
19651 
        iprot.skip(ftype)
19652 
      iprot.readFieldEnd()
19653 
    iprot.readStructEnd()
19654 
 
19655 
  def write(self, oprot):
19656 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
19657 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
19658 
      return
19659 
    oprot.writeStructBegin('getBilledOrdersForVendor_result')
19660 
    if self.success is not None:
19661 
      oprot.writeFieldBegin('success', TType.LIST, 0)
19662 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
5031 varun.gupt 19663 
      for iter438 in self.success:
19664 
        iter438.write(oprot)
4600 varun.gupt 19665 
      oprot.writeListEnd()
19666 
      oprot.writeFieldEnd()
19667 
    if self.ex is not None:
19668 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
19669 
      self.ex.write(oprot)
19670 
      oprot.writeFieldEnd()
19671 
    oprot.writeFieldStop()
19672 
    oprot.writeStructEnd()
19673 
 
19674 
  def validate(self):
19675 
    return
19676 
 
19677 
 
19678 
  def __repr__(self):
19679 
    L = ['%s=%r' % (key, value)
19680 
      for key, value in self.__dict__.iteritems()]
19681 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
19682 
 
19683 
  def __eq__(self, other):
19684 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
19685 
 
19686 
  def __ne__(self, other):
19687 
    return not (self == other)
19688 
 
4607 rajveer 19689 
class getSlippedSippingDateOrders_args:
19690 
 
19691 
  thrift_spec = (
19692 
  )
19693 
 
19694 
  def read(self, iprot):
19695 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
19696 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
19697 
      return
19698 
    iprot.readStructBegin()
19699 
    while True:
19700 
      (fname, ftype, fid) = iprot.readFieldBegin()
19701 
      if ftype == TType.STOP:
19702 
        break
19703 
      else:
19704 
        iprot.skip(ftype)
19705 
      iprot.readFieldEnd()
19706 
    iprot.readStructEnd()
19707 
 
19708 
  def write(self, oprot):
19709 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
19710 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
19711 
      return
19712 
    oprot.writeStructBegin('getSlippedSippingDateOrders_args')
19713 
    oprot.writeFieldStop()
19714 
    oprot.writeStructEnd()
19715 
 
19716 
  def validate(self):
19717 
    return
19718 
 
19719 
 
19720 
  def __repr__(self):
19721 
    L = ['%s=%r' % (key, value)
19722 
      for key, value in self.__dict__.iteritems()]
19723 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
19724 
 
19725 
  def __eq__(self, other):
19726 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
19727 
 
19728 
  def __ne__(self, other):
19729 
    return not (self == other)
19730 
 
19731 
class getSlippedSippingDateOrders_result:
19732 
  """
19733 
  Attributes:
19734 
   - success
19735 
   - ex
19736 
  """
19737 
 
19738 
  thrift_spec = (
19739 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
19740 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
19741 
  )
19742 
 
19743 
  def __init__(self, success=None, ex=None,):
19744 
    self.success = success
19745 
    self.ex = ex
19746 
 
19747 
  def read(self, iprot):
19748 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
19749 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
19750 
      return
19751 
    iprot.readStructBegin()
19752 
    while True:
19753 
      (fname, ftype, fid) = iprot.readFieldBegin()
19754 
      if ftype == TType.STOP:
19755 
        break
19756 
      if fid == 0:
19757 
        if ftype == TType.LIST:
19758 
          self.success = []
5031 varun.gupt 19759 
          (_etype442, _size439) = iprot.readListBegin()
19760 
          for _i443 in xrange(_size439):
19761 
            _elem444 = Order()
19762 
            _elem444.read(iprot)
19763 
            self.success.append(_elem444)
4607 rajveer 19764 
          iprot.readListEnd()
19765 
        else:
19766 
          iprot.skip(ftype)
19767 
      elif fid == 1:
19768 
        if ftype == TType.STRUCT:
19769 
          self.ex = TransactionServiceException()
19770 
          self.ex.read(iprot)
19771 
        else:
19772 
          iprot.skip(ftype)
19773 
      else:
19774 
        iprot.skip(ftype)
19775 
      iprot.readFieldEnd()
19776 
    iprot.readStructEnd()
19777 
 
19778 
  def write(self, oprot):
19779 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
19780 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
19781 
      return
19782 
    oprot.writeStructBegin('getSlippedSippingDateOrders_result')
19783 
    if self.success is not None:
19784 
      oprot.writeFieldBegin('success', TType.LIST, 0)
19785 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
5031 varun.gupt 19786 
      for iter445 in self.success:
19787 
        iter445.write(oprot)
4607 rajveer 19788 
      oprot.writeListEnd()
19789 
      oprot.writeFieldEnd()
19790 
    if self.ex is not None:
19791 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
19792 
      self.ex.write(oprot)
19793 
      oprot.writeFieldEnd()
19794 
    oprot.writeFieldStop()
19795 
    oprot.writeStructEnd()
19796 
 
19797 
  def validate(self):
19798 
    return
19799 
 
19800 
 
19801 
  def __repr__(self):
19802 
    L = ['%s=%r' % (key, value)
19803 
      for key, value in self.__dict__.iteritems()]
19804 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
19805 
 
19806 
  def __eq__(self, other):
19807 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
19808 
 
19809 
  def __ne__(self, other):
19810 
    return not (self == other)
19811 
 
4709 rajveer 19812 
class getCancelledOrders_args:
19813 
  """
19814 
  Attributes:
19815 
   - cancelDateFrom
19816 
   - cancelDateTo
19817 
  """
19818 
 
19819 
  thrift_spec = (
19820 
    None, # 0
19821 
    (1, TType.I64, 'cancelDateFrom', None, None, ), # 1
19822 
    (2, TType.I64, 'cancelDateTo', None, None, ), # 2
19823 
  )
19824 
 
19825 
  def __init__(self, cancelDateFrom=None, cancelDateTo=None,):
19826 
    self.cancelDateFrom = cancelDateFrom
19827 
    self.cancelDateTo = cancelDateTo
19828 
 
19829 
  def read(self, iprot):
19830 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
19831 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
19832 
      return
19833 
    iprot.readStructBegin()
19834 
    while True:
19835 
      (fname, ftype, fid) = iprot.readFieldBegin()
19836 
      if ftype == TType.STOP:
19837 
        break
19838 
      if fid == 1:
19839 
        if ftype == TType.I64:
19840 
          self.cancelDateFrom = iprot.readI64();
19841 
        else:
19842 
          iprot.skip(ftype)
19843 
      elif fid == 2:
19844 
        if ftype == TType.I64:
19845 
          self.cancelDateTo = iprot.readI64();
19846 
        else:
19847 
          iprot.skip(ftype)
19848 
      else:
19849 
        iprot.skip(ftype)
19850 
      iprot.readFieldEnd()
19851 
    iprot.readStructEnd()
19852 
 
19853 
  def write(self, oprot):
19854 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
19855 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
19856 
      return
19857 
    oprot.writeStructBegin('getCancelledOrders_args')
19858 
    if self.cancelDateFrom is not None:
19859 
      oprot.writeFieldBegin('cancelDateFrom', TType.I64, 1)
19860 
      oprot.writeI64(self.cancelDateFrom)
19861 
      oprot.writeFieldEnd()
19862 
    if self.cancelDateTo is not None:
19863 
      oprot.writeFieldBegin('cancelDateTo', TType.I64, 2)
19864 
      oprot.writeI64(self.cancelDateTo)
19865 
      oprot.writeFieldEnd()
19866 
    oprot.writeFieldStop()
19867 
    oprot.writeStructEnd()
19868 
 
19869 
  def validate(self):
19870 
    return
19871 
 
19872 
 
19873 
  def __repr__(self):
19874 
    L = ['%s=%r' % (key, value)
19875 
      for key, value in self.__dict__.iteritems()]
19876 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
19877 
 
19878 
  def __eq__(self, other):
19879 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
19880 
 
19881 
  def __ne__(self, other):
19882 
    return not (self == other)
19883 
 
19884 
class getCancelledOrders_result:
19885 
  """
19886 
  Attributes:
19887 
   - success
19888 
   - ex
19889 
  """
19890 
 
19891 
  thrift_spec = (
19892 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
19893 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
19894 
  )
19895 
 
19896 
  def __init__(self, success=None, ex=None,):
19897 
    self.success = success
19898 
    self.ex = ex
19899 
 
19900 
  def read(self, iprot):
19901 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
19902 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
19903 
      return
19904 
    iprot.readStructBegin()
19905 
    while True:
19906 
      (fname, ftype, fid) = iprot.readFieldBegin()
19907 
      if ftype == TType.STOP:
19908 
        break
19909 
      if fid == 0:
19910 
        if ftype == TType.LIST:
19911 
          self.success = []
5031 varun.gupt 19912 
          (_etype449, _size446) = iprot.readListBegin()
19913 
          for _i450 in xrange(_size446):
19914 
            _elem451 = Order()
19915 
            _elem451.read(iprot)
19916 
            self.success.append(_elem451)
4709 rajveer 19917 
          iprot.readListEnd()
19918 
        else:
19919 
          iprot.skip(ftype)
19920 
      elif fid == 1:
19921 
        if ftype == TType.STRUCT:
19922 
          self.ex = TransactionServiceException()
19923 
          self.ex.read(iprot)
19924 
        else:
19925 
          iprot.skip(ftype)
19926 
      else:
19927 
        iprot.skip(ftype)
19928 
      iprot.readFieldEnd()
19929 
    iprot.readStructEnd()
19930 
 
19931 
  def write(self, oprot):
19932 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
19933 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
19934 
      return
19935 
    oprot.writeStructBegin('getCancelledOrders_result')
19936 
    if self.success is not None:
19937 
      oprot.writeFieldBegin('success', TType.LIST, 0)
19938 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
5031 varun.gupt 19939 
      for iter452 in self.success:
19940 
        iter452.write(oprot)
4709 rajveer 19941 
      oprot.writeListEnd()
19942 
      oprot.writeFieldEnd()
19943 
    if self.ex is not None:
19944 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
19945 
      self.ex.write(oprot)
19946 
      oprot.writeFieldEnd()
19947 
    oprot.writeFieldStop()
19948 
    oprot.writeStructEnd()
19949 
 
19950 
  def validate(self):
19951 
    return
19952 
 
19953 
 
19954 
  def __repr__(self):
19955 
    L = ['%s=%r' % (key, value)
19956 
      for key, value in self.__dict__.iteritems()]
19957 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
19958 
 
19959 
  def __eq__(self, other):
19960 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
19961 
 
19962 
  def __ne__(self, other):
19963 
    return not (self == other)
19964 
 
4600 varun.gupt 19965 
class saveBluedartSettlements_args:
19966 
  """
19967 
  Attributes:
19968 
   - mapAWBAndAmount
19969 
  """
19970 
 
19971 
  thrift_spec = (
19972 
    None, # 0
19973 
    (1, TType.MAP, 'mapAWBAndAmount', (TType.I64,None,TType.DOUBLE,None), None, ), # 1
19974 
  )
19975 
 
19976 
  def __init__(self, mapAWBAndAmount=None,):
19977 
    self.mapAWBAndAmount = mapAWBAndAmount
19978 
 
19979 
  def read(self, iprot):
19980 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
19981 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
19982 
      return
19983 
    iprot.readStructBegin()
19984 
    while True:
19985 
      (fname, ftype, fid) = iprot.readFieldBegin()
19986 
      if ftype == TType.STOP:
19987 
        break
19988 
      if fid == 1:
19989 
        if ftype == TType.MAP:
19990 
          self.mapAWBAndAmount = {}
5031 varun.gupt 19991 
          (_ktype454, _vtype455, _size453 ) = iprot.readMapBegin()
19992 
          for _i457 in xrange(_size453):
19993 
            _key458 = iprot.readI64();
19994 
            _val459 = iprot.readDouble();
19995 
            self.mapAWBAndAmount[_key458] = _val459
4600 varun.gupt 19996 
          iprot.readMapEnd()
19997 
        else:
19998 
          iprot.skip(ftype)
19999 
      else:
20000 
        iprot.skip(ftype)
20001 
      iprot.readFieldEnd()
20002 
    iprot.readStructEnd()
20003 
 
20004 
  def write(self, oprot):
20005 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
20006 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
20007 
      return
20008 
    oprot.writeStructBegin('saveBluedartSettlements_args')
20009 
    if self.mapAWBAndAmount is not None:
20010 
      oprot.writeFieldBegin('mapAWBAndAmount', TType.MAP, 1)
20011 
      oprot.writeMapBegin(TType.I64, TType.DOUBLE, len(self.mapAWBAndAmount))
5031 varun.gupt 20012 
      for kiter460,viter461 in self.mapAWBAndAmount.items():
20013 
        oprot.writeI64(kiter460)
20014 
        oprot.writeDouble(viter461)
4600 varun.gupt 20015 
      oprot.writeMapEnd()
20016 
      oprot.writeFieldEnd()
20017 
    oprot.writeFieldStop()
20018 
    oprot.writeStructEnd()
20019 
 
20020 
  def validate(self):
20021 
    return
20022 
 
20023 
 
20024 
  def __repr__(self):
20025 
    L = ['%s=%r' % (key, value)
20026 
      for key, value in self.__dict__.iteritems()]
20027 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
20028 
 
20029 
  def __eq__(self, other):
20030 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
20031 
 
20032 
  def __ne__(self, other):
20033 
    return not (self == other)
20034 
 
20035 
class saveBluedartSettlements_result:
20036 
  """
20037 
  Attributes:
20038 
   - ex
20039 
  """
20040 
 
20041 
  thrift_spec = (
20042 
    None, # 0
20043 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
20044 
  )
20045 
 
20046 
  def __init__(self, ex=None,):
20047 
    self.ex = ex
20048 
 
20049 
  def read(self, iprot):
20050 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
20051 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
20052 
      return
20053 
    iprot.readStructBegin()
20054 
    while True:
20055 
      (fname, ftype, fid) = iprot.readFieldBegin()
20056 
      if ftype == TType.STOP:
20057 
        break
20058 
      if fid == 1:
20059 
        if ftype == TType.STRUCT:
20060 
          self.ex = TransactionServiceException()
20061 
          self.ex.read(iprot)
20062 
        else:
20063 
          iprot.skip(ftype)
20064 
      else:
20065 
        iprot.skip(ftype)
20066 
      iprot.readFieldEnd()
20067 
    iprot.readStructEnd()
20068 
 
20069 
  def write(self, oprot):
20070 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
20071 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
20072 
      return
20073 
    oprot.writeStructBegin('saveBluedartSettlements_result')
20074 
    if self.ex is not None:
20075 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
20076 
      self.ex.write(oprot)
20077 
      oprot.writeFieldEnd()
20078 
    oprot.writeFieldStop()
20079 
    oprot.writeStructEnd()
20080 
 
20081 
  def validate(self):
20082 
    return
20083 
 
20084 
 
20085 
  def __repr__(self):
20086 
    L = ['%s=%r' % (key, value)
20087 
      for key, value in self.__dict__.iteritems()]
20088 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
20089 
 
20090 
  def __eq__(self, other):
20091 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
20092 
 
20093 
  def __ne__(self, other):
20094 
    return not (self == other)
20095 
 
20096 
class savePaymentSettlements_args:
20097 
  """
20098 
  Attributes:
20099 
   - settlementDate
20100 
   - paymentGatewayId
4905 varun.gupt 20101 
   - referenceId
4600 varun.gupt 20102 
   - serviceTax
20103 
   - otherCharges
20104 
   - netCollection
20105 
  """
20106 
 
20107 
  thrift_spec = (
20108 
    None, # 0
20109 
    (1, TType.I64, 'settlementDate', None, None, ), # 1
20110 
    (2, TType.I64, 'paymentGatewayId', None, None, ), # 2
4905 varun.gupt 20111 
    (3, TType.I64, 'referenceId', None, None, ), # 3
4600 varun.gupt 20112 
    (4, TType.DOUBLE, 'serviceTax', None, None, ), # 4
20113 
    (5, TType.DOUBLE, 'otherCharges', None, None, ), # 5
20114 
    (6, TType.DOUBLE, 'netCollection', None, None, ), # 6
20115 
  )
20116 
 
4905 varun.gupt 20117 
  def __init__(self, settlementDate=None, paymentGatewayId=None, referenceId=None, serviceTax=None, otherCharges=None, netCollection=None,):
4600 varun.gupt 20118 
    self.settlementDate = settlementDate
20119 
    self.paymentGatewayId = paymentGatewayId
4905 varun.gupt 20120 
    self.referenceId = referenceId
4600 varun.gupt 20121 
    self.serviceTax = serviceTax
20122 
    self.otherCharges = otherCharges
20123 
    self.netCollection = netCollection
20124 
 
20125 
  def read(self, iprot):
20126 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
20127 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
20128 
      return
20129 
    iprot.readStructBegin()
20130 
    while True:
20131 
      (fname, ftype, fid) = iprot.readFieldBegin()
20132 
      if ftype == TType.STOP:
20133 
        break
20134 
      if fid == 1:
20135 
        if ftype == TType.I64:
20136 
          self.settlementDate = iprot.readI64();
20137 
        else:
20138 
          iprot.skip(ftype)
20139 
      elif fid == 2:
20140 
        if ftype == TType.I64:
20141 
          self.paymentGatewayId = iprot.readI64();
20142 
        else:
20143 
          iprot.skip(ftype)
20144 
      elif fid == 3:
20145 
        if ftype == TType.I64:
4905 varun.gupt 20146 
          self.referenceId = iprot.readI64();
4600 varun.gupt 20147 
        else:
20148 
          iprot.skip(ftype)
20149 
      elif fid == 4:
20150 
        if ftype == TType.DOUBLE:
20151 
          self.serviceTax = iprot.readDouble();
20152 
        else:
20153 
          iprot.skip(ftype)
20154 
      elif fid == 5:
20155 
        if ftype == TType.DOUBLE:
20156 
          self.otherCharges = iprot.readDouble();
20157 
        else:
20158 
          iprot.skip(ftype)
20159 
      elif fid == 6:
20160 
        if ftype == TType.DOUBLE:
20161 
          self.netCollection = iprot.readDouble();
20162 
        else:
20163 
          iprot.skip(ftype)
20164 
      else:
20165 
        iprot.skip(ftype)
20166 
      iprot.readFieldEnd()
20167 
    iprot.readStructEnd()
20168 
 
20169 
  def write(self, oprot):
20170 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
20171 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
20172 
      return
20173 
    oprot.writeStructBegin('savePaymentSettlements_args')
20174 
    if self.settlementDate is not None:
20175 
      oprot.writeFieldBegin('settlementDate', TType.I64, 1)
20176 
      oprot.writeI64(self.settlementDate)
20177 
      oprot.writeFieldEnd()
20178 
    if self.paymentGatewayId is not None:
20179 
      oprot.writeFieldBegin('paymentGatewayId', TType.I64, 2)
20180 
      oprot.writeI64(self.paymentGatewayId)
20181 
      oprot.writeFieldEnd()
4905 varun.gupt 20182 
    if self.referenceId is not None:
20183 
      oprot.writeFieldBegin('referenceId', TType.I64, 3)
20184 
      oprot.writeI64(self.referenceId)
4600 varun.gupt 20185 
      oprot.writeFieldEnd()
20186 
    if self.serviceTax is not None:
20187 
      oprot.writeFieldBegin('serviceTax', TType.DOUBLE, 4)
20188 
      oprot.writeDouble(self.serviceTax)
20189 
      oprot.writeFieldEnd()
20190 
    if self.otherCharges is not None:
20191 
      oprot.writeFieldBegin('otherCharges', TType.DOUBLE, 5)
20192 
      oprot.writeDouble(self.otherCharges)
20193 
      oprot.writeFieldEnd()
20194 
    if self.netCollection is not None:
20195 
      oprot.writeFieldBegin('netCollection', TType.DOUBLE, 6)
20196 
      oprot.writeDouble(self.netCollection)
20197 
      oprot.writeFieldEnd()
20198 
    oprot.writeFieldStop()
20199 
    oprot.writeStructEnd()
20200 
 
20201 
  def validate(self):
20202 
    return
20203 
 
20204 
 
20205 
  def __repr__(self):
20206 
    L = ['%s=%r' % (key, value)
20207 
      for key, value in self.__dict__.iteritems()]
20208 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
20209 
 
20210 
  def __eq__(self, other):
20211 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
20212 
 
20213 
  def __ne__(self, other):
20214 
    return not (self == other)
20215 
 
20216 
class savePaymentSettlements_result:
20217 
  """
20218 
  Attributes:
20219 
   - ex
20220 
  """
20221 
 
20222 
  thrift_spec = (
20223 
    None, # 0
20224 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
20225 
  )
20226 
 
20227 
  def __init__(self, ex=None,):
20228 
    self.ex = ex
20229 
 
20230 
  def read(self, iprot):
20231 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
20232 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
20233 
      return
20234 
    iprot.readStructBegin()
20235 
    while True:
20236 
      (fname, ftype, fid) = iprot.readFieldBegin()
20237 
      if ftype == TType.STOP:
20238 
        break
20239 
      if fid == 1:
20240 
        if ftype == TType.STRUCT:
20241 
          self.ex = TransactionServiceException()
20242 
          self.ex.read(iprot)
20243 
        else:
20244 
          iprot.skip(ftype)
20245 
      else:
20246 
        iprot.skip(ftype)
20247 
      iprot.readFieldEnd()
20248 
    iprot.readStructEnd()
20249 
 
20250 
  def write(self, oprot):
20251 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
20252 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
20253 
      return
20254 
    oprot.writeStructBegin('savePaymentSettlements_result')
20255 
    if self.ex is not None:
20256 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
20257 
      self.ex.write(oprot)
20258 
      oprot.writeFieldEnd()
20259 
    oprot.writeFieldStop()
20260 
    oprot.writeStructEnd()
20261 
 
20262 
  def validate(self):
20263 
    return
20264 
 
20265 
 
20266 
  def __repr__(self):
20267 
    L = ['%s=%r' % (key, value)
20268 
      for key, value in self.__dict__.iteritems()]
20269 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
20270 
 
20271 
  def __eq__(self, other):
20272 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
20273 
 
20274 
  def __ne__(self, other):
20275 
    return not (self == other)
20276 
 
20277 
class saveEBSSettlementSummary_args:
20278 
  """
20279 
  Attributes:
20280 
   - settlementId
20281 
   - settlementDate
20282 
   - transactionDateFrom
20283 
   - transactionDateTo
20284 
   - amount
20285 
  """
20286 
 
20287 
  thrift_spec = (
20288 
    None, # 0
20289 
    (1, TType.I64, 'settlementId', None, None, ), # 1
20290 
    (2, TType.I64, 'settlementDate', None, None, ), # 2
20291 
    (3, TType.I64, 'transactionDateFrom', None, None, ), # 3
20292 
    (4, TType.I64, 'transactionDateTo', None, None, ), # 4
20293 
    (5, TType.DOUBLE, 'amount', None, None, ), # 5
20294 
  )
20295 
 
20296 
  def __init__(self, settlementId=None, settlementDate=None, transactionDateFrom=None, transactionDateTo=None, amount=None,):
20297 
    self.settlementId = settlementId
20298 
    self.settlementDate = settlementDate
20299 
    self.transactionDateFrom = transactionDateFrom
20300 
    self.transactionDateTo = transactionDateTo
20301 
    self.amount = amount
20302 
 
20303 
  def read(self, iprot):
20304 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
20305 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
20306 
      return
20307 
    iprot.readStructBegin()
20308 
    while True:
20309 
      (fname, ftype, fid) = iprot.readFieldBegin()
20310 
      if ftype == TType.STOP:
20311 
        break
20312 
      if fid == 1:
20313 
        if ftype == TType.I64:
20314 
          self.settlementId = iprot.readI64();
20315 
        else:
20316 
          iprot.skip(ftype)
20317 
      elif fid == 2:
20318 
        if ftype == TType.I64:
20319 
          self.settlementDate = iprot.readI64();
20320 
        else:
20321 
          iprot.skip(ftype)
20322 
      elif fid == 3:
20323 
        if ftype == TType.I64:
20324 
          self.transactionDateFrom = iprot.readI64();
20325 
        else:
20326 
          iprot.skip(ftype)
20327 
      elif fid == 4:
20328 
        if ftype == TType.I64:
20329 
          self.transactionDateTo = iprot.readI64();
20330 
        else:
20331 
          iprot.skip(ftype)
20332 
      elif fid == 5:
20333 
        if ftype == TType.DOUBLE:
20334 
          self.amount = iprot.readDouble();
20335 
        else:
20336 
          iprot.skip(ftype)
20337 
      else:
20338 
        iprot.skip(ftype)
20339 
      iprot.readFieldEnd()
20340 
    iprot.readStructEnd()
20341 
 
20342 
  def write(self, oprot):
20343 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
20344 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
20345 
      return
20346 
    oprot.writeStructBegin('saveEBSSettlementSummary_args')
20347 
    if self.settlementId is not None:
20348 
      oprot.writeFieldBegin('settlementId', TType.I64, 1)
20349 
      oprot.writeI64(self.settlementId)
20350 
      oprot.writeFieldEnd()
20351 
    if self.settlementDate is not None:
20352 
      oprot.writeFieldBegin('settlementDate', TType.I64, 2)
20353 
      oprot.writeI64(self.settlementDate)
20354 
      oprot.writeFieldEnd()
20355 
    if self.transactionDateFrom is not None:
20356 
      oprot.writeFieldBegin('transactionDateFrom', TType.I64, 3)
20357 
      oprot.writeI64(self.transactionDateFrom)
20358 
      oprot.writeFieldEnd()
20359 
    if self.transactionDateTo is not None:
20360 
      oprot.writeFieldBegin('transactionDateTo', TType.I64, 4)
20361 
      oprot.writeI64(self.transactionDateTo)
20362 
      oprot.writeFieldEnd()
20363 
    if self.amount is not None:
20364 
      oprot.writeFieldBegin('amount', TType.DOUBLE, 5)
20365 
      oprot.writeDouble(self.amount)
20366 
      oprot.writeFieldEnd()
20367 
    oprot.writeFieldStop()
20368 
    oprot.writeStructEnd()
20369 
 
20370 
  def validate(self):
20371 
    return
20372 
 
20373 
 
20374 
  def __repr__(self):
20375 
    L = ['%s=%r' % (key, value)
20376 
      for key, value in self.__dict__.iteritems()]
20377 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
20378 
 
20379 
  def __eq__(self, other):
20380 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
20381 
 
20382 
  def __ne__(self, other):
20383 
    return not (self == other)
20384 
 
20385 
class saveEBSSettlementSummary_result:
20386 
  """
20387 
  Attributes:
20388 
   - ex
20389 
  """
20390 
 
20391 
  thrift_spec = (
20392 
    None, # 0
20393 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
20394 
  )
20395 
 
20396 
  def __init__(self, ex=None,):
20397 
    self.ex = ex
20398 
 
20399 
  def read(self, iprot):
20400 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
20401 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
20402 
      return
20403 
    iprot.readStructBegin()
20404 
    while True:
20405 
      (fname, ftype, fid) = iprot.readFieldBegin()
20406 
      if ftype == TType.STOP:
20407 
        break
20408 
      if fid == 1:
20409 
        if ftype == TType.STRUCT:
20410 
          self.ex = TransactionServiceException()
20411 
          self.ex.read(iprot)
20412 
        else:
20413 
          iprot.skip(ftype)
20414 
      else:
20415 
        iprot.skip(ftype)
20416 
      iprot.readFieldEnd()
20417 
    iprot.readStructEnd()
20418 
 
20419 
  def write(self, oprot):
20420 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
20421 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
20422 
      return
20423 
    oprot.writeStructBegin('saveEBSSettlementSummary_result')
20424 
    if self.ex is not None:
20425 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
20426 
      self.ex.write(oprot)
20427 
      oprot.writeFieldEnd()
20428 
    oprot.writeFieldStop()
20429 
    oprot.writeStructEnd()
20430 
 
20431 
  def validate(self):
20432 
    return
20433 
 
20434 
 
20435 
  def __repr__(self):
20436 
    L = ['%s=%r' % (key, value)
20437 
      for key, value in self.__dict__.iteritems()]
20438 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
20439 
 
20440 
  def __eq__(self, other):
20441 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
20442 
 
20443 
  def __ne__(self, other):
20444 
    return not (self == other)
20445 
 
20446 
class getSettlementForPaymentId_args:
20447 
  """
20448 
  Attributes:
20449 
   - paymentId
20450 
  """
20451 
 
20452 
  thrift_spec = (
20453 
    None, # 0
20454 
    (1, TType.I64, 'paymentId', None, None, ), # 1
20455 
  )
20456 
 
20457 
  def __init__(self, paymentId=None,):
20458 
    self.paymentId = paymentId
20459 
 
20460 
  def read(self, iprot):
20461 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
20462 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
20463 
      return
20464 
    iprot.readStructBegin()
20465 
    while True:
20466 
      (fname, ftype, fid) = iprot.readFieldBegin()
20467 
      if ftype == TType.STOP:
20468 
        break
20469 
      if fid == 1:
20470 
        if ftype == TType.I64:
20471 
          self.paymentId = iprot.readI64();
20472 
        else:
20473 
          iprot.skip(ftype)
20474 
      else:
20475 
        iprot.skip(ftype)
20476 
      iprot.readFieldEnd()
20477 
    iprot.readStructEnd()
20478 
 
20479 
  def write(self, oprot):
20480 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
20481 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
20482 
      return
20483 
    oprot.writeStructBegin('getSettlementForPaymentId_args')
20484 
    if self.paymentId is not None:
20485 
      oprot.writeFieldBegin('paymentId', TType.I64, 1)
20486 
      oprot.writeI64(self.paymentId)
20487 
      oprot.writeFieldEnd()
20488 
    oprot.writeFieldStop()
20489 
    oprot.writeStructEnd()
20490 
 
20491 
  def validate(self):
20492 
    return
20493 
 
20494 
 
20495 
  def __repr__(self):
20496 
    L = ['%s=%r' % (key, value)
20497 
      for key, value in self.__dict__.iteritems()]
20498 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
20499 
 
20500 
  def __eq__(self, other):
20501 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
20502 
 
20503 
  def __ne__(self, other):
20504 
    return not (self == other)
20505 
 
20506 
class getSettlementForPaymentId_result:
20507 
  """
20508 
  Attributes:
20509 
   - success
20510 
   - ex
20511 
  """
20512 
 
20513 
  thrift_spec = (
20514 
    (0, TType.STRUCT, 'success', (PaymentSettlement, PaymentSettlement.thrift_spec), None, ), # 0
20515 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
20516 
  )
20517 
 
20518 
  def __init__(self, success=None, ex=None,):
20519 
    self.success = success
20520 
    self.ex = ex
20521 
 
20522 
  def read(self, iprot):
20523 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
20524 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
20525 
      return
20526 
    iprot.readStructBegin()
20527 
    while True:
20528 
      (fname, ftype, fid) = iprot.readFieldBegin()
20529 
      if ftype == TType.STOP:
20530 
        break
20531 
      if fid == 0:
20532 
        if ftype == TType.STRUCT:
20533 
          self.success = PaymentSettlement()
20534 
          self.success.read(iprot)
20535 
        else:
20536 
          iprot.skip(ftype)
20537 
      elif fid == 1:
20538 
        if ftype == TType.STRUCT:
20539 
          self.ex = TransactionServiceException()
20540 
          self.ex.read(iprot)
20541 
        else:
20542 
          iprot.skip(ftype)
20543 
      else:
20544 
        iprot.skip(ftype)
20545 
      iprot.readFieldEnd()
20546 
    iprot.readStructEnd()
20547 
 
20548 
  def write(self, oprot):
20549 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
20550 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
20551 
      return
20552 
    oprot.writeStructBegin('getSettlementForPaymentId_result')
20553 
    if self.success is not None:
20554 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
20555 
      self.success.write(oprot)
20556 
      oprot.writeFieldEnd()
20557 
    if self.ex is not None:
20558 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
20559 
      self.ex.write(oprot)
20560 
      oprot.writeFieldEnd()
20561 
    oprot.writeFieldStop()
20562 
    oprot.writeStructEnd()
20563 
 
20564 
  def validate(self):
20565 
    return
20566 
 
20567 
 
20568 
  def __repr__(self):
20569 
    L = ['%s=%r' % (key, value)
20570 
      for key, value in self.__dict__.iteritems()]
20571 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
20572 
 
20573 
  def __eq__(self, other):
20574 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
20575 
 
20576 
  def __ne__(self, other):
20577 
    return not (self == other)
20578 
 
20579 
class getEBSSettlementSummaries_args:
20580 
 
20581 
  thrift_spec = (
20582 
  )
20583 
 
20584 
  def read(self, iprot):
20585 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
20586 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
20587 
      return
20588 
    iprot.readStructBegin()
20589 
    while True:
20590 
      (fname, ftype, fid) = iprot.readFieldBegin()
20591 
      if ftype == TType.STOP:
20592 
        break
20593 
      else:
20594 
        iprot.skip(ftype)
20595 
      iprot.readFieldEnd()
20596 
    iprot.readStructEnd()
20597 
 
20598 
  def write(self, oprot):
20599 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
20600 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
20601 
      return
20602 
    oprot.writeStructBegin('getEBSSettlementSummaries_args')
20603 
    oprot.writeFieldStop()
20604 
    oprot.writeStructEnd()
20605 
 
20606 
  def validate(self):
20607 
    return
20608 
 
20609 
 
20610 
  def __repr__(self):
20611 
    L = ['%s=%r' % (key, value)
20612 
      for key, value in self.__dict__.iteritems()]
20613 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
20614 
 
20615 
  def __eq__(self, other):
20616 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
20617 
 
20618 
  def __ne__(self, other):
20619 
    return not (self == other)
20620 
 
20621 
class getEBSSettlementSummaries_result:
20622 
  """
20623 
  Attributes:
20624 
   - success
20625 
   - ex
20626 
  """
20627 
 
20628 
  thrift_spec = (
20629 
    (0, TType.MAP, 'success', (TType.I64,None,TType.STRING,None), None, ), # 0
20630 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
20631 
  )
20632 
 
20633 
  def __init__(self, success=None, ex=None,):
20634 
    self.success = success
20635 
    self.ex = ex
20636 
 
20637 
  def read(self, iprot):
20638 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
20639 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
20640 
      return
20641 
    iprot.readStructBegin()
20642 
    while True:
20643 
      (fname, ftype, fid) = iprot.readFieldBegin()
20644 
      if ftype == TType.STOP:
20645 
        break
20646 
      if fid == 0:
20647 
        if ftype == TType.MAP:
20648 
          self.success = {}
5031 varun.gupt 20649 
          (_ktype463, _vtype464, _size462 ) = iprot.readMapBegin()
20650 
          for _i466 in xrange(_size462):
20651 
            _key467 = iprot.readI64();
20652 
            _val468 = iprot.readString();
20653 
            self.success[_key467] = _val468
4600 varun.gupt 20654 
          iprot.readMapEnd()
20655 
        else:
20656 
          iprot.skip(ftype)
20657 
      elif fid == 1:
20658 
        if ftype == TType.STRUCT:
20659 
          self.ex = TransactionServiceException()
20660 
          self.ex.read(iprot)
20661 
        else:
20662 
          iprot.skip(ftype)
20663 
      else:
20664 
        iprot.skip(ftype)
20665 
      iprot.readFieldEnd()
20666 
    iprot.readStructEnd()
20667 
 
20668 
  def write(self, oprot):
20669 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
20670 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
20671 
      return
20672 
    oprot.writeStructBegin('getEBSSettlementSummaries_result')
20673 
    if self.success is not None:
20674 
      oprot.writeFieldBegin('success', TType.MAP, 0)
20675 
      oprot.writeMapBegin(TType.I64, TType.STRING, len(self.success))
5031 varun.gupt 20676 
      for kiter469,viter470 in self.success.items():
20677 
        oprot.writeI64(kiter469)
20678 
        oprot.writeString(viter470)
4600 varun.gupt 20679 
      oprot.writeMapEnd()
20680 
      oprot.writeFieldEnd()
20681 
    if self.ex is not None:
20682 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
20683 
      self.ex.write(oprot)
20684 
      oprot.writeFieldEnd()
20685 
    oprot.writeFieldStop()
20686 
    oprot.writeStructEnd()
20687 
 
20688 
  def validate(self):
20689 
    return
20690 
 
20691 
 
20692 
  def __repr__(self):
20693 
    L = ['%s=%r' % (key, value)
20694 
      for key, value in self.__dict__.iteritems()]
20695 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
20696 
 
20697 
  def __eq__(self, other):
20698 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
20699 
 
20700 
  def __ne__(self, other):
20701 
    return not (self == other)
20702 
 
20703 
class markEBSSettlementUploaded_args:
20704 
  """
20705 
  Attributes:
20706 
   - settlementId
20707 
  """
20708 
 
20709 
  thrift_spec = (
20710 
    None, # 0
20711 
    (1, TType.I64, 'settlementId', None, None, ), # 1
20712 
  )
20713 
 
20714 
  def __init__(self, settlementId=None,):
20715 
    self.settlementId = settlementId
20716 
 
20717 
  def read(self, iprot):
20718 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
20719 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
20720 
      return
20721 
    iprot.readStructBegin()
20722 
    while True:
20723 
      (fname, ftype, fid) = iprot.readFieldBegin()
20724 
      if ftype == TType.STOP:
20725 
        break
20726 
      if fid == 1:
20727 
        if ftype == TType.I64:
20728 
          self.settlementId = iprot.readI64();
20729 
        else:
20730 
          iprot.skip(ftype)
20731 
      else:
20732 
        iprot.skip(ftype)
20733 
      iprot.readFieldEnd()
20734 
    iprot.readStructEnd()
20735 
 
20736 
  def write(self, oprot):
20737 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
20738 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
20739 
      return
20740 
    oprot.writeStructBegin('markEBSSettlementUploaded_args')
20741 
    if self.settlementId is not None:
20742 
      oprot.writeFieldBegin('settlementId', TType.I64, 1)
20743 
      oprot.writeI64(self.settlementId)
20744 
      oprot.writeFieldEnd()
20745 
    oprot.writeFieldStop()
20746 
    oprot.writeStructEnd()
20747 
 
20748 
  def validate(self):
20749 
    return
20750 
 
20751 
 
20752 
  def __repr__(self):
20753 
    L = ['%s=%r' % (key, value)
20754 
      for key, value in self.__dict__.iteritems()]
20755 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
20756 
 
20757 
  def __eq__(self, other):
20758 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
20759 
 
20760 
  def __ne__(self, other):
20761 
    return not (self == other)
20762 
 
20763 
class markEBSSettlementUploaded_result:
20764 
  """
20765 
  Attributes:
20766 
   - ex
20767 
  """
20768 
 
20769 
  thrift_spec = (
20770 
    None, # 0
20771 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
20772 
  )
20773 
 
20774 
  def __init__(self, ex=None,):
20775 
    self.ex = ex
20776 
 
20777 
  def read(self, iprot):
20778 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
20779 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
20780 
      return
20781 
    iprot.readStructBegin()
20782 
    while True:
20783 
      (fname, ftype, fid) = iprot.readFieldBegin()
20784 
      if ftype == TType.STOP:
20785 
        break
20786 
      if fid == 1:
20787 
        if ftype == TType.STRUCT:
20788 
          self.ex = TransactionServiceException()
20789 
          self.ex.read(iprot)
20790 
        else:
20791 
          iprot.skip(ftype)
20792 
      else:
20793 
        iprot.skip(ftype)
20794 
      iprot.readFieldEnd()
20795 
    iprot.readStructEnd()
20796 
 
20797 
  def write(self, oprot):
20798 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
20799 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
20800 
      return
20801 
    oprot.writeStructBegin('markEBSSettlementUploaded_result')
20802 
    if self.ex is not None:
20803 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
20804 
      self.ex.write(oprot)
20805 
      oprot.writeFieldEnd()
20806 
    oprot.writeFieldStop()
20807 
    oprot.writeStructEnd()
20808 
 
20809 
  def validate(self):
20810 
    return
20811 
 
20812 
 
20813 
  def __repr__(self):
20814 
    L = ['%s=%r' % (key, value)
20815 
      for key, value in self.__dict__.iteritems()]
20816 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
20817 
 
20818 
  def __eq__(self, other):
20819 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
20820 
 
20821 
  def __ne__(self, other):
20822 
    return not (self == other)
20823 
 
20824 
class getEBSSettlementDate_args:
20825 
  """
20826 
  Attributes:
20827 
   - settlementId
20828 
  """
20829 
 
20830 
  thrift_spec = (
20831 
    None, # 0
20832 
    (1, TType.I64, 'settlementId', None, None, ), # 1
20833 
  )
20834 
 
20835 
  def __init__(self, settlementId=None,):
20836 
    self.settlementId = settlementId
20837 
 
20838 
  def read(self, iprot):
20839 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
20840 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
20841 
      return
20842 
    iprot.readStructBegin()
20843 
    while True:
20844 
      (fname, ftype, fid) = iprot.readFieldBegin()
20845 
      if ftype == TType.STOP:
20846 
        break
20847 
      if fid == 1:
20848 
        if ftype == TType.I64:
20849 
          self.settlementId = iprot.readI64();
20850 
        else:
20851 
          iprot.skip(ftype)
20852 
      else:
20853 
        iprot.skip(ftype)
20854 
      iprot.readFieldEnd()
20855 
    iprot.readStructEnd()
20856 
 
20857 
  def write(self, oprot):
20858 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
20859 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
20860 
      return
20861 
    oprot.writeStructBegin('getEBSSettlementDate_args')
20862 
    if self.settlementId is not None:
20863 
      oprot.writeFieldBegin('settlementId', TType.I64, 1)
20864 
      oprot.writeI64(self.settlementId)
20865 
      oprot.writeFieldEnd()
20866 
    oprot.writeFieldStop()
20867 
    oprot.writeStructEnd()
20868 
 
20869 
  def validate(self):
20870 
    return
20871 
 
20872 
 
20873 
  def __repr__(self):
20874 
    L = ['%s=%r' % (key, value)
20875 
      for key, value in self.__dict__.iteritems()]
20876 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
20877 
 
20878 
  def __eq__(self, other):
20879 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
20880 
 
20881 
  def __ne__(self, other):
20882 
    return not (self == other)
20883 
 
20884 
class getEBSSettlementDate_result:
20885 
  """
20886 
  Attributes:
20887 
   - success
20888 
   - ex
20889 
  """
20890 
 
20891 
  thrift_spec = (
20892 
    (0, TType.I64, 'success', None, None, ), # 0
20893 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
20894 
  )
20895 
 
20896 
  def __init__(self, success=None, ex=None,):
20897 
    self.success = success
20898 
    self.ex = ex
20899 
 
20900 
  def read(self, iprot):
20901 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
20902 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
20903 
      return
20904 
    iprot.readStructBegin()
20905 
    while True:
20906 
      (fname, ftype, fid) = iprot.readFieldBegin()
20907 
      if ftype == TType.STOP:
20908 
        break
20909 
      if fid == 0:
20910 
        if ftype == TType.I64:
20911 
          self.success = iprot.readI64();
20912 
        else:
20913 
          iprot.skip(ftype)
20914 
      elif fid == 1:
20915 
        if ftype == TType.STRUCT:
20916 
          self.ex = TransactionServiceException()
20917 
          self.ex.read(iprot)
20918 
        else:
20919 
          iprot.skip(ftype)
20920 
      else:
20921 
        iprot.skip(ftype)
20922 
      iprot.readFieldEnd()
20923 
    iprot.readStructEnd()
20924 
 
20925 
  def write(self, oprot):
20926 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
20927 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
20928 
      return
20929 
    oprot.writeStructBegin('getEBSSettlementDate_result')
20930 
    if self.success is not None:
20931 
      oprot.writeFieldBegin('success', TType.I64, 0)
20932 
      oprot.writeI64(self.success)
20933 
      oprot.writeFieldEnd()
20934 
    if self.ex is not None:
20935 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
20936 
      self.ex.write(oprot)
20937 
      oprot.writeFieldEnd()
20938 
    oprot.writeFieldStop()
20939 
    oprot.writeStructEnd()
20940 
 
20941 
  def validate(self):
20942 
    return
20943 
 
20944 
 
20945 
  def __repr__(self):
20946 
    L = ['%s=%r' % (key, value)
20947 
      for key, value in self.__dict__.iteritems()]
20948 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
20949 
 
20950 
  def __eq__(self, other):
20951 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
20952 
 
20953 
  def __ne__(self, other):
20954 
    return not (self == other)
4715 varun.gupt 20955 
 
20956 
class getSettlementsByDate_args:
20957 
  """
20958 
  Attributes:
20959 
   - settlementDateFrom
20960 
   - settlementDateTo
20961 
   - isRefund
20962 
  """
20963 
 
20964 
  thrift_spec = (
20965 
    None, # 0
20966 
    (1, TType.I64, 'settlementDateFrom', None, None, ), # 1
20967 
    (2, TType.I64, 'settlementDateTo', None, None, ), # 2
20968 
    (3, TType.BOOL, 'isRefund', None, None, ), # 3
20969 
  )
20970 
 
20971 
  def __init__(self, settlementDateFrom=None, settlementDateTo=None, isRefund=None,):
20972 
    self.settlementDateFrom = settlementDateFrom
20973 
    self.settlementDateTo = settlementDateTo
20974 
    self.isRefund = isRefund
20975 
 
20976 
  def read(self, iprot):
20977 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
20978 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
20979 
      return
20980 
    iprot.readStructBegin()
20981 
    while True:
20982 
      (fname, ftype, fid) = iprot.readFieldBegin()
20983 
      if ftype == TType.STOP:
20984 
        break
20985 
      if fid == 1:
20986 
        if ftype == TType.I64:
20987 
          self.settlementDateFrom = iprot.readI64();
20988 
        else:
20989 
          iprot.skip(ftype)
20990 
      elif fid == 2:
20991 
        if ftype == TType.I64:
20992 
          self.settlementDateTo = iprot.readI64();
20993 
        else:
20994 
          iprot.skip(ftype)
20995 
      elif fid == 3:
20996 
        if ftype == TType.BOOL:
20997 
          self.isRefund = iprot.readBool();
20998 
        else:
20999 
          iprot.skip(ftype)
21000 
      else:
21001 
        iprot.skip(ftype)
21002 
      iprot.readFieldEnd()
21003 
    iprot.readStructEnd()
21004 
 
21005 
  def write(self, oprot):
21006 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
21007 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
21008 
      return
21009 
    oprot.writeStructBegin('getSettlementsByDate_args')
21010 
    if self.settlementDateFrom is not None:
21011 
      oprot.writeFieldBegin('settlementDateFrom', TType.I64, 1)
21012 
      oprot.writeI64(self.settlementDateFrom)
21013 
      oprot.writeFieldEnd()
21014 
    if self.settlementDateTo is not None:
21015 
      oprot.writeFieldBegin('settlementDateTo', TType.I64, 2)
21016 
      oprot.writeI64(self.settlementDateTo)
21017 
      oprot.writeFieldEnd()
21018 
    if self.isRefund is not None:
21019 
      oprot.writeFieldBegin('isRefund', TType.BOOL, 3)
21020 
      oprot.writeBool(self.isRefund)
21021 
      oprot.writeFieldEnd()
21022 
    oprot.writeFieldStop()
21023 
    oprot.writeStructEnd()
21024 
 
21025 
  def validate(self):
21026 
    return
21027 
 
21028 
 
21029 
  def __repr__(self):
21030 
    L = ['%s=%r' % (key, value)
21031 
      for key, value in self.__dict__.iteritems()]
21032 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
21033 
 
21034 
  def __eq__(self, other):
21035 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
21036 
 
21037 
  def __ne__(self, other):
21038 
    return not (self == other)
21039 
 
21040 
class getSettlementsByDate_result:
21041 
  """
21042 
  Attributes:
21043 
   - success
21044 
   - ex
21045 
  """
21046 
 
21047 
  thrift_spec = (
21048 
    (0, TType.LIST, 'success', (TType.STRUCT,(PaymentSettlement, PaymentSettlement.thrift_spec)), None, ), # 0
21049 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
21050 
  )
21051 
 
21052 
  def __init__(self, success=None, ex=None,):
21053 
    self.success = success
21054 
    self.ex = ex
21055 
 
21056 
  def read(self, iprot):
21057 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
21058 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
21059 
      return
21060 
    iprot.readStructBegin()
21061 
    while True:
21062 
      (fname, ftype, fid) = iprot.readFieldBegin()
21063 
      if ftype == TType.STOP:
21064 
        break
21065 
      if fid == 0:
21066 
        if ftype == TType.LIST:
21067 
          self.success = []
5031 varun.gupt 21068 
          (_etype474, _size471) = iprot.readListBegin()
21069 
          for _i475 in xrange(_size471):
21070 
            _elem476 = PaymentSettlement()
21071 
            _elem476.read(iprot)
21072 
            self.success.append(_elem476)
4715 varun.gupt 21073 
          iprot.readListEnd()
21074 
        else:
21075 
          iprot.skip(ftype)
21076 
      elif fid == 1:
21077 
        if ftype == TType.STRUCT:
21078 
          self.ex = TransactionServiceException()
21079 
          self.ex.read(iprot)
21080 
        else:
21081 
          iprot.skip(ftype)
21082 
      else:
21083 
        iprot.skip(ftype)
21084 
      iprot.readFieldEnd()
21085 
    iprot.readStructEnd()
21086 
 
21087 
  def write(self, oprot):
21088 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
21089 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
21090 
      return
21091 
    oprot.writeStructBegin('getSettlementsByDate_result')
21092 
    if self.success is not None:
21093 
      oprot.writeFieldBegin('success', TType.LIST, 0)
21094 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
5031 varun.gupt 21095 
      for iter477 in self.success:
21096 
        iter477.write(oprot)
4715 varun.gupt 21097 
      oprot.writeListEnd()
21098 
      oprot.writeFieldEnd()
21099 
    if self.ex is not None:
21100 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
21101 
      self.ex.write(oprot)
21102 
      oprot.writeFieldEnd()
21103 
    oprot.writeFieldStop()
21104 
    oprot.writeStructEnd()
21105 
 
21106 
  def validate(self):
21107 
    return
21108 
 
21109 
 
21110 
  def __repr__(self):
21111 
    L = ['%s=%r' % (key, value)
21112 
      for key, value in self.__dict__.iteritems()]
21113 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
21114 
 
21115 
  def __eq__(self, other):
21116 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
21117 
 
21118 
  def __ne__(self, other):
21119 
    return not (self == other)
21120 
 
21121 
class getReshippedOrderIds_args:
21122 
  """
21123 
  Attributes:
21124 
   - orderIds
21125 
  """
21126 
 
21127 
  thrift_spec = (
21128 
    None, # 0
21129 
    (1, TType.LIST, 'orderIds', (TType.I64,None), None, ), # 1
21130 
  )
21131 
 
21132 
  def __init__(self, orderIds=None,):
21133 
    self.orderIds = orderIds
21134 
 
21135 
  def read(self, iprot):
21136 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
21137 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
21138 
      return
21139 
    iprot.readStructBegin()
21140 
    while True:
21141 
      (fname, ftype, fid) = iprot.readFieldBegin()
21142 
      if ftype == TType.STOP:
21143 
        break
21144 
      if fid == 1:
21145 
        if ftype == TType.LIST:
21146 
          self.orderIds = []
5031 varun.gupt 21147 
          (_etype481, _size478) = iprot.readListBegin()
21148 
          for _i482 in xrange(_size478):
21149 
            _elem483 = iprot.readI64();
21150 
            self.orderIds.append(_elem483)
4715 varun.gupt 21151 
          iprot.readListEnd()
21152 
        else:
21153 
          iprot.skip(ftype)
21154 
      else:
21155 
        iprot.skip(ftype)
21156 
      iprot.readFieldEnd()
21157 
    iprot.readStructEnd()
21158 
 
21159 
  def write(self, oprot):
21160 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
21161 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
21162 
      return
21163 
    oprot.writeStructBegin('getReshippedOrderIds_args')
21164 
    if self.orderIds is not None:
21165 
      oprot.writeFieldBegin('orderIds', TType.LIST, 1)
21166 
      oprot.writeListBegin(TType.I64, len(self.orderIds))
5031 varun.gupt 21167 
      for iter484 in self.orderIds:
21168 
        oprot.writeI64(iter484)
4715 varun.gupt 21169 
      oprot.writeListEnd()
21170 
      oprot.writeFieldEnd()
21171 
    oprot.writeFieldStop()
21172 
    oprot.writeStructEnd()
21173 
 
21174 
  def validate(self):
21175 
    return
21176 
 
21177 
 
21178 
  def __repr__(self):
21179 
    L = ['%s=%r' % (key, value)
21180 
      for key, value in self.__dict__.iteritems()]
21181 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
21182 
 
21183 
  def __eq__(self, other):
21184 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
21185 
 
21186 
  def __ne__(self, other):
21187 
    return not (self == other)
21188 
 
21189 
class getReshippedOrderIds_result:
21190 
  """
21191 
  Attributes:
21192 
   - success
21193 
   - ex
21194 
  """
21195 
 
21196 
  thrift_spec = (
21197 
    (0, TType.LIST, 'success', (TType.I64,None), None, ), # 0
21198 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
21199 
  )
21200 
 
21201 
  def __init__(self, success=None, ex=None,):
21202 
    self.success = success
21203 
    self.ex = ex
21204 
 
21205 
  def read(self, iprot):
21206 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
21207 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
21208 
      return
21209 
    iprot.readStructBegin()
21210 
    while True:
21211 
      (fname, ftype, fid) = iprot.readFieldBegin()
21212 
      if ftype == TType.STOP:
21213 
        break
21214 
      if fid == 0:
21215 
        if ftype == TType.LIST:
21216 
          self.success = []
5031 varun.gupt 21217 
          (_etype488, _size485) = iprot.readListBegin()
21218 
          for _i489 in xrange(_size485):
21219 
            _elem490 = iprot.readI64();
21220 
            self.success.append(_elem490)
4715 varun.gupt 21221 
          iprot.readListEnd()
21222 
        else:
21223 
          iprot.skip(ftype)
21224 
      elif fid == 1:
21225 
        if ftype == TType.STRUCT:
21226 
          self.ex = TransactionServiceException()
21227 
          self.ex.read(iprot)
21228 
        else:
21229 
          iprot.skip(ftype)
21230 
      else:
21231 
        iprot.skip(ftype)
21232 
      iprot.readFieldEnd()
21233 
    iprot.readStructEnd()
21234 
 
21235 
  def write(self, oprot):
21236 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
21237 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
21238 
      return
21239 
    oprot.writeStructBegin('getReshippedOrderIds_result')
21240 
    if self.success is not None:
21241 
      oprot.writeFieldBegin('success', TType.LIST, 0)
21242 
      oprot.writeListBegin(TType.I64, len(self.success))
5031 varun.gupt 21243 
      for iter491 in self.success:
21244 
        oprot.writeI64(iter491)
4715 varun.gupt 21245 
      oprot.writeListEnd()
21246 
      oprot.writeFieldEnd()
21247 
    if self.ex is not None:
21248 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
21249 
      self.ex.write(oprot)
21250 
      oprot.writeFieldEnd()
21251 
    oprot.writeFieldStop()
21252 
    oprot.writeStructEnd()
21253 
 
21254 
  def validate(self):
21255 
    return
21256 
 
21257 
 
21258 
  def __repr__(self):
21259 
    L = ['%s=%r' % (key, value)
21260 
      for key, value in self.__dict__.iteritems()]
21261 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
21262 
 
21263 
  def __eq__(self, other):
21264 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
21265 
 
21266 
  def __ne__(self, other):
21267 
    return not (self == other)
4757 mandeep.dh 21268 
 
21269 
class updateOrdersAsPORaised_args:
21270 
  """
21271 
  Attributes:
21272 
   - itemIdQuantityMap
21273 
   - purchaseOrderId
21274 
   - warehouseId
21275 
  """
21276 
 
21277 
  thrift_spec = (
21278 
    None, # 0
21279 
    (1, TType.MAP, 'itemIdQuantityMap', (TType.I64,None,TType.I64,None), None, ), # 1
21280 
    (2, TType.I64, 'purchaseOrderId', None, None, ), # 2
21281 
    (3, TType.I64, 'warehouseId', None, None, ), # 3
21282 
  )
21283 
 
21284 
  def __init__(self, itemIdQuantityMap=None, purchaseOrderId=None, warehouseId=None,):
21285 
    self.itemIdQuantityMap = itemIdQuantityMap
21286 
    self.purchaseOrderId = purchaseOrderId
21287 
    self.warehouseId = warehouseId
21288 
 
21289 
  def read(self, iprot):
21290 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
21291 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
21292 
      return
21293 
    iprot.readStructBegin()
21294 
    while True:
21295 
      (fname, ftype, fid) = iprot.readFieldBegin()
21296 
      if ftype == TType.STOP:
21297 
        break
21298 
      if fid == 1:
21299 
        if ftype == TType.MAP:
21300 
          self.itemIdQuantityMap = {}
5031 varun.gupt 21301 
          (_ktype493, _vtype494, _size492 ) = iprot.readMapBegin()
21302 
          for _i496 in xrange(_size492):
21303 
            _key497 = iprot.readI64();
21304 
            _val498 = iprot.readI64();
21305 
            self.itemIdQuantityMap[_key497] = _val498
4757 mandeep.dh 21306 
          iprot.readMapEnd()
21307 
        else:
21308 
          iprot.skip(ftype)
21309 
      elif fid == 2:
21310 
        if ftype == TType.I64:
21311 
          self.purchaseOrderId = iprot.readI64();
21312 
        else:
21313 
          iprot.skip(ftype)
21314 
      elif fid == 3:
21315 
        if ftype == TType.I64:
21316 
          self.warehouseId = iprot.readI64();
21317 
        else:
21318 
          iprot.skip(ftype)
21319 
      else:
21320 
        iprot.skip(ftype)
21321 
      iprot.readFieldEnd()
21322 
    iprot.readStructEnd()
21323 
 
21324 
  def write(self, oprot):
21325 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
21326 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
21327 
      return
21328 
    oprot.writeStructBegin('updateOrdersAsPORaised_args')
21329 
    if self.itemIdQuantityMap is not None:
21330 
      oprot.writeFieldBegin('itemIdQuantityMap', TType.MAP, 1)
21331 
      oprot.writeMapBegin(TType.I64, TType.I64, len(self.itemIdQuantityMap))
5031 varun.gupt 21332 
      for kiter499,viter500 in self.itemIdQuantityMap.items():
21333 
        oprot.writeI64(kiter499)
21334 
        oprot.writeI64(viter500)
4757 mandeep.dh 21335 
      oprot.writeMapEnd()
21336 
      oprot.writeFieldEnd()
21337 
    if self.purchaseOrderId is not None:
21338 
      oprot.writeFieldBegin('purchaseOrderId', TType.I64, 2)
21339 
      oprot.writeI64(self.purchaseOrderId)
21340 
      oprot.writeFieldEnd()
21341 
    if self.warehouseId is not None:
21342 
      oprot.writeFieldBegin('warehouseId', TType.I64, 3)
21343 
      oprot.writeI64(self.warehouseId)
21344 
      oprot.writeFieldEnd()
21345 
    oprot.writeFieldStop()
21346 
    oprot.writeStructEnd()
21347 
 
21348 
  def validate(self):
21349 
    return
21350 
 
21351 
 
21352 
  def __repr__(self):
21353 
    L = ['%s=%r' % (key, value)
21354 
      for key, value in self.__dict__.iteritems()]
21355 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
21356 
 
21357 
  def __eq__(self, other):
21358 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
21359 
 
21360 
  def __ne__(self, other):
21361 
    return not (self == other)
21362 
 
21363 
class updateOrdersAsPORaised_result:
21364 
  """
21365 
  Attributes:
21366 
   - ex
21367 
  """
21368 
 
21369 
  thrift_spec = (
21370 
    None, # 0
21371 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
21372 
  )
21373 
 
21374 
  def __init__(self, ex=None,):
21375 
    self.ex = ex
21376 
 
21377 
  def read(self, iprot):
21378 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
21379 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
21380 
      return
21381 
    iprot.readStructBegin()
21382 
    while True:
21383 
      (fname, ftype, fid) = iprot.readFieldBegin()
21384 
      if ftype == TType.STOP:
21385 
        break
21386 
      if fid == 1:
21387 
        if ftype == TType.STRUCT:
21388 
          self.ex = TransactionServiceException()
21389 
          self.ex.read(iprot)
21390 
        else:
21391 
          iprot.skip(ftype)
21392 
      else:
21393 
        iprot.skip(ftype)
21394 
      iprot.readFieldEnd()
21395 
    iprot.readStructEnd()
21396 
 
21397 
  def write(self, oprot):
21398 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
21399 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
21400 
      return
21401 
    oprot.writeStructBegin('updateOrdersAsPORaised_result')
21402 
    if self.ex is not None:
21403 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
21404 
      self.ex.write(oprot)
21405 
      oprot.writeFieldEnd()
21406 
    oprot.writeFieldStop()
21407 
    oprot.writeStructEnd()
21408 
 
21409 
  def validate(self):
21410 
    return
21411 
 
21412 
 
21413 
  def __repr__(self):
21414 
    L = ['%s=%r' % (key, value)
21415 
      for key, value in self.__dict__.iteritems()]
21416 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
21417 
 
21418 
  def __eq__(self, other):
21419 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
21420 
 
21421 
  def __ne__(self, other):
21422 
    return not (self == other)
4875 varun.gupt 21423 
 
21424 
class getOrdersWhereVendorNotPaid_args:
21425 
  """
21426 
  Attributes:
21427 
   - vendorId
21428 
  """
21429 
 
21430 
  thrift_spec = (
21431 
    None, # 0
21432 
    (1, TType.I64, 'vendorId', None, None, ), # 1
21433 
  )
21434 
 
21435 
  def __init__(self, vendorId=None,):
21436 
    self.vendorId = vendorId
21437 
 
21438 
  def read(self, iprot):
21439 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
21440 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
21441 
      return
21442 
    iprot.readStructBegin()
21443 
    while True:
21444 
      (fname, ftype, fid) = iprot.readFieldBegin()
21445 
      if ftype == TType.STOP:
21446 
        break
21447 
      if fid == 1:
21448 
        if ftype == TType.I64:
21449 
          self.vendorId = iprot.readI64();
21450 
        else:
21451 
          iprot.skip(ftype)
21452 
      else:
21453 
        iprot.skip(ftype)
21454 
      iprot.readFieldEnd()
21455 
    iprot.readStructEnd()
21456 
 
21457 
  def write(self, oprot):
21458 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
21459 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
21460 
      return
21461 
    oprot.writeStructBegin('getOrdersWhereVendorNotPaid_args')
21462 
    if self.vendorId is not None:
21463 
      oprot.writeFieldBegin('vendorId', TType.I64, 1)
21464 
      oprot.writeI64(self.vendorId)
21465 
      oprot.writeFieldEnd()
21466 
    oprot.writeFieldStop()
21467 
    oprot.writeStructEnd()
21468 
 
21469 
  def validate(self):
21470 
    return
21471 
 
21472 
 
21473 
  def __repr__(self):
21474 
    L = ['%s=%r' % (key, value)
21475 
      for key, value in self.__dict__.iteritems()]
21476 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
21477 
 
21478 
  def __eq__(self, other):
21479 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
21480 
 
21481 
  def __ne__(self, other):
21482 
    return not (self == other)
21483 
 
21484 
class getOrdersWhereVendorNotPaid_result:
21485 
  """
21486 
  Attributes:
21487 
   - success
21488 
   - ex
21489 
  """
21490 
 
21491 
  thrift_spec = (
21492 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
21493 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
21494 
  )
21495 
 
21496 
  def __init__(self, success=None, ex=None,):
21497 
    self.success = success
21498 
    self.ex = ex
21499 
 
21500 
  def read(self, iprot):
21501 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
21502 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
21503 
      return
21504 
    iprot.readStructBegin()
21505 
    while True:
21506 
      (fname, ftype, fid) = iprot.readFieldBegin()
21507 
      if ftype == TType.STOP:
21508 
        break
21509 
      if fid == 0:
21510 
        if ftype == TType.LIST:
21511 
          self.success = []
5031 varun.gupt 21512 
          (_etype504, _size501) = iprot.readListBegin()
21513 
          for _i505 in xrange(_size501):
21514 
            _elem506 = Order()
21515 
            _elem506.read(iprot)
21516 
            self.success.append(_elem506)
4875 varun.gupt 21517 
          iprot.readListEnd()
21518 
        else:
21519 
          iprot.skip(ftype)
21520 
      elif fid == 1:
21521 
        if ftype == TType.STRUCT:
21522 
          self.ex = TransactionServiceException()
21523 
          self.ex.read(iprot)
21524 
        else:
21525 
          iprot.skip(ftype)
21526 
      else:
21527 
        iprot.skip(ftype)
21528 
      iprot.readFieldEnd()
21529 
    iprot.readStructEnd()
21530 
 
21531 
  def write(self, oprot):
21532 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
21533 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
21534 
      return
21535 
    oprot.writeStructBegin('getOrdersWhereVendorNotPaid_result')
21536 
    if self.success is not None:
21537 
      oprot.writeFieldBegin('success', TType.LIST, 0)
21538 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
5031 varun.gupt 21539 
      for iter507 in self.success:
21540 
        iter507.write(oprot)
4875 varun.gupt 21541 
      oprot.writeListEnd()
21542 
      oprot.writeFieldEnd()
21543 
    if self.ex is not None:
21544 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
21545 
      self.ex.write(oprot)
21546 
      oprot.writeFieldEnd()
21547 
    oprot.writeFieldStop()
21548 
    oprot.writeStructEnd()
21549 
 
21550 
  def validate(self):
21551 
    return
21552 
 
21553 
 
21554 
  def __repr__(self):
21555 
    L = ['%s=%r' % (key, value)
21556 
      for key, value in self.__dict__.iteritems()]
21557 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
21558 
 
21559 
  def __eq__(self, other):
21560 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
21561 
 
21562 
  def __ne__(self, other):
21563 
    return not (self == other)
5031 varun.gupt 21564 
 
21565 
class getStatusDistributionOfOrders_args:
21566 
  """
21567 
  Attributes:
21568 
   - startDate
21569 
   - endDate
21570 
  """
21571 
 
21572 
  thrift_spec = (
21573 
    None, # 0
21574 
    (1, TType.I64, 'startDate', None, None, ), # 1
21575 
    (2, TType.I64, 'endDate', None, None, ), # 2
21576 
  )
21577 
 
21578 
  def __init__(self, startDate=None, endDate=None,):
21579 
    self.startDate = startDate
21580 
    self.endDate = endDate
21581 
 
21582 
  def read(self, iprot):
21583 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
21584 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
21585 
      return
21586 
    iprot.readStructBegin()
21587 
    while True:
21588 
      (fname, ftype, fid) = iprot.readFieldBegin()
21589 
      if ftype == TType.STOP:
21590 
        break
21591 
      if fid == 1:
21592 
        if ftype == TType.I64:
21593 
          self.startDate = iprot.readI64();
21594 
        else:
21595 
          iprot.skip(ftype)
21596 
      elif fid == 2:
21597 
        if ftype == TType.I64:
21598 
          self.endDate = iprot.readI64();
21599 
        else:
21600 
          iprot.skip(ftype)
21601 
      else:
21602 
        iprot.skip(ftype)
21603 
      iprot.readFieldEnd()
21604 
    iprot.readStructEnd()
21605 
 
21606 
  def write(self, oprot):
21607 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
21608 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
21609 
      return
21610 
    oprot.writeStructBegin('getStatusDistributionOfOrders_args')
21611 
    if self.startDate is not None:
21612 
      oprot.writeFieldBegin('startDate', TType.I64, 1)
21613 
      oprot.writeI64(self.startDate)
21614 
      oprot.writeFieldEnd()
21615 
    if self.endDate is not None:
21616 
      oprot.writeFieldBegin('endDate', TType.I64, 2)
21617 
      oprot.writeI64(self.endDate)
21618 
      oprot.writeFieldEnd()
21619 
    oprot.writeFieldStop()
21620 
    oprot.writeStructEnd()
21621 
 
21622 
  def validate(self):
21623 
    return
21624 
 
21625 
 
21626 
  def __repr__(self):
21627 
    L = ['%s=%r' % (key, value)
21628 
      for key, value in self.__dict__.iteritems()]
21629 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
21630 
 
21631 
  def __eq__(self, other):
21632 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
21633 
 
21634 
  def __ne__(self, other):
21635 
    return not (self == other)
21636 
 
21637 
class getStatusDistributionOfOrders_result:
21638 
  """
21639 
  Attributes:
21640 
   - success
21641 
   - ex
21642 
  """
21643 
 
21644 
  thrift_spec = (
21645 
    (0, TType.MAP, 'success', (TType.I64,None,TType.I64,None), None, ), # 0
21646 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
21647 
  )
21648 
 
21649 
  def __init__(self, success=None, ex=None,):
21650 
    self.success = success
21651 
    self.ex = ex
21652 
 
21653 
  def read(self, iprot):
21654 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
21655 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
21656 
      return
21657 
    iprot.readStructBegin()
21658 
    while True:
21659 
      (fname, ftype, fid) = iprot.readFieldBegin()
21660 
      if ftype == TType.STOP:
21661 
        break
21662 
      if fid == 0:
21663 
        if ftype == TType.MAP:
21664 
          self.success = {}
21665 
          (_ktype509, _vtype510, _size508 ) = iprot.readMapBegin()
21666 
          for _i512 in xrange(_size508):
21667 
            _key513 = iprot.readI64();
21668 
            _val514 = iprot.readI64();
21669 
            self.success[_key513] = _val514
21670 
          iprot.readMapEnd()
21671 
        else:
21672 
          iprot.skip(ftype)
21673 
      elif fid == 1:
21674 
        if ftype == TType.STRUCT:
21675 
          self.ex = TransactionServiceException()
21676 
          self.ex.read(iprot)
21677 
        else:
21678 
          iprot.skip(ftype)
21679 
      else:
21680 
        iprot.skip(ftype)
21681 
      iprot.readFieldEnd()
21682 
    iprot.readStructEnd()
21683 
 
21684 
  def write(self, oprot):
21685 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
21686 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
21687 
      return
21688 
    oprot.writeStructBegin('getStatusDistributionOfOrders_result')
21689 
    if self.success is not None:
21690 
      oprot.writeFieldBegin('success', TType.MAP, 0)
21691 
      oprot.writeMapBegin(TType.I64, TType.I64, len(self.success))
21692 
      for kiter515,viter516 in self.success.items():
21693 
        oprot.writeI64(kiter515)
21694 
        oprot.writeI64(viter516)
21695 
      oprot.writeMapEnd()
21696 
      oprot.writeFieldEnd()
21697 
    if self.ex is not None:
21698 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
21699 
      self.ex.write(oprot)
21700 
      oprot.writeFieldEnd()
21701 
    oprot.writeFieldStop()
21702 
    oprot.writeStructEnd()
21703 
 
21704 
  def validate(self):
21705 
    return
21706 
 
21707 
 
21708 
  def __repr__(self):
21709 
    L = ['%s=%r' % (key, value)
21710 
      for key, value in self.__dict__.iteritems()]
21711 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
21712 
 
21713 
  def __eq__(self, other):
21714 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
21715 
 
21716 
  def __ne__(self, other):
21717 
    return not (self == other)