Subversion Repositories SmartDukaan

Rev

Rev 5833 | Rev 6000 | 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 
 
5527 anupam.sin 58 
  def changeTransactionStatus(self, transactionId, status, description, pickUp, orderType):
94 ashish 59 
    """
60 
    Parameters:
61 
     - transactionId
62 
     - status
63 
     - description
5527 anupam.sin 64 
     - pickUp
65 
     - orderType
94 ashish 66 
    """
67 
    pass
68 
 
1398 varun.gupt 69 
  def enqueueTransactionInfoEmail(self, transactionId):
1382 varun.gupt 70 
    """
71 
    Parameters:
72 
     - transactionId
73 
    """
74 
    pass
75 
 
4801 anupam.sin 76 
  def getAllOrders(self, statuses, from_date, to_date, warehouse_id):
94 ashish 77 
    """
78 
    Parameters:
4801 anupam.sin 79 
     - statuses
483 rajveer 80 
     - from_date
81 
     - to_date
82 
     - warehouse_id
94 ashish 83 
    """
84 
    pass
85 
 
4133 chandransh 86 
  def getOrdersInBatch(self, statuses, offset, limit, warehouse_id):
87 
    """
88 
    Returns at most 'limit' orders with the given statuses for the given warehouse starting from the given offset.
89 
    Pass the status as null and the limit as 0 to ignore them.
90 
 
91 
    Parameters:
92 
     - statuses
93 
     - offset
94 
     - limit
95 
     - warehouse_id
96 
    """
97 
    pass
98 
 
99 
  def getOrderCount(self, statuses, warehouseId):
100 
    """
101 
    Returns the count of orders with the given statuses assigned to the given warehouse.
102 
 
103 
    Parameters:
104 
     - statuses
105 
     - warehouseId
106 
    """
107 
    pass
108 
 
999 varun.gupt 109 
  def getOrdersByBillingDate(self, status, start_billing_date, end_billing_date, warehouse_id):
110 
    """
1132 chandransh 111 
    Returns orders within a range of their billing dates
3431 rajveer 112 
 
999 varun.gupt 113 
    Parameters:
114 
     - status
115 
     - start_billing_date
116 
     - end_billing_date
117 
     - warehouse_id
118 
    """
119 
    pass
120 
 
3451 chandransh 121 
  def getOrdersByShippingDate(self, fromShippingDate, toShippingDate, providerId, warehouseId, cod):
3427 chandransh 122 
    """
123 
    Returns orders for a particular provider and warehouse which were shipped between the given dates.
3451 chandransh 124 
    Returned orders comprise of COD orders if cod parameter is true. It comprises of prepaid orders otherwise.
125 
    Pass providerId and warehouseId as -1 to ignore both these parameters.
3431 rajveer 126 
 
3427 chandransh 127 
    Parameters:
128 
     - fromShippingDate
129 
     - toShippingDate
130 
     - providerId
131 
     - warehouseId
3451 chandransh 132 
     - cod
3427 chandransh 133 
    """
134 
    pass
135 
 
1382 varun.gupt 136 
  def getReturnableOrdersForCustomer(self, customer_id, limit):
137 
    """
138 
    Returns order ids for orders which can be returned
3431 rajveer 139 
 
1382 varun.gupt 140 
    Parameters:
141 
     - customer_id
142 
     - limit
143 
    """
144 
    pass
145 
 
146 
  def getCancellableOrdersForCustomer(self, customer_id, limit):
147 
    """
148 
    Returns order ids for orders which can be cancelled
3431 rajveer 149 
 
1382 varun.gupt 150 
    Parameters:
151 
     - customer_id
152 
     - limit
153 
    """
154 
    pass
155 
 
483 rajveer 156 
  def changeOrderStatus(self, orderId, status, description):
94 ashish 157 
    """
158 
    Parameters:
483 rajveer 159 
     - orderId
160 
     - status
161 
     - description
94 ashish 162 
    """
163 
    pass
164 
 
1528 ankur.sing 165 
  def getOrdersForTransaction(self, transactionId, customerId):
94 ashish 166 
    """
1528 ankur.sing 167 
    Returns list of orders for given transaction Id. Also filters based on customer Id so that
168 
    only user who owns the transaction can view its order details.
3431 rajveer 169 
 
94 ashish 170 
    Parameters:
171 
     - transactionId
1528 ankur.sing 172 
     - customerId
94 ashish 173 
    """
174 
    pass
175 
 
3014 chandransh 176 
  def getOrdersForCustomer(self, customerId, from_date, to_date, statuses):
94 ashish 177 
    """
3014 chandransh 178 
    Returns list of orders for the given customer created between the given dates and having the given statuses.
179 
    Pass and empty list to ignore filtering on statuses.
3431 rajveer 180 
 
94 ashish 181 
    Parameters:
483 rajveer 182 
     - customerId
183 
     - from_date
184 
     - to_date
3014 chandransh 185 
     - statuses
94 ashish 186 
    """
187 
    pass
188 
 
483 rajveer 189 
  def createOrder(self, order):
94 ashish 190 
    """
191 
    Parameters:
483 rajveer 192 
     - order
94 ashish 193 
    """
194 
    pass
195 
 
483 rajveer 196 
  def getOrder(self, id):
94 ashish 197 
    """
198 
    Parameters:
483 rajveer 199 
     - id
94 ashish 200 
    """
201 
    pass
202 
 
483 rajveer 203 
  def getLineItemsForOrder(self, orderId):
94 ashish 204 
    """
205 
    Parameters:
483 rajveer 206 
     - orderId
94 ashish 207 
    """
208 
    pass
209 
 
4999 phani.kuma 210 
  def getOrderList(self, order_ids):
211 
    """
212 
    Parameters:
213 
     - order_ids
214 
    """
215 
    pass
216 
 
5386 phani.kuma 217 
  def getOrderListForVendor(self, order_ids, vendorId):
218 
    """
219 
    Parameters:
220 
     - order_ids
221 
     - vendorId
222 
    """
223 
    pass
224 
 
1528 ankur.sing 225 
  def getOrderForCustomer(self, orderId, customerId):
226 
    """
227 
    Returns an order for the order Id. Also checks if the order belongs to the customer whose Id is passed.
228 
    Throws exception if either order Id is invalid or order does not below to the customer whose Id is passed.
3431 rajveer 229 
 
1528 ankur.sing 230 
    Parameters:
231 
     - orderId
232 
     - customerId
233 
    """
234 
    pass
235 
 
4444 rajveer 236 
  def getAlerts(self, type, warehouseId, status, timestamp):
3064 chandransh 237 
    """
238 
    Parameters:
4394 rajveer 239 
     - type
4444 rajveer 240 
     - warehouseId
4394 rajveer 241 
     - status
242 
     - timestamp
3064 chandransh 243 
    """
244 
    pass
245 
 
4444 rajveer 246 
  def addAlert(self, type, warehouseId, description):
3064 chandransh 247 
    """
248 
    Parameters:
249 
     - type
4444 rajveer 250 
     - warehouseId
4394 rajveer 251 
     - description
3064 chandransh 252 
    """
253 
    pass
254 
 
4444 rajveer 255 
  def markAlertsAsSeen(self, warehouseId):
256 
    """
257 
    Parameters:
258 
     - warehouseId
259 
    """
260 
    pass
261 
 
3064 chandransh 262 
  def getValidOrderCount(self, ):
263 
    """
264 
    Return the number of valid orders. (OrderStatus >= OrderStatus.SUBMITTED_FOR_PROCESSING)
265 
    """
266 
    pass
267 
 
268 
  def getNoOfCustomersWithSuccessfulTransaction(self, ):
269 
    """
270 
    Returns the number of distinct customers who have done successful transactions
271 
    """
272 
    pass
273 
 
274 
  def getValidOrdersAmountRange(self, ):
275 
    """
276 
    Returns the minimum and maximum amounts of a valid order. (OrderStatus >= OrderStatus.SUBMITTED_FOR_PROCESSING)
277 
    List contains two values, first minimum amount and second maximum amount.
278 
    """
279 
    pass
280 
 
5874 rajveer 281 
  def getValidOrders(self, limit, onlyStore):
3064 chandransh 282 
    """
283 
    Returns list of Orders in descending order by Order creation date. List is restricted to limit Orders.
284 
    If limit is passed as 0, then all valid Orders are returned.
3431 rajveer 285 
 
3064 chandransh 286 
    Parameters:
287 
     - limit
5874 rajveer 288 
     - onlyStore
3064 chandransh 289 
    """
290 
    pass
291 
 
1220 chandransh 292 
  def batchOrders(self, warehouseId):
293 
    """
294 
    Create a batch of all the pending orders for the given warehouse.
295 
    The returned list is orderd by created_timestamp.
296 
    If there are no pending orders, an empty list is returned.
3431 rajveer 297 
 
1220 chandransh 298 
    Parameters:
299 
     - warehouseId
300 
    """
301 
    pass
302 
 
1208 chandransh 303 
  def markOrderAsOutOfStock(self, orderId):
304 
    """
305 
    Mark the given order as out of stock. Throws an exception if the order with the given Id couldn't be found.
3431 rajveer 306 
 
1208 chandransh 307 
    Parameters:
308 
     - orderId
309 
    """
310 
    pass
311 
 
3064 chandransh 312 
  def verifyOrder(self, orderId):
759 chandransh 313 
    """
3064 chandransh 314 
    Marks the given order as SUBMITTED_FOR_PROCESSING and updates the verified
315 
    timestamp. It is intended to be used for COD orders but can be harmlessly
316 
    used for all other orders as well.
317 
    Throws an exception if no such order exists.
3431 rajveer 318 
 
759 chandransh 319 
    Parameters:
3064 chandransh 320 
     - orderId
321 
    """
322 
    pass
323 
 
324 
  def acceptOrder(self, orderId):
325 
    """
326 
    Marks the given order as ACCEPTED and updates the accepted timestamp. If the
327 
    given order is not a COD order, it also captures the payment if the same has
328 
    not been captured.
329 
    Throws an exception if no such order exists.
3431 rajveer 330 
 
3064 chandransh 331 
    Parameters:
332 
     - orderId
333 
    """
334 
    pass
335 
 
5110 mandeep.dh 336 
  def addBillingDetails(self, orderId, invoice_number, serialNumber, itemNumber, billed_by, jacketNumber, billingType, fulfilmentWarehouseId, authorize):
3064 chandransh 337 
    """
338 
    Add billing details such as the bill number and the biller to the Order.
4658 mandeep.dh 339 
    Adds jacket number, item number and Serial no. to the order. Doesn't update
3064 chandransh 340 
    the IMEI no. if a -1 is supplied.
341 
    Also, it generates an invoice number for the order, marks the order as
342 
    BILLED and sets the billing timestamp.
343 
    Returns false if it doesn't find the order with the given ID.
3431 rajveer 344 
 
3064 chandransh 345 
    Parameters:
346 
     - orderId
4283 anupam.sin 347 
     - invoice_number
4658 mandeep.dh 348 
     - serialNumber
3064 chandransh 349 
     - itemNumber
4283 anupam.sin 350 
     - billed_by
351 
     - jacketNumber
3064 chandransh 352 
     - billingType
5110 mandeep.dh 353 
     - fulfilmentWarehouseId
4763 rajveer 354 
     - authorize
3064 chandransh 355 
    """
356 
    pass
357 
 
4763 rajveer 358 
  def addInvoiceNumber(self, orderId, invoiceNumber, color):
4579 rajveer 359 
    """
360 
    Add the invoice number to the order.
361 
 
362 
    Parameters:
363 
     - orderId
364 
     - invoiceNumber
4763 rajveer 365 
     - color
4579 rajveer 366 
    """
367 
    pass
368 
 
4910 phani.kuma 369 
  def markOrdersAsShippedFromWarehouse(self, warehouseId, providerId, cod, orderIds):
3064 chandransh 370 
    """
371 
    Depending on the third parameter, marks either all prepaid or all cod orders BILLED by the
4910 phani.kuma 372 
    given warehouse and were picked up by the given provider as SHIPPED_FROM_WH.
4410 rajveer 373 
 
374 
    Parameters:
375 
     - warehouseId
376 
     - providerId
377 
     - cod
4910 phani.kuma 378 
     - orderIds
4410 rajveer 379 
    """
380 
    pass
381 
 
5713 rajveer 382 
  def markOrdersAsReturnedFromStore(self, providerId, orderIds, awbs):
5676 rajveer 383 
    """
384 
    Parameters:
385 
     - providerId
386 
     - orderIds
5713 rajveer 387 
     - awbs
5676 rajveer 388 
    """
389 
    pass
390 
 
4910 phani.kuma 391 
  def markOrdersAsPickedUp(self, providerId, pickupDetails):
4410 rajveer 392 
    """
4910 phani.kuma 393 
    Marks all SHIPPED_FROM_WH orders of the previous day for a provider as SHIPPED_TO_LOGISTICS.
394 
    Raises an exception if we encounter report for an AWB number that we did not ship.
3431 rajveer 395 
 
3064 chandransh 396 
    Parameters:
759 chandransh 397 
     - providerId
4910 phani.kuma 398 
     - pickupDetails
759 chandransh 399 
    """
400 
    pass
401 
 
4910 phani.kuma 402 
  def getOrdersNotPickedUp(self, providerId):
1113 chandransh 403 
    """
404 
    Returns a list of orders that were shipped from warehouse but did not appear in the pick-up report.
3431 rajveer 405 
 
1113 chandransh 406 
    Parameters:
407 
     - providerId
408 
    """
409 
    pass
410 
 
1132 chandransh 411 
  def markOrdersAsDelivered(self, providerId, deliveredOrders):
412 
    """
413 
    Marks all orders with AWBs in the given map as delivered. Also sets the delivery timestamp and
414 
    the name of the receiver.
415 
    Raises an exception if we encounter report for an AWB number that we did not ship.
3431 rajveer 416 
 
1132 chandransh 417 
    Parameters:
418 
     - providerId
419 
     - deliveredOrders
420 
    """
421 
    pass
422 
 
4910 phani.kuma 423 
  def markAsRTOrders(self, providerId, returnedOrders):
1135 chandransh 424 
    """
4910 phani.kuma 425 
    Mark all orders with AWBs in the given map as RTO. Also sets the delivery timestamp.
1135 chandransh 426 
    Raises an exception if we encounter report for an AWB number that we did not ship.
3431 rajveer 427 
 
1135 chandransh 428 
    Parameters:
429 
     - providerId
430 
     - returnedOrders
431 
    """
432 
    pass
433 
 
4910 phani.kuma 434 
  def getRTOrders(self, providerId):
435 
    """
436 
    Returns a list of orders that were returned by courier.
437 
 
438 
    Parameters:
439 
     - providerId
440 
    """
441 
    pass
442 
 
1246 chandransh 443 
  def updateNonDeliveryReason(self, providerId, undeliveredOrders):
444 
    """
445 
    Update the status description of orders whose AWB numbers are keys of the Map.
3431 rajveer 446 
 
1246 chandransh 447 
    Parameters:
448 
     - providerId
449 
     - undeliveredOrders
450 
    """
451 
    pass
452 
 
4910 phani.kuma 453 
  def getNonDeliveredOrdersbyCourier(self, providerId):
454 
    """
455 
    Returns a list of orders that were picked up or shipped four days ago but did not get delivered.
456 
 
457 
    Parameters:
458 
     - providerId
459 
    """
460 
    pass
461 
 
462 
  def markOrdersAsLocalConnected(self, providerId, local_connected_orders):
463 
    """
464 
    Mark all orders with AWBs in the given map as local connected. Also sets the local connected timestamp.
465 
 
466 
    Parameters:
467 
     - providerId
468 
     - local_connected_orders
469 
    """
470 
    pass
471 
 
472 
  def getOrdersNotLocalConnected(self, providerId):
473 
    """
474 
    Returns a list of orders that were picked up or shipped but pending local connection.
475 
 
476 
    Parameters:
477 
     - providerId
478 
    """
479 
    pass
480 
 
481 
  def markOrdersAsDestinationCityReached(self, providerId, destination_city_reached_orders):
482 
    """
483 
    Mark all orders with AWBs in the given map as reached destination city. Also sets the reached destination timestamp.
484 
 
485 
    Parameters:
486 
     - providerId
487 
     - destination_city_reached_orders
488 
    """
489 
    pass
490 
 
491 
  def markOrdersAsFirstDeliveryAttempted(self, providerId, first_atdl_orders):
492 
    """
493 
    Mark all orders with AWBs in the given map as first delivery attempt made. Also sets the first delivery attempted timestamp.
494 
 
495 
    Parameters:
496 
     - providerId
497 
     - first_atdl_orders
498 
    """
499 
    pass
500 
 
1408 ankur.sing 501 
  def getUndeliveredOrders(self, providerId, warehouseId):
502 
    """
503 
    Returns the list of orders whose delivery time has passed but have not been
504 
    delivered yet for the given provider and warehouse. To get a complete list of
505 
    undelivered orders, pass them as -1.
506 
    Returns an empty list if no such orders exist.
3431 rajveer 507 
 
1408 ankur.sing 508 
    Parameters:
509 
     - providerId
510 
     - warehouseId
511 
    """
512 
    pass
513 
 
4783 phani.kuma 514 
  def getUndeliveredOrdersExpectedDeliveryDateNotMet(self, ):
515 
    """
516 
    Returns the list of orders whose expected delivery date has passed but have not been
517 
    delivered yet.
518 
    Returns an empty list if no such orders exist.
519 
    """
520 
    pass
521 
 
2536 chandransh 522 
  def toggleDOAFlag(self, orderId):
523 
    """
524 
    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.
525 
    Returns the final flag status.
526 
    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 527 
 
2536 chandransh 528 
    Parameters:
529 
     - orderId
530 
    """
531 
    pass
1886 ankur.sing 532 
 
4712 rajveer 533 
  def markOrderAsDelivered(self, orderId, deliveryTimestamp, receiver):
534 
    """
535 
    Parameters:
536 
     - orderId
537 
     - deliveryTimestamp
538 
     - receiver
539 
    """
540 
    pass
541 
 
5553 rajveer 542 
  def markOrderAsReceivedAtStore(self, orderId, deliveryTimestamp):
543 
    """
544 
    Parameters:
545 
     - orderId
546 
     - deliveryTimestamp
547 
    """
548 
    pass
549 
 
4454 rajveer 550 
  def markOrderDoaRequestReceived(self, orderId):
551 
    """
552 
    Once user raise the request for a DOA, order status will be changed from DELVIERY_SUCCESS to DOA_REQUEST_RECEIVED
553 
 
554 
    Parameters:
555 
     - orderId
556 
    """
557 
    pass
558 
 
559 
  def markOrderDoaRequestAuthorized(self, orderId, isAuthorized):
560 
    """
561 
    CRM person can authorize or deny the request reised by customer. If he authorizes order will change from DOA_REQUEST_RECEIVED
562 
    to DOA_REQUEST_AUTHORIZED. If he denies, status will be changed back to DELVIERY_SUCCESS.
563 
 
564 
    Parameters:
565 
     - orderId
566 
     - isAuthorized
567 
    """
568 
    pass
569 
 
4488 rajveer 570 
  def markOrderReturnRequestReceived(self, orderId):
571 
    """
572 
    Once user raise the request for a RET, order status will be changed from DELVIERY_SUCCESS to RET_REQUEST_RECEIVED
573 
 
574 
    Parameters:
575 
     - orderId
576 
    """
577 
    pass
578 
 
579 
  def markOrderReturnRequestAuthorized(self, orderId, isAuthorized):
580 
    """
581 
    CRM person can authorize or deny the request reised by customer. If he authorizes order will change from RET_REQUEST_RECEIVED
582 
    to RET_REQUEST_AUTHORIZED. If he denies, status will be changed back to DELVIERY_SUCCESS.
583 
 
584 
    Parameters:
585 
     - orderId
586 
     - isAuthorized
587 
    """
588 
    pass
589 
 
4579 rajveer 590 
  def requestPickupNumber(self, orderId, providerId):
2536 chandransh 591 
    """
592 
    Sends out an email to the account manager of the original courier provider used to ship the order.
4452 rajveer 593 
    If the order status was DELIVERY_SUCCESS, it is changed to be DOA_PICKUP_REQUEST_RAISED.
594 
    If the order status was DOA_PICKUP_REQUEST_RAISED, it is left unchanged.
2536 chandransh 595 
    For any other status, it returns false.
596 
    Throws an exception if the order with the given id couldn't be found.
3431 rajveer 597 
 
2536 chandransh 598 
    Parameters:
599 
     - orderId
4579 rajveer 600 
     - providerId
2536 chandransh 601 
    """
602 
    pass
603 
 
4602 rajveer 604 
  def authorizePickup(self, orderId, pickupNumber, providerId):
2536 chandransh 605 
    """
4452 rajveer 606 
    If the order status is DOA_PICKUP_REQUEST_RAISED, it does the following
2536 chandransh 607 
    	1. Sends out an email to the customer with the dispatch advice that he has to print as an attachment.
608 
    	2. Changes order status to be DOA_PICKUP_AUTHORIZED.
609 
    	3. Returns true
2591 chandransh 610 
    If the order is in any other status, it returns false.
2536 chandransh 611 
    Throws an exception if the order with the given id couldn't be found.
3431 rajveer 612 
 
2536 chandransh 613 
    Parameters:
614 
     - orderId
615 
     - pickupNumber
4602 rajveer 616 
     - providerId
2536 chandransh 617 
    """
618 
    pass
619 
 
2764 chandransh 620 
  def markDoasAsPickedUp(self, providerId, pickupDetails):
621 
    """
622 
    Marks all DOA_PICKUP_AUTHORIZED orders of the previous day for a provider as DOA_RETURN_IN_TRANSIT.
3431 rajveer 623 
 
2764 chandransh 624 
    Parameters:
625 
     - providerId
626 
     - pickupDetails
627 
    """
628 
    pass
629 
 
4910 phani.kuma 630 
  def getDoasNotPickedUp(self, providerId):
631 
    """
632 
    Returns a list of orders that were authorized for pickup but did not appear in the pick-up report.
633 
 
634 
    Parameters:
635 
     - providerId
636 
    """
637 
    pass
638 
 
4741 phani.kuma 639 
  def markReturnOrdersAsPickedUp(self, providerId, pickupDetails):
640 
    """
641 
    Marks all RET_PICKUP_CONFIRMED orders of the previous day for a provider as RET_RETURN_IN_TRANSIT.
642 
 
643 
    Parameters:
644 
     - providerId
645 
     - pickupDetails
646 
    """
647 
    pass
648 
 
4910 phani.kuma 649 
  def getReturnOrdersNotPickedUp(self, providerId):
650 
    """
651 
    Returns a list of orders that were authorized for pickup but did not appear in the pick-up report.
652 
 
653 
    Parameters:
654 
     - providerId
655 
    """
656 
    pass
657 
 
4479 rajveer 658 
  def receiveReturn(self, orderId, receiveCondition):
2591 chandransh 659 
    """
4452 rajveer 660 
    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 661 
    If the order status is RTO_IN_TRANSIT, marks the order status as RTO_RECEIVED_PRESTINE and returns true.
2591 chandransh 662 
    If the order is in any other state, it returns false.
663 
    Throws an exception if the order with the given id couldn't be found.
3431 rajveer 664 
 
2591 chandransh 665 
    Parameters:
666 
     - orderId
4479 rajveer 667 
     - receiveCondition
2591 chandransh 668 
    """
669 
    pass
2536 chandransh 670 
 
2591 chandransh 671 
  def validateDoa(self, orderId, isValid):
672 
    """
4452 rajveer 673 
    Used to validate the DOA certificate for an order in the DOA_RECEIVED_PRESTINE state. If the certificate is valid,
2616 chandransh 674 
    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 675 
    If the order is in any other state, it returns false.
676 
    Throws an exception if the order with the given id couldn't be found.
3431 rajveer 677 
 
2591 chandransh 678 
    Parameters:
679 
     - orderId
680 
     - isValid
681 
    """
682 
    pass
683 
 
4495 rajveer 684 
  def validateReturnProduct(self, orderId, isUsable):
685 
    """
686 
    Parameters:
687 
     - orderId
688 
     - isUsable
689 
    """
690 
    pass
691 
 
2616 chandransh 692 
  def reshipOrder(self, orderId):
693 
    """
4484 rajveer 694 
    If the order is in RTO_RECEIVED_PRESTINE or DOA_CERT_INVALID state, it does the following:
2616 chandransh 695 
    	1. Creates a new order for processing in the BILLED state. All billing information is saved.
4484 rajveer 696 
    	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 697 
 
698 
    If the order is in DOA_CERT_VALID state, it does the following:
699 
    	1. Creates a new order for processing in the SUBMITTED_FOR_PROCESSING state.
700 
    	2. Creates a return order for the warehouse executive to return the DOA material.
4452 rajveer 701 
    	3. Marks the current order as the final DOA_VALID_RESHIPPED state.
3431 rajveer 702 
 
2616 chandransh 703 
    Returns the id of the newly created order.
3431 rajveer 704 
 
2616 chandransh 705 
    Throws an exception if the order with the given id couldn't be found.
3431 rajveer 706 
 
2616 chandransh 707 
    Parameters:
708 
     - orderId
709 
    """
710 
    pass
2591 chandransh 711 
 
3226 chandransh 712 
  def refundOrder(self, orderId, refundedBy, reason):
2616 chandransh 713 
    """
4484 rajveer 714 
    If the order is in RTO_RECEIVED_PRESTINE, DOA_CERT_VALID or DOA_CERT_INVALID state, it does the following:
2616 chandransh 715 
    	1. Creates a refund request for batch processing.
716 
    	2. Creates a return order for the warehouse executive to return the shipped material.
4484 rajveer 717 
    	3. Marks the current order as RTO_REFUNDED, DOA_VALID_REFUNDED or DOA_INVALID_REFUNDED final states.
3431 rajveer 718 
 
2616 chandransh 719 
    If the order is in SUBMITTED_FOR_PROCESSING or INVENTORY_LOW state, it does the following:
720 
    	1. Creates a refund request for batch processing.
3226 chandransh 721 
    	2. Cancels the reservation of the item in the warehouse.
722 
    	3. Marks the current order as the REFUNDED final state.
3431 rajveer 723 
 
3226 chandransh 724 
    For all COD orders, if the order is in INIT, SUBMITTED_FOR_PROCESSING or INVENTORY_LOW state, it does the following:
725 
    	1. Cancels the reservation of the item in the warehouse.
726 
    	2. Marks the current order as CANCELED.
727 
 
728 
    In all cases, it updates the reason for cancellation or refund and the person who performed the action.
729 
 
2616 chandransh 730 
    Returns True if it is successful, False otherwise.
3431 rajveer 731 
 
2616 chandransh 732 
    Throws an exception if the order with the given id couldn't be found.
3431 rajveer 733 
 
2616 chandransh 734 
    Parameters:
735 
     - orderId
3226 chandransh 736 
     - refundedBy
737 
     - reason
2616 chandransh 738 
    """
739 
    pass
740 
 
2690 chandransh 741 
  def getReturnOrders(self, warehouseId, fromDate, toDate):
742 
    """
743 
    Get all return orders created between the from and to dates for the given warehouse.
744 
    Ignores the warehouse if it is passed as -1.
3431 rajveer 745 
 
2690 chandransh 746 
    Parameters:
747 
     - warehouseId
748 
     - fromDate
749 
     - toDate
750 
    """
751 
    pass
2616 chandransh 752 
 
5481 phani.kuma 753 
  def getAllReturnOrders(self, onlyNotProcessed, fromDate, toDate):
754 
    """
755 
    Get all return orders created between the from and to dates.
756 
 
757 
    Parameters:
758 
     - onlyNotProcessed
759 
     - fromDate
760 
     - toDate
761 
    """
762 
    pass
763 
 
2700 chandransh 764 
  def getReturnOrder(self, id):
765 
    """
766 
    Returns the ReturnOrder corresponding to the given id.
767 
    Throws an exception if the return order with the given id couldn't be found.
3431 rajveer 768 
 
2700 chandransh 769 
    Parameters:
770 
     - id
771 
    """
772 
    pass
773 
 
2690 chandransh 774 
  def processReturn(self, returnOrderId):
775 
    """
776 
    Marks the return order with the given id as processed. Raises an exception if no such return order exists.
3431 rajveer 777 
 
2690 chandransh 778 
    Parameters:
779 
     - returnOrderId
780 
    """
781 
    pass
782 
 
3451 chandransh 783 
  def updateWeight(self, orderId, weight):
784 
    """
785 
    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 786 
 
3451 chandransh 787 
    Parameters:
788 
     - orderId
789 
     - weight
790 
    """
791 
    pass
792 
 
3469 chandransh 793 
  def changeItem(self, orderId, itemId):
794 
    """
795 
    Change the item to be shipped for this order. Also adjusts the reservation in the inventory accordingly.
796 
    Currently, it also ensures that only a different color of the given item is shipped.
3451 chandransh 797 
 
3469 chandransh 798 
    Parameters:
799 
     - orderId
800 
     - itemId
801 
    """
802 
    pass
803 
 
804 
  def shiftToWarehouse(self, orderId, warehouseId):
805 
    """
806 
    Moves the given order to the given warehouse. Also adjusts the inventory reservations accordingly.
807 
 
808 
    Parameters:
809 
     - orderId
810 
     - warehouseId
811 
    """
812 
    pass
813 
 
4647 rajveer 814 
  def addDelayReason(self, orderId, delayReason, furtherDelay, delayReasonText):
3553 chandransh 815 
    """
816 
    Adds the given delay reason to the given order.
3986 chandransh 817 
    Increases the expected delivery time of the given order by the given no. of days.
3553 chandransh 818 
    Raises an exception if no order with the given id can be found.
3469 chandransh 819 
 
3553 chandransh 820 
    Parameters:
821 
     - orderId
822 
     - delayReason
3986 chandransh 823 
     - furtherDelay
4647 rajveer 824 
     - delayReasonText
3553 chandransh 825 
    """
826 
    pass
827 
 
3956 chandransh 828 
  def reconcileCodCollection(self, collectedAmountMap, xferBy, xferTxnId, xferDate):
829 
    """
830 
    Marks the COD orders with given AWB nos. as having been processed.
831 
    Updates the captured amount for the corresponding payment.
3553 chandransh 832 
 
3956 chandransh 833 
    Returns a map of AWBs which were not processed and the associated reason. An AWB is not processed if:
834 
    1. There is no order corresponding to an AWB number.
835 
    2. The captured amount for a payment exceeds the total payment.
836 
    3. The order corresponding to an AWB no. is in a state prior to DELIVERY_SUCCESS.
837 
 
838 
    Parameters:
839 
     - collectedAmountMap
840 
     - xferBy
841 
     - xferTxnId
842 
     - xferDate
843 
    """
844 
    pass
845 
 
4008 mandeep.dh 846 
  def getTransactionsRequiringExtraProcessing(self, category):
847 
    """
4065 mandeep.dh 848 
    Returns the list of transaction ids that require some extra processing and
4008 mandeep.dh 849 
    which belong to a particular category. This is currently used by CRM
4065 mandeep.dh 850 
    application. If no such transaction ids are present, it returns an empty list.
3956 chandransh 851 
 
4008 mandeep.dh 852 
    Parameters:
853 
     - category
854 
    """
855 
    pass
856 
 
857 
  def markTransactionAsProcessed(self, transactionId, category):
858 
    """
859 
    Marks a particular transaction as processed for a particular cateogory.
4065 mandeep.dh 860 
    It essentially deletes the transaction id record for a particular
861 
    processing type category (if present) from DB.
862 
    This is currently used by CRM application.
4008 mandeep.dh 863 
 
864 
    Parameters:
865 
     - transactionId
866 
     - category
867 
    """
868 
    pass
869 
 
4018 chandransh 870 
  def getItemWiseRiskyOrdersCount(self, ):
871 
    """
872 
    Returns a map containing the number of risky orders keyed by item id. A risky order
873 
    is defined as one whose shipping date is about to expire.
874 
    """
875 
    pass
4008 mandeep.dh 876 
 
4295 varun.gupt 877 
  def getOrdersForItemIds(self, itemIds):
878 
    """
879 
    Returns a list of all orders which have items with given id
880 
 
881 
    Parameters:
882 
     - itemIds
883 
    """
884 
    pass
885 
 
4247 rajveer 886 
  def markOrderCancellationRequestReceived(self, orderId):
887 
    """
888 
    Mark order as cancellation request received. If customer sends request of cancellation of
889 
    a particular order, this method will be called. It will just change status of the order
890 
    depending on its current status. It also records the previous status, so that we can move
891 
    back to that status if cancellation request is denied.
4018 chandransh 892 
 
4247 rajveer 893 
    Parameters:
894 
     - orderId
895 
    """
896 
    pass
897 
 
898 
  def markOrderCancellationRequestConfirmed(self, orderId):
899 
    """
900 
    If we decide to to cancel order, CRM will call this method to move the status of order to
901 
    cancellation request confirmed. After this OM will be able to cancel the order.
902 
 
903 
    Parameters:
904 
     - orderId
905 
    """
906 
    pass
907 
 
908 
  def markOrderCancellationRequestDenied(self, orderId):
909 
    """
910 
    If we decide to not to cancel order, we will move the order ro previous status.
911 
 
912 
    Parameters:
913 
     - orderId
914 
    """
915 
    pass
916 
 
4258 rajveer 917 
  def markTransactionAsPaymentFlagRemoved(self, transactionId):
4247 rajveer 918 
    """
4258 rajveer 919 
    If we and/or payment gateway has decided to accept the payment, this method needs to be called.
920 
    Changed transaction and all orders status to payment accepted.
4247 rajveer 921 
 
922 
    Parameters:
4258 rajveer 923 
     - transactionId
4247 rajveer 924 
    """
925 
    pass
926 
 
4259 anupam.sin 927 
  def refundTransaction(self, transactionId, refundedBy, reason):
928 
    """
929 
    This method is called when a flagged payment is deemed unserviceable and the corresponding orders
930 
    need to be cancelled
4247 rajveer 931 
 
4259 anupam.sin 932 
    Parameters:
933 
     - transactionId
934 
     - refundedBy
935 
     - reason
936 
    """
937 
    pass
938 
 
4324 mandeep.dh 939 
  def updateShipmentAddress(self, orderId, addressId):
940 
    """
941 
    Updates shipment address of an order. Delivery and shipping date estimates
942 
    etc. are also updated here.
943 
 
944 
    Throws TransactionServiceException in case address change is not
945 
    possible due to certain reasons such as new pincode in address is
946 
    not serviceable etc.
947 
 
948 
    Parameters:
949 
     - orderId
950 
     - addressId
951 
    """
952 
    pass
953 
 
4285 rajveer 954 
  def acceptOrdersForItemId(self, itemId, inventory):
955 
    """
956 
    Marks the orders as ACCEPTED for the given itemId and inventory. It also updates the accepted timestamp. If the
957 
    given order is not a COD order, it also captures the payment if the same has not been captured.
4259 anupam.sin 958 
 
4285 rajveer 959 
    Parameters:
960 
     - itemId
961 
     - inventory
962 
    """
963 
    pass
964 
 
4369 rajveer 965 
  def markOrdersAsPORaised(self, vendorId, itemId, quantity, estimate, isReminder):
4303 rajveer 966 
    """
967 
    Parameters:
968 
     - vendorId
969 
     - itemId
970 
     - quantity
971 
     - estimate
4369 rajveer 972 
     - isReminder
4303 rajveer 973 
    """
974 
    pass
4285 rajveer 975 
 
4369 rajveer 976 
  def markOrdersAsReversalInitiated(self, vendorId, itemId, quantity, estimate, isReminder):
4303 rajveer 977 
    """
978 
    Parameters:
979 
     - vendorId
980 
     - itemId
981 
     - quantity
982 
     - estimate
4369 rajveer 983 
     - isReminder
4303 rajveer 984 
    """
985 
    pass
986 
 
4369 rajveer 987 
  def markOrdersAsNotAvailabke(self, vendorId, itemId, quantity, estimate, isReminder):
4303 rajveer 988 
    """
989 
    Parameters:
990 
     - vendorId
991 
     - itemId
992 
     - quantity
993 
     - estimate
4369 rajveer 994 
     - isReminder
4303 rajveer 995 
    """
996 
    pass
997 
 
4369 rajveer 998 
  def markOrdersAsTimeout(self, vendorId):
999 
    """
1000 
    Parameters:
1001 
     - vendorId
1002 
    """
1003 
    pass
4303 rajveer 1004 
 
4662 rajveer 1005 
  def markOrderAsLostInTransit(self, orderId):
1006 
    """
1007 
    Mark order as LOST_IN_TRANSIT
1008 
 
1009 
    Parameters:
1010 
     - orderId
1011 
    """
1012 
    pass
1013 
 
4386 anupam.sin 1014 
  def getOrderForAwb(self, awb):
1015 
    """
1016 
    Returns the order corresponding to an AWB number
4369 rajveer 1017 
 
4386 anupam.sin 1018 
    Parameters:
1019 
     - awb
1020 
    """
1021 
    pass
1022 
 
4910 phani.kuma 1023 
  def getOrdersForProviderForStatus(self, logistics_provider_id, order_status_list):
4506 phani.kuma 1024 
    """
4910 phani.kuma 1025 
    Returns the order corresponding to a logistics provider id for a given list of order status
4386 anupam.sin 1026 
 
4506 phani.kuma 1027 
    Parameters:
1028 
     - logistics_provider_id
4910 phani.kuma 1029 
     - order_status_list
4506 phani.kuma 1030 
    """
1031 
    pass
1032 
 
4600 varun.gupt 1033 
  def getBilledOrdersForVendor(self, vendorId, billingDateFrom, billingDateTo):
1034 
    """
1035 
    Returns list of orders fullfiled from a certain vendor and billed in a given date range
4506 phani.kuma 1036 
 
4600 varun.gupt 1037 
    Parameters:
1038 
     - vendorId
1039 
     - billingDateFrom
1040 
     - billingDateTo
1041 
    """
1042 
    pass
1043 
 
4607 rajveer 1044 
  def getSlippedSippingDateOrders(self, ):
1045 
    pass
1046 
 
4709 rajveer 1047 
  def getCancelledOrders(self, cancelDateFrom, cancelDateTo):
1048 
    """
1049 
    Parameters:
1050 
     - cancelDateFrom
1051 
     - cancelDateTo
1052 
    """
1053 
    pass
1054 
 
4600 varun.gupt 1055 
  def saveBluedartSettlements(self, mapAWBAndAmount):
1056 
    """
1057 
    Parameters:
1058 
     - mapAWBAndAmount
1059 
    """
1060 
    pass
1061 
 
4905 varun.gupt 1062 
  def savePaymentSettlements(self, settlementDate, paymentGatewayId, referenceId, serviceTax, otherCharges, netCollection):
4600 varun.gupt 1063 
    """
1064 
    Parameters:
1065 
     - settlementDate
1066 
     - paymentGatewayId
4905 varun.gupt 1067 
     - referenceId
4600 varun.gupt 1068 
     - serviceTax
1069 
     - otherCharges
1070 
     - netCollection
1071 
    """
1072 
    pass
1073 
 
1074 
  def saveEBSSettlementSummary(self, settlementId, settlementDate, transactionDateFrom, transactionDateTo, amount):
1075 
    """
1076 
    Parameters:
1077 
     - settlementId
1078 
     - settlementDate
1079 
     - transactionDateFrom
1080 
     - transactionDateTo
1081 
     - amount
1082 
    """
1083 
    pass
1084 
 
5386 phani.kuma 1085 
  def getSettlementForPrepaid(self, referenceId, isRefund):
4600 varun.gupt 1086 
    """
1087 
    Parameters:
5189 varun.gupt 1088 
     - referenceId
1089 
     - isRefund
4600 varun.gupt 1090 
    """
1091 
    pass
1092 
 
5386 phani.kuma 1093 
  def getSettlementForCod(self, orderId, isRefund):
1094 
    """
1095 
    Parameters:
1096 
     - orderId
1097 
     - isRefund
1098 
    """
1099 
    pass
1100 
 
4600 varun.gupt 1101 
  def getEBSSettlementSummaries(self, ):
1102 
    pass
1103 
 
1104 
  def markEBSSettlementUploaded(self, settlementId):
1105 
    """
1106 
    Parameters:
1107 
     - settlementId
1108 
    """
1109 
    pass
1110 
 
1111 
  def getEBSSettlementDate(self, settlementId):
1112 
    """
1113 
    Parameters:
1114 
     - settlementId
1115 
    """
1116 
    pass
1117 
 
4715 varun.gupt 1118 
  def getSettlementsByDate(self, settlementDateFrom, settlementDateTo, isRefund):
1119 
    """
1120 
    Parameters:
1121 
     - settlementDateFrom
1122 
     - settlementDateTo
1123 
     - isRefund
1124 
    """
1125 
    pass
4600 varun.gupt 1126 
 
4715 varun.gupt 1127 
  def getReshippedOrderIds(self, orderIds):
1128 
    """
1129 
    Returns list of Order Ids, which belong to reshiped orders, shortlisted from a given list of Order Ids
1130 
 
1131 
    Parameters:
1132 
     - orderIds
1133 
    """
1134 
    pass
1135 
 
5481 phani.kuma 1136 
  def getBilledOrders(self, vendorId, onlyVendorNotPaid, billingDateFrom, billingDateTo):
4875 varun.gupt 1137 
    """
1138 
    Parameters:
1139 
     - vendorId
5481 phani.kuma 1140 
     - onlyVendorNotPaid
1141 
     - billingDateFrom
1142 
     - billingDateTo
4875 varun.gupt 1143 
    """
1144 
    pass
4757 mandeep.dh 1145 
 
5031 varun.gupt 1146 
  def getStatusDistributionOfOrders(self, startDate, endDate):
1147 
    """
1148 
    Parameters:
1149 
     - startDate
1150 
     - endDate
1151 
    """
1152 
    pass
4875 varun.gupt 1153 
 
5067 varun.gupt 1154 
  def getOrderIdsForStatus(self, status, startDatetime, endDatetime):
1155 
    """
1156 
    Parameters:
1157 
     - status
1158 
     - startDatetime
1159 
     - endDatetime
1160 
    """
1161 
    pass
5031 varun.gupt 1162 
 
5348 anupam.sin 1163 
  def updateCODAgent(self, agent, orderId):
1164 
    """
1165 
    Updates the agent who handled the COD verification call
1166 
 
1167 
    Parameters:
1168 
     - agent
1169 
     - orderId
1170 
    """
1171 
    pass
1172 
 
5099 varun.gupt 1173 
  def updateOrderAsPaidToVendor(self, orderId):
1174 
    """
1175 
    Parameters:
1176 
     - orderId
1177 
    """
1178 
    pass
5067 varun.gupt 1179 
 
5386 phani.kuma 1180 
  def updateOrderOnlyAsPaidToVendor(self, orderId):
1181 
    """
1182 
    Parameters:
1183 
     - orderId
1184 
    """
1185 
    pass
1186 
 
5208 varun.gupt 1187 
  def getRefundedOrdersMarkedPaid(self, ):
1188 
    pass
5099 varun.gupt 1189 
 
5447 anupam.sin 1190 
  def getAllVerificationAgents(self, minOrderId, maxOrderId):
1191 
    """
1192 
    gets all COD Verification Agents for all orderIds from a minId to maxId
5208 varun.gupt 1193 
 
5447 anupam.sin 1194 
 
1195 
    Parameters:
1196 
     - minOrderId
1197 
     - maxOrderId
1198 
    """
1199 
    pass
1200 
 
5527 anupam.sin 1201 
  def getAllAttributesForOrderId(self, orderId):
1202 
    """
1203 
    gets all attributes for a given orderId
5447 anupam.sin 1204 
 
5527 anupam.sin 1205 
    Parameters:
1206 
     - orderId
1207 
    """
1208 
    pass
1209 
 
5676 rajveer 1210 
  def setOrderAttributes(self, orderId, attributes):
1211 
    """
1212 
    sets attributes for an order
1213 
 
1214 
    Parameters:
1215 
     - orderId
1216 
     - attributes
1217 
    """
1218 
    pass
1219 
 
5527 anupam.sin 1220 
  def setOrderAttributeForTransaction(self, transactionId, attribute):
1221 
    """
1222 
    sets attributes for all orders in a transaction
1223 
 
1224 
    Parameters:
1225 
     - transactionId
1226 
     - attribute
1227 
    """
1228 
    pass
1229 
 
5553 rajveer 1230 
  def getReceivePendingOrders(self, storeId):
1231 
    """
1232 
    Parameters:
1233 
     - storeId
1234 
    """
1235 
    pass
5527 anupam.sin 1236 
 
5553 rajveer 1237 
  def getReceivedAtStoreOrders(self, storeId):
1238 
    """
1239 
    Parameters:
1240 
     - storeId
1241 
    """
1242 
    pass
1243 
 
5713 rajveer 1244 
  def getOrdersCollectionAtStore(self, storeId, fromDate, toDate, onlyCod):
1245 
    """
1246 
    Parameters:
1247 
     - storeId
1248 
     - fromDate
1249 
     - toDate
1250 
     - onlyCod
1251 
    """
1252 
    pass
1253 
 
5833 rajveer 1254 
  def getOrderAttributeValue(self, orderId, attributeName):
1255 
    """
1256 
    Parameters:
1257 
     - orderId
1258 
     - attributeName
1259 
    """
1260 
    pass
1261 
 
5593 mandeep.dh 1262 
  def acceptOrderForItem(self, itemId, quantity, fulfilmentWarehouseId, billingWarehouseId):
1263 
    """
1264 
    Accepts appropriate order for an item in a given billingWarehouse. Usually
1265 
    invoked while scanning IN of items.
5553 rajveer 1266 
 
5593 mandeep.dh 1267 
    Parameters:
1268 
     - itemId
1269 
     - quantity
1270 
     - fulfilmentWarehouseId
1271 
     - billingWarehouseId
1272 
    """
1273 
    pass
1274 
 
1275 
 
3376 rajveer 1276 
class Client(shop2020.thriftpy.generic.GenericService.Client, Iface):
94 ashish 1277 
  def __init__(self, iprot, oprot=None):
3376 rajveer 1278 
    shop2020.thriftpy.generic.GenericService.Client.__init__(self, iprot, oprot)
94 ashish 1279 
 
1280 
  def createTransaction(self, transaction):
1281 
    """
1282 
    Parameters:
1283 
     - transaction
1284 
    """
1285 
    self.send_createTransaction(transaction)
132 ashish 1286 
    return self.recv_createTransaction()
94 ashish 1287 
 
1288 
  def send_createTransaction(self, transaction):
1289 
    self._oprot.writeMessageBegin('createTransaction', TMessageType.CALL, self._seqid)
1290 
    args = createTransaction_args()
1291 
    args.transaction = transaction
1292 
    args.write(self._oprot)
1293 
    self._oprot.writeMessageEnd()
1294 
    self._oprot.trans.flush()
1295 
 
1296 
  def recv_createTransaction(self, ):
1297 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1298 
    if mtype == TMessageType.EXCEPTION:
1299 
      x = TApplicationException()
1300 
      x.read(self._iprot)
1301 
      self._iprot.readMessageEnd()
1302 
      raise x
1303 
    result = createTransaction_result()
1304 
    result.read(self._iprot)
1305 
    self._iprot.readMessageEnd()
3431 rajveer 1306 
    if result.success is not None:
132 ashish 1307 
      return result.success
3431 rajveer 1308 
    if result.ex is not None:
94 ashish 1309 
      raise result.ex
132 ashish 1310 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "createTransaction failed: unknown result");
94 ashish 1311 
 
1312 
  def getTransaction(self, id):
1313 
    """
1314 
    Parameters:
1315 
     - id
1316 
    """
1317 
    self.send_getTransaction(id)
1318 
    return self.recv_getTransaction()
1319 
 
1320 
  def send_getTransaction(self, id):
1321 
    self._oprot.writeMessageBegin('getTransaction', TMessageType.CALL, self._seqid)
1322 
    args = getTransaction_args()
1323 
    args.id = id
1324 
    args.write(self._oprot)
1325 
    self._oprot.writeMessageEnd()
1326 
    self._oprot.trans.flush()
1327 
 
1328 
  def recv_getTransaction(self, ):
1329 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1330 
    if mtype == TMessageType.EXCEPTION:
1331 
      x = TApplicationException()
1332 
      x.read(self._iprot)
1333 
      self._iprot.readMessageEnd()
1334 
      raise x
1335 
    result = getTransaction_result()
1336 
    result.read(self._iprot)
1337 
    self._iprot.readMessageEnd()
3431 rajveer 1338 
    if result.success is not None:
94 ashish 1339 
      return result.success
3431 rajveer 1340 
    if result.ex is not None:
94 ashish 1341 
      raise result.ex
1342 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getTransaction failed: unknown result");
1343 
 
1344 
  def getTransactionsForCustomer(self, customerId, from_date, to_date, status):
1345 
    """
1346 
    Parameters:
1347 
     - customerId
1348 
     - from_date
1349 
     - to_date
1350 
     - status
1351 
    """
1352 
    self.send_getTransactionsForCustomer(customerId, from_date, to_date, status)
1353 
    return self.recv_getTransactionsForCustomer()
1354 
 
1355 
  def send_getTransactionsForCustomer(self, customerId, from_date, to_date, status):
1356 
    self._oprot.writeMessageBegin('getTransactionsForCustomer', TMessageType.CALL, self._seqid)
1357 
    args = getTransactionsForCustomer_args()
1358 
    args.customerId = customerId
1359 
    args.from_date = from_date
1360 
    args.to_date = to_date
1361 
    args.status = status
1362 
    args.write(self._oprot)
1363 
    self._oprot.writeMessageEnd()
1364 
    self._oprot.trans.flush()
1365 
 
1366 
  def recv_getTransactionsForCustomer(self, ):
1367 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1368 
    if mtype == TMessageType.EXCEPTION:
1369 
      x = TApplicationException()
1370 
      x.read(self._iprot)
1371 
      self._iprot.readMessageEnd()
1372 
      raise x
1373 
    result = getTransactionsForCustomer_result()
1374 
    result.read(self._iprot)
1375 
    self._iprot.readMessageEnd()
3431 rajveer 1376 
    if result.success is not None:
94 ashish 1377 
      return result.success
3431 rajveer 1378 
    if result.ex is not None:
94 ashish 1379 
      raise result.ex
1380 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getTransactionsForCustomer failed: unknown result");
1381 
 
132 ashish 1382 
  def getTransactionsForShoppingCartId(self, shoppingCartId):
1383 
    """
1384 
    Parameters:
1385 
     - shoppingCartId
1386 
    """
1387 
    self.send_getTransactionsForShoppingCartId(shoppingCartId)
1388 
    return self.recv_getTransactionsForShoppingCartId()
1389 
 
1390 
  def send_getTransactionsForShoppingCartId(self, shoppingCartId):
1391 
    self._oprot.writeMessageBegin('getTransactionsForShoppingCartId', TMessageType.CALL, self._seqid)
1392 
    args = getTransactionsForShoppingCartId_args()
1393 
    args.shoppingCartId = shoppingCartId
1394 
    args.write(self._oprot)
1395 
    self._oprot.writeMessageEnd()
1396 
    self._oprot.trans.flush()
1397 
 
1398 
  def recv_getTransactionsForShoppingCartId(self, ):
1399 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1400 
    if mtype == TMessageType.EXCEPTION:
1401 
      x = TApplicationException()
1402 
      x.read(self._iprot)
1403 
      self._iprot.readMessageEnd()
1404 
      raise x
1405 
    result = getTransactionsForShoppingCartId_result()
1406 
    result.read(self._iprot)
1407 
    self._iprot.readMessageEnd()
3431 rajveer 1408 
    if result.success is not None:
132 ashish 1409 
      return result.success
3431 rajveer 1410 
    if result.ex is not None:
132 ashish 1411 
      raise result.ex
1412 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getTransactionsForShoppingCartId failed: unknown result");
1413 
 
94 ashish 1414 
  def getTransactionStatus(self, transactionId):
1415 
    """
1416 
    Parameters:
1417 
     - transactionId
1418 
    """
1419 
    self.send_getTransactionStatus(transactionId)
1420 
    return self.recv_getTransactionStatus()
1421 
 
1422 
  def send_getTransactionStatus(self, transactionId):
1423 
    self._oprot.writeMessageBegin('getTransactionStatus', TMessageType.CALL, self._seqid)
1424 
    args = getTransactionStatus_args()
1425 
    args.transactionId = transactionId
1426 
    args.write(self._oprot)
1427 
    self._oprot.writeMessageEnd()
1428 
    self._oprot.trans.flush()
1429 
 
1430 
  def recv_getTransactionStatus(self, ):
1431 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1432 
    if mtype == TMessageType.EXCEPTION:
1433 
      x = TApplicationException()
1434 
      x.read(self._iprot)
1435 
      self._iprot.readMessageEnd()
1436 
      raise x
1437 
    result = getTransactionStatus_result()
1438 
    result.read(self._iprot)
1439 
    self._iprot.readMessageEnd()
3431 rajveer 1440 
    if result.success is not None:
94 ashish 1441 
      return result.success
3431 rajveer 1442 
    if result.ex is not None:
94 ashish 1443 
      raise result.ex
1444 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getTransactionStatus failed: unknown result");
1445 
 
5527 anupam.sin 1446 
  def changeTransactionStatus(self, transactionId, status, description, pickUp, orderType):
94 ashish 1447 
    """
1448 
    Parameters:
1449 
     - transactionId
1450 
     - status
1451 
     - description
5527 anupam.sin 1452 
     - pickUp
1453 
     - orderType
94 ashish 1454 
    """
5527 anupam.sin 1455 
    self.send_changeTransactionStatus(transactionId, status, description, pickUp, orderType)
94 ashish 1456 
    return self.recv_changeTransactionStatus()
1457 
 
5527 anupam.sin 1458 
  def send_changeTransactionStatus(self, transactionId, status, description, pickUp, orderType):
94 ashish 1459 
    self._oprot.writeMessageBegin('changeTransactionStatus', TMessageType.CALL, self._seqid)
1460 
    args = changeTransactionStatus_args()
1461 
    args.transactionId = transactionId
1462 
    args.status = status
1463 
    args.description = description
5527 anupam.sin 1464 
    args.pickUp = pickUp
1465 
    args.orderType = orderType
94 ashish 1466 
    args.write(self._oprot)
1467 
    self._oprot.writeMessageEnd()
1468 
    self._oprot.trans.flush()
1469 
 
1470 
  def recv_changeTransactionStatus(self, ):
1471 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1472 
    if mtype == TMessageType.EXCEPTION:
1473 
      x = TApplicationException()
1474 
      x.read(self._iprot)
1475 
      self._iprot.readMessageEnd()
1476 
      raise x
1477 
    result = changeTransactionStatus_result()
1478 
    result.read(self._iprot)
1479 
    self._iprot.readMessageEnd()
3431 rajveer 1480 
    if result.success is not None:
94 ashish 1481 
      return result.success
3431 rajveer 1482 
    if result.ex is not None:
94 ashish 1483 
      raise result.ex
1484 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "changeTransactionStatus failed: unknown result");
1485 
 
1398 varun.gupt 1486 
  def enqueueTransactionInfoEmail(self, transactionId):
1382 varun.gupt 1487 
    """
1488 
    Parameters:
1489 
     - transactionId
1490 
    """
1398 varun.gupt 1491 
    self.send_enqueueTransactionInfoEmail(transactionId)
1492 
    return self.recv_enqueueTransactionInfoEmail()
1382 varun.gupt 1493 
 
1398 varun.gupt 1494 
  def send_enqueueTransactionInfoEmail(self, transactionId):
1495 
    self._oprot.writeMessageBegin('enqueueTransactionInfoEmail', TMessageType.CALL, self._seqid)
1496 
    args = enqueueTransactionInfoEmail_args()
1382 varun.gupt 1497 
    args.transactionId = transactionId
1498 
    args.write(self._oprot)
1499 
    self._oprot.writeMessageEnd()
1500 
    self._oprot.trans.flush()
1501 
 
1398 varun.gupt 1502 
  def recv_enqueueTransactionInfoEmail(self, ):
1382 varun.gupt 1503 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1504 
    if mtype == TMessageType.EXCEPTION:
1505 
      x = TApplicationException()
1506 
      x.read(self._iprot)
1507 
      self._iprot.readMessageEnd()
1508 
      raise x
1398 varun.gupt 1509 
    result = enqueueTransactionInfoEmail_result()
1382 varun.gupt 1510 
    result.read(self._iprot)
1511 
    self._iprot.readMessageEnd()
3431 rajveer 1512 
    if result.success is not None:
1382 varun.gupt 1513 
      return result.success
3431 rajveer 1514 
    if result.ex is not None:
1382 varun.gupt 1515 
      raise result.ex
1398 varun.gupt 1516 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "enqueueTransactionInfoEmail failed: unknown result");
1382 varun.gupt 1517 
 
4801 anupam.sin 1518 
  def getAllOrders(self, statuses, from_date, to_date, warehouse_id):
94 ashish 1519 
    """
1520 
    Parameters:
4801 anupam.sin 1521 
     - statuses
483 rajveer 1522 
     - from_date
1523 
     - to_date
1524 
     - warehouse_id
94 ashish 1525 
    """
4801 anupam.sin 1526 
    self.send_getAllOrders(statuses, from_date, to_date, warehouse_id)
483 rajveer 1527 
    return self.recv_getAllOrders()
94 ashish 1528 
 
4801 anupam.sin 1529 
  def send_getAllOrders(self, statuses, from_date, to_date, warehouse_id):
483 rajveer 1530 
    self._oprot.writeMessageBegin('getAllOrders', TMessageType.CALL, self._seqid)
1531 
    args = getAllOrders_args()
4801 anupam.sin 1532 
    args.statuses = statuses
483 rajveer 1533 
    args.from_date = from_date
1534 
    args.to_date = to_date
1535 
    args.warehouse_id = warehouse_id
94 ashish 1536 
    args.write(self._oprot)
1537 
    self._oprot.writeMessageEnd()
1538 
    self._oprot.trans.flush()
1539 
 
483 rajveer 1540 
  def recv_getAllOrders(self, ):
94 ashish 1541 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1542 
    if mtype == TMessageType.EXCEPTION:
1543 
      x = TApplicationException()
1544 
      x.read(self._iprot)
1545 
      self._iprot.readMessageEnd()
1546 
      raise x
483 rajveer 1547 
    result = getAllOrders_result()
94 ashish 1548 
    result.read(self._iprot)
1549 
    self._iprot.readMessageEnd()
3431 rajveer 1550 
    if result.success is not None:
94 ashish 1551 
      return result.success
3431 rajveer 1552 
    if result.ex is not None:
94 ashish 1553 
      raise result.ex
483 rajveer 1554 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAllOrders failed: unknown result");
94 ashish 1555 
 
4133 chandransh 1556 
  def getOrdersInBatch(self, statuses, offset, limit, warehouse_id):
1557 
    """
1558 
    Returns at most 'limit' orders with the given statuses for the given warehouse starting from the given offset.
1559 
    Pass the status as null and the limit as 0 to ignore them.
1560 
 
1561 
    Parameters:
1562 
     - statuses
1563 
     - offset
1564 
     - limit
1565 
     - warehouse_id
1566 
    """
1567 
    self.send_getOrdersInBatch(statuses, offset, limit, warehouse_id)
1568 
    return self.recv_getOrdersInBatch()
1569 
 
1570 
  def send_getOrdersInBatch(self, statuses, offset, limit, warehouse_id):
1571 
    self._oprot.writeMessageBegin('getOrdersInBatch', TMessageType.CALL, self._seqid)
1572 
    args = getOrdersInBatch_args()
1573 
    args.statuses = statuses
1574 
    args.offset = offset
1575 
    args.limit = limit
1576 
    args.warehouse_id = warehouse_id
1577 
    args.write(self._oprot)
1578 
    self._oprot.writeMessageEnd()
1579 
    self._oprot.trans.flush()
1580 
 
1581 
  def recv_getOrdersInBatch(self, ):
1582 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1583 
    if mtype == TMessageType.EXCEPTION:
1584 
      x = TApplicationException()
1585 
      x.read(self._iprot)
1586 
      self._iprot.readMessageEnd()
1587 
      raise x
1588 
    result = getOrdersInBatch_result()
1589 
    result.read(self._iprot)
1590 
    self._iprot.readMessageEnd()
1591 
    if result.success is not None:
1592 
      return result.success
1593 
    if result.ex is not None:
1594 
      raise result.ex
1595 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getOrdersInBatch failed: unknown result");
1596 
 
1597 
  def getOrderCount(self, statuses, warehouseId):
1598 
    """
1599 
    Returns the count of orders with the given statuses assigned to the given warehouse.
1600 
 
1601 
    Parameters:
1602 
     - statuses
1603 
     - warehouseId
1604 
    """
1605 
    self.send_getOrderCount(statuses, warehouseId)
1606 
    return self.recv_getOrderCount()
1607 
 
1608 
  def send_getOrderCount(self, statuses, warehouseId):
1609 
    self._oprot.writeMessageBegin('getOrderCount', TMessageType.CALL, self._seqid)
1610 
    args = getOrderCount_args()
1611 
    args.statuses = statuses
1612 
    args.warehouseId = warehouseId
1613 
    args.write(self._oprot)
1614 
    self._oprot.writeMessageEnd()
1615 
    self._oprot.trans.flush()
1616 
 
1617 
  def recv_getOrderCount(self, ):
1618 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1619 
    if mtype == TMessageType.EXCEPTION:
1620 
      x = TApplicationException()
1621 
      x.read(self._iprot)
1622 
      self._iprot.readMessageEnd()
1623 
      raise x
1624 
    result = getOrderCount_result()
1625 
    result.read(self._iprot)
1626 
    self._iprot.readMessageEnd()
1627 
    if result.success is not None:
1628 
      return result.success
1629 
    if result.ex is not None:
1630 
      raise result.ex
1631 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getOrderCount failed: unknown result");
1632 
 
999 varun.gupt 1633 
  def getOrdersByBillingDate(self, status, start_billing_date, end_billing_date, warehouse_id):
1634 
    """
1132 chandransh 1635 
    Returns orders within a range of their billing dates
3431 rajveer 1636 
 
999 varun.gupt 1637 
    Parameters:
1638 
     - status
1639 
     - start_billing_date
1640 
     - end_billing_date
1641 
     - warehouse_id
1642 
    """
1643 
    self.send_getOrdersByBillingDate(status, start_billing_date, end_billing_date, warehouse_id)
1644 
    return self.recv_getOrdersByBillingDate()
1645 
 
1646 
  def send_getOrdersByBillingDate(self, status, start_billing_date, end_billing_date, warehouse_id):
1647 
    self._oprot.writeMessageBegin('getOrdersByBillingDate', TMessageType.CALL, self._seqid)
1648 
    args = getOrdersByBillingDate_args()
1649 
    args.status = status
1650 
    args.start_billing_date = start_billing_date
1651 
    args.end_billing_date = end_billing_date
1652 
    args.warehouse_id = warehouse_id
1653 
    args.write(self._oprot)
1654 
    self._oprot.writeMessageEnd()
1655 
    self._oprot.trans.flush()
1656 
 
1657 
  def recv_getOrdersByBillingDate(self, ):
1658 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1659 
    if mtype == TMessageType.EXCEPTION:
1660 
      x = TApplicationException()
1661 
      x.read(self._iprot)
1662 
      self._iprot.readMessageEnd()
1663 
      raise x
1664 
    result = getOrdersByBillingDate_result()
1665 
    result.read(self._iprot)
1666 
    self._iprot.readMessageEnd()
3431 rajveer 1667 
    if result.success is not None:
999 varun.gupt 1668 
      return result.success
3431 rajveer 1669 
    if result.ex is not None:
999 varun.gupt 1670 
      raise result.ex
1671 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getOrdersByBillingDate failed: unknown result");
1672 
 
3451 chandransh 1673 
  def getOrdersByShippingDate(self, fromShippingDate, toShippingDate, providerId, warehouseId, cod):
3427 chandransh 1674 
    """
1675 
    Returns orders for a particular provider and warehouse which were shipped between the given dates.
3451 chandransh 1676 
    Returned orders comprise of COD orders if cod parameter is true. It comprises of prepaid orders otherwise.
1677 
    Pass providerId and warehouseId as -1 to ignore both these parameters.
3431 rajveer 1678 
 
3427 chandransh 1679 
    Parameters:
1680 
     - fromShippingDate
1681 
     - toShippingDate
1682 
     - providerId
1683 
     - warehouseId
3451 chandransh 1684 
     - cod
3427 chandransh 1685 
    """
3451 chandransh 1686 
    self.send_getOrdersByShippingDate(fromShippingDate, toShippingDate, providerId, warehouseId, cod)
3427 chandransh 1687 
    return self.recv_getOrdersByShippingDate()
1688 
 
3451 chandransh 1689 
  def send_getOrdersByShippingDate(self, fromShippingDate, toShippingDate, providerId, warehouseId, cod):
3427 chandransh 1690 
    self._oprot.writeMessageBegin('getOrdersByShippingDate', TMessageType.CALL, self._seqid)
1691 
    args = getOrdersByShippingDate_args()
1692 
    args.fromShippingDate = fromShippingDate
1693 
    args.toShippingDate = toShippingDate
1694 
    args.providerId = providerId
1695 
    args.warehouseId = warehouseId
3451 chandransh 1696 
    args.cod = cod
3427 chandransh 1697 
    args.write(self._oprot)
1698 
    self._oprot.writeMessageEnd()
1699 
    self._oprot.trans.flush()
1700 
 
1701 
  def recv_getOrdersByShippingDate(self, ):
1702 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1703 
    if mtype == TMessageType.EXCEPTION:
1704 
      x = TApplicationException()
1705 
      x.read(self._iprot)
1706 
      self._iprot.readMessageEnd()
1707 
      raise x
1708 
    result = getOrdersByShippingDate_result()
1709 
    result.read(self._iprot)
1710 
    self._iprot.readMessageEnd()
3431 rajveer 1711 
    if result.success is not None:
3427 chandransh 1712 
      return result.success
3431 rajveer 1713 
    if result.ex is not None:
3427 chandransh 1714 
      raise result.ex
1715 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getOrdersByShippingDate failed: unknown result");
1716 
 
1382 varun.gupt 1717 
  def getReturnableOrdersForCustomer(self, customer_id, limit):
1718 
    """
1719 
    Returns order ids for orders which can be returned
3431 rajveer 1720 
 
1382 varun.gupt 1721 
    Parameters:
1722 
     - customer_id
1723 
     - limit
1724 
    """
1725 
    self.send_getReturnableOrdersForCustomer(customer_id, limit)
1726 
    return self.recv_getReturnableOrdersForCustomer()
1727 
 
1728 
  def send_getReturnableOrdersForCustomer(self, customer_id, limit):
1729 
    self._oprot.writeMessageBegin('getReturnableOrdersForCustomer', TMessageType.CALL, self._seqid)
1730 
    args = getReturnableOrdersForCustomer_args()
1731 
    args.customer_id = customer_id
1732 
    args.limit = limit
1733 
    args.write(self._oprot)
1734 
    self._oprot.writeMessageEnd()
1735 
    self._oprot.trans.flush()
1736 
 
1737 
  def recv_getReturnableOrdersForCustomer(self, ):
1738 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1739 
    if mtype == TMessageType.EXCEPTION:
1740 
      x = TApplicationException()
1741 
      x.read(self._iprot)
1742 
      self._iprot.readMessageEnd()
1743 
      raise x
1744 
    result = getReturnableOrdersForCustomer_result()
1745 
    result.read(self._iprot)
1746 
    self._iprot.readMessageEnd()
3431 rajveer 1747 
    if result.success is not None:
1382 varun.gupt 1748 
      return result.success
3431 rajveer 1749 
    if result.ex is not None:
1382 varun.gupt 1750 
      raise result.ex
1751 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getReturnableOrdersForCustomer failed: unknown result");
1752 
 
1753 
  def getCancellableOrdersForCustomer(self, customer_id, limit):
1754 
    """
1755 
    Returns order ids for orders which can be cancelled
3431 rajveer 1756 
 
1382 varun.gupt 1757 
    Parameters:
1758 
     - customer_id
1759 
     - limit
1760 
    """
1761 
    self.send_getCancellableOrdersForCustomer(customer_id, limit)
1762 
    return self.recv_getCancellableOrdersForCustomer()
1763 
 
1764 
  def send_getCancellableOrdersForCustomer(self, customer_id, limit):
1765 
    self._oprot.writeMessageBegin('getCancellableOrdersForCustomer', TMessageType.CALL, self._seqid)
1766 
    args = getCancellableOrdersForCustomer_args()
1767 
    args.customer_id = customer_id
1768 
    args.limit = limit
1769 
    args.write(self._oprot)
1770 
    self._oprot.writeMessageEnd()
1771 
    self._oprot.trans.flush()
1772 
 
1773 
  def recv_getCancellableOrdersForCustomer(self, ):
1774 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1775 
    if mtype == TMessageType.EXCEPTION:
1776 
      x = TApplicationException()
1777 
      x.read(self._iprot)
1778 
      self._iprot.readMessageEnd()
1779 
      raise x
1780 
    result = getCancellableOrdersForCustomer_result()
1781 
    result.read(self._iprot)
1782 
    self._iprot.readMessageEnd()
3431 rajveer 1783 
    if result.success is not None:
1382 varun.gupt 1784 
      return result.success
3431 rajveer 1785 
    if result.ex is not None:
1382 varun.gupt 1786 
      raise result.ex
1787 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getCancellableOrdersForCustomer failed: unknown result");
1788 
 
483 rajveer 1789 
  def changeOrderStatus(self, orderId, status, description):
94 ashish 1790 
    """
1791 
    Parameters:
483 rajveer 1792 
     - orderId
1793 
     - status
1794 
     - description
94 ashish 1795 
    """
483 rajveer 1796 
    self.send_changeOrderStatus(orderId, status, description)
1797 
    return self.recv_changeOrderStatus()
94 ashish 1798 
 
483 rajveer 1799 
  def send_changeOrderStatus(self, orderId, status, description):
1800 
    self._oprot.writeMessageBegin('changeOrderStatus', TMessageType.CALL, self._seqid)
1801 
    args = changeOrderStatus_args()
1802 
    args.orderId = orderId
1803 
    args.status = status
1804 
    args.description = description
94 ashish 1805 
    args.write(self._oprot)
1806 
    self._oprot.writeMessageEnd()
1807 
    self._oprot.trans.flush()
1808 
 
483 rajveer 1809 
  def recv_changeOrderStatus(self, ):
94 ashish 1810 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1811 
    if mtype == TMessageType.EXCEPTION:
1812 
      x = TApplicationException()
1813 
      x.read(self._iprot)
1814 
      self._iprot.readMessageEnd()
1815 
      raise x
483 rajveer 1816 
    result = changeOrderStatus_result()
94 ashish 1817 
    result.read(self._iprot)
1818 
    self._iprot.readMessageEnd()
3431 rajveer 1819 
    if result.success is not None:
94 ashish 1820 
      return result.success
3431 rajveer 1821 
    if result.ex is not None:
94 ashish 1822 
      raise result.ex
483 rajveer 1823 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "changeOrderStatus failed: unknown result");
94 ashish 1824 
 
1528 ankur.sing 1825 
  def getOrdersForTransaction(self, transactionId, customerId):
94 ashish 1826 
    """
1528 ankur.sing 1827 
    Returns list of orders for given transaction Id. Also filters based on customer Id so that
1828 
    only user who owns the transaction can view its order details.
3431 rajveer 1829 
 
94 ashish 1830 
    Parameters:
1831 
     - transactionId
1528 ankur.sing 1832 
     - customerId
94 ashish 1833 
    """
1528 ankur.sing 1834 
    self.send_getOrdersForTransaction(transactionId, customerId)
483 rajveer 1835 
    return self.recv_getOrdersForTransaction()
94 ashish 1836 
 
1528 ankur.sing 1837 
  def send_getOrdersForTransaction(self, transactionId, customerId):
483 rajveer 1838 
    self._oprot.writeMessageBegin('getOrdersForTransaction', TMessageType.CALL, self._seqid)
1839 
    args = getOrdersForTransaction_args()
94 ashish 1840 
    args.transactionId = transactionId
1528 ankur.sing 1841 
    args.customerId = customerId
94 ashish 1842 
    args.write(self._oprot)
1843 
    self._oprot.writeMessageEnd()
1844 
    self._oprot.trans.flush()
1845 
 
483 rajveer 1846 
  def recv_getOrdersForTransaction(self, ):
94 ashish 1847 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1848 
    if mtype == TMessageType.EXCEPTION:
1849 
      x = TApplicationException()
1850 
      x.read(self._iprot)
1851 
      self._iprot.readMessageEnd()
1852 
      raise x
483 rajveer 1853 
    result = getOrdersForTransaction_result()
94 ashish 1854 
    result.read(self._iprot)
1855 
    self._iprot.readMessageEnd()
3431 rajveer 1856 
    if result.success is not None:
94 ashish 1857 
      return result.success
3431 rajveer 1858 
    if result.ex is not None:
94 ashish 1859 
      raise result.ex
483 rajveer 1860 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getOrdersForTransaction failed: unknown result");
94 ashish 1861 
 
3014 chandransh 1862 
  def getOrdersForCustomer(self, customerId, from_date, to_date, statuses):
94 ashish 1863 
    """
3014 chandransh 1864 
    Returns list of orders for the given customer created between the given dates and having the given statuses.
1865 
    Pass and empty list to ignore filtering on statuses.
3431 rajveer 1866 
 
94 ashish 1867 
    Parameters:
483 rajveer 1868 
     - customerId
1869 
     - from_date
1870 
     - to_date
3014 chandransh 1871 
     - statuses
94 ashish 1872 
    """
3014 chandransh 1873 
    self.send_getOrdersForCustomer(customerId, from_date, to_date, statuses)
483 rajveer 1874 
    return self.recv_getOrdersForCustomer()
94 ashish 1875 
 
3014 chandransh 1876 
  def send_getOrdersForCustomer(self, customerId, from_date, to_date, statuses):
483 rajveer 1877 
    self._oprot.writeMessageBegin('getOrdersForCustomer', TMessageType.CALL, self._seqid)
1878 
    args = getOrdersForCustomer_args()
1879 
    args.customerId = customerId
1880 
    args.from_date = from_date
1881 
    args.to_date = to_date
3014 chandransh 1882 
    args.statuses = statuses
94 ashish 1883 
    args.write(self._oprot)
1884 
    self._oprot.writeMessageEnd()
1885 
    self._oprot.trans.flush()
1886 
 
483 rajveer 1887 
  def recv_getOrdersForCustomer(self, ):
94 ashish 1888 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1889 
    if mtype == TMessageType.EXCEPTION:
1890 
      x = TApplicationException()
1891 
      x.read(self._iprot)
1892 
      self._iprot.readMessageEnd()
1893 
      raise x
483 rajveer 1894 
    result = getOrdersForCustomer_result()
94 ashish 1895 
    result.read(self._iprot)
1896 
    self._iprot.readMessageEnd()
3431 rajveer 1897 
    if result.success is not None:
94 ashish 1898 
      return result.success
3431 rajveer 1899 
    if result.ex is not None:
94 ashish 1900 
      raise result.ex
483 rajveer 1901 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getOrdersForCustomer failed: unknown result");
94 ashish 1902 
 
483 rajveer 1903 
  def createOrder(self, order):
94 ashish 1904 
    """
1905 
    Parameters:
483 rajveer 1906 
     - order
94 ashish 1907 
    """
483 rajveer 1908 
    self.send_createOrder(order)
1909 
    return self.recv_createOrder()
94 ashish 1910 
 
483 rajveer 1911 
  def send_createOrder(self, order):
1912 
    self._oprot.writeMessageBegin('createOrder', TMessageType.CALL, self._seqid)
1913 
    args = createOrder_args()
1914 
    args.order = order
94 ashish 1915 
    args.write(self._oprot)
1916 
    self._oprot.writeMessageEnd()
1917 
    self._oprot.trans.flush()
1918 
 
483 rajveer 1919 
  def recv_createOrder(self, ):
94 ashish 1920 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1921 
    if mtype == TMessageType.EXCEPTION:
1922 
      x = TApplicationException()
1923 
      x.read(self._iprot)
1924 
      self._iprot.readMessageEnd()
1925 
      raise x
483 rajveer 1926 
    result = createOrder_result()
94 ashish 1927 
    result.read(self._iprot)
1928 
    self._iprot.readMessageEnd()
3431 rajveer 1929 
    if result.success is not None:
94 ashish 1930 
      return result.success
3431 rajveer 1931 
    if result.ex is not None:
94 ashish 1932 
      raise result.ex
483 rajveer 1933 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "createOrder failed: unknown result");
94 ashish 1934 
 
483 rajveer 1935 
  def getOrder(self, id):
94 ashish 1936 
    """
1937 
    Parameters:
483 rajveer 1938 
     - id
94 ashish 1939 
    """
483 rajveer 1940 
    self.send_getOrder(id)
1941 
    return self.recv_getOrder()
94 ashish 1942 
 
483 rajveer 1943 
  def send_getOrder(self, id):
1944 
    self._oprot.writeMessageBegin('getOrder', TMessageType.CALL, self._seqid)
1945 
    args = getOrder_args()
1946 
    args.id = id
94 ashish 1947 
    args.write(self._oprot)
1948 
    self._oprot.writeMessageEnd()
1949 
    self._oprot.trans.flush()
1950 
 
483 rajveer 1951 
  def recv_getOrder(self, ):
94 ashish 1952 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1953 
    if mtype == TMessageType.EXCEPTION:
1954 
      x = TApplicationException()
1955 
      x.read(self._iprot)
1956 
      self._iprot.readMessageEnd()
1957 
      raise x
483 rajveer 1958 
    result = getOrder_result()
94 ashish 1959 
    result.read(self._iprot)
1960 
    self._iprot.readMessageEnd()
3431 rajveer 1961 
    if result.success is not None:
94 ashish 1962 
      return result.success
3431 rajveer 1963 
    if result.ex is not None:
94 ashish 1964 
      raise result.ex
483 rajveer 1965 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getOrder failed: unknown result");
94 ashish 1966 
 
483 rajveer 1967 
  def getLineItemsForOrder(self, orderId):
94 ashish 1968 
    """
1969 
    Parameters:
483 rajveer 1970 
     - orderId
94 ashish 1971 
    """
483 rajveer 1972 
    self.send_getLineItemsForOrder(orderId)
1973 
    return self.recv_getLineItemsForOrder()
94 ashish 1974 
 
483 rajveer 1975 
  def send_getLineItemsForOrder(self, orderId):
1976 
    self._oprot.writeMessageBegin('getLineItemsForOrder', TMessageType.CALL, self._seqid)
1977 
    args = getLineItemsForOrder_args()
1978 
    args.orderId = orderId
94 ashish 1979 
    args.write(self._oprot)
1980 
    self._oprot.writeMessageEnd()
1981 
    self._oprot.trans.flush()
1982 
 
483 rajveer 1983 
  def recv_getLineItemsForOrder(self, ):
94 ashish 1984 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1985 
    if mtype == TMessageType.EXCEPTION:
1986 
      x = TApplicationException()
1987 
      x.read(self._iprot)
1988 
      self._iprot.readMessageEnd()
1989 
      raise x
483 rajveer 1990 
    result = getLineItemsForOrder_result()
94 ashish 1991 
    result.read(self._iprot)
1992 
    self._iprot.readMessageEnd()
3431 rajveer 1993 
    if result.success is not None:
94 ashish 1994 
      return result.success
3431 rajveer 1995 
    if result.ex is not None:
94 ashish 1996 
      raise result.ex
483 rajveer 1997 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getLineItemsForOrder failed: unknown result");
94 ashish 1998 
 
4999 phani.kuma 1999 
  def getOrderList(self, order_ids):
2000 
    """
2001 
    Parameters:
2002 
     - order_ids
2003 
    """
2004 
    self.send_getOrderList(order_ids)
2005 
    return self.recv_getOrderList()
2006 
 
2007 
  def send_getOrderList(self, order_ids):
2008 
    self._oprot.writeMessageBegin('getOrderList', TMessageType.CALL, self._seqid)
2009 
    args = getOrderList_args()
2010 
    args.order_ids = order_ids
2011 
    args.write(self._oprot)
2012 
    self._oprot.writeMessageEnd()
2013 
    self._oprot.trans.flush()
2014 
 
2015 
  def recv_getOrderList(self, ):
2016 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2017 
    if mtype == TMessageType.EXCEPTION:
2018 
      x = TApplicationException()
2019 
      x.read(self._iprot)
2020 
      self._iprot.readMessageEnd()
2021 
      raise x
2022 
    result = getOrderList_result()
2023 
    result.read(self._iprot)
2024 
    self._iprot.readMessageEnd()
2025 
    if result.success is not None:
2026 
      return result.success
2027 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getOrderList failed: unknown result");
2028 
 
5386 phani.kuma 2029 
  def getOrderListForVendor(self, order_ids, vendorId):
2030 
    """
2031 
    Parameters:
2032 
     - order_ids
2033 
     - vendorId
2034 
    """
2035 
    self.send_getOrderListForVendor(order_ids, vendorId)
2036 
    return self.recv_getOrderListForVendor()
2037 
 
2038 
  def send_getOrderListForVendor(self, order_ids, vendorId):
2039 
    self._oprot.writeMessageBegin('getOrderListForVendor', TMessageType.CALL, self._seqid)
2040 
    args = getOrderListForVendor_args()
2041 
    args.order_ids = order_ids
2042 
    args.vendorId = vendorId
2043 
    args.write(self._oprot)
2044 
    self._oprot.writeMessageEnd()
2045 
    self._oprot.trans.flush()
2046 
 
2047 
  def recv_getOrderListForVendor(self, ):
2048 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2049 
    if mtype == TMessageType.EXCEPTION:
2050 
      x = TApplicationException()
2051 
      x.read(self._iprot)
2052 
      self._iprot.readMessageEnd()
2053 
      raise x
2054 
    result = getOrderListForVendor_result()
2055 
    result.read(self._iprot)
2056 
    self._iprot.readMessageEnd()
2057 
    if result.success is not None:
2058 
      return result.success
2059 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getOrderListForVendor failed: unknown result");
2060 
 
1528 ankur.sing 2061 
  def getOrderForCustomer(self, orderId, customerId):
2062 
    """
2063 
    Returns an order for the order Id. Also checks if the order belongs to the customer whose Id is passed.
2064 
    Throws exception if either order Id is invalid or order does not below to the customer whose Id is passed.
3431 rajveer 2065 
 
1528 ankur.sing 2066 
    Parameters:
2067 
     - orderId
2068 
     - customerId
2069 
    """
2070 
    self.send_getOrderForCustomer(orderId, customerId)
2071 
    return self.recv_getOrderForCustomer()
2072 
 
2073 
  def send_getOrderForCustomer(self, orderId, customerId):
2074 
    self._oprot.writeMessageBegin('getOrderForCustomer', TMessageType.CALL, self._seqid)
2075 
    args = getOrderForCustomer_args()
2076 
    args.orderId = orderId
2077 
    args.customerId = customerId
2078 
    args.write(self._oprot)
2079 
    self._oprot.writeMessageEnd()
2080 
    self._oprot.trans.flush()
2081 
 
2082 
  def recv_getOrderForCustomer(self, ):
2083 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2084 
    if mtype == TMessageType.EXCEPTION:
2085 
      x = TApplicationException()
2086 
      x.read(self._iprot)
2087 
      self._iprot.readMessageEnd()
2088 
      raise x
2089 
    result = getOrderForCustomer_result()
2090 
    result.read(self._iprot)
2091 
    self._iprot.readMessageEnd()
3431 rajveer 2092 
    if result.success is not None:
1528 ankur.sing 2093 
      return result.success
3431 rajveer 2094 
    if result.ex is not None:
1528 ankur.sing 2095 
      raise result.ex
2096 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getOrderForCustomer failed: unknown result");
2097 
 
4444 rajveer 2098 
  def getAlerts(self, type, warehouseId, status, timestamp):
3064 chandransh 2099 
    """
2100 
    Parameters:
4394 rajveer 2101 
     - type
4444 rajveer 2102 
     - warehouseId
4394 rajveer 2103 
     - status
2104 
     - timestamp
3064 chandransh 2105 
    """
4444 rajveer 2106 
    self.send_getAlerts(type, warehouseId, status, timestamp)
3064 chandransh 2107 
    return self.recv_getAlerts()
2108 
 
4444 rajveer 2109 
  def send_getAlerts(self, type, warehouseId, status, timestamp):
3064 chandransh 2110 
    self._oprot.writeMessageBegin('getAlerts', TMessageType.CALL, self._seqid)
2111 
    args = getAlerts_args()
4394 rajveer 2112 
    args.type = type
4444 rajveer 2113 
    args.warehouseId = warehouseId
4394 rajveer 2114 
    args.status = status
2115 
    args.timestamp = timestamp
3064 chandransh 2116 
    args.write(self._oprot)
2117 
    self._oprot.writeMessageEnd()
2118 
    self._oprot.trans.flush()
2119 
 
2120 
  def recv_getAlerts(self, ):
2121 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2122 
    if mtype == TMessageType.EXCEPTION:
2123 
      x = TApplicationException()
2124 
      x.read(self._iprot)
2125 
      self._iprot.readMessageEnd()
2126 
      raise x
2127 
    result = getAlerts_result()
2128 
    result.read(self._iprot)
2129 
    self._iprot.readMessageEnd()
3431 rajveer 2130 
    if result.success is not None:
3064 chandransh 2131 
      return result.success
2132 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAlerts failed: unknown result");
2133 
 
4444 rajveer 2134 
  def addAlert(self, type, warehouseId, description):
3064 chandransh 2135 
    """
2136 
    Parameters:
2137 
     - type
4444 rajveer 2138 
     - warehouseId
4394 rajveer 2139 
     - description
3064 chandransh 2140 
    """
4444 rajveer 2141 
    self.send_addAlert(type, warehouseId, description)
4394 rajveer 2142 
    self.recv_addAlert()
3064 chandransh 2143 
 
4444 rajveer 2144 
  def send_addAlert(self, type, warehouseId, description):
4394 rajveer 2145 
    self._oprot.writeMessageBegin('addAlert', TMessageType.CALL, self._seqid)
2146 
    args = addAlert_args()
3064 chandransh 2147 
    args.type = type
4444 rajveer 2148 
    args.warehouseId = warehouseId
4394 rajveer 2149 
    args.description = description
3064 chandransh 2150 
    args.write(self._oprot)
2151 
    self._oprot.writeMessageEnd()
2152 
    self._oprot.trans.flush()
2153 
 
4394 rajveer 2154 
  def recv_addAlert(self, ):
3064 chandransh 2155 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2156 
    if mtype == TMessageType.EXCEPTION:
2157 
      x = TApplicationException()
2158 
      x.read(self._iprot)
2159 
      self._iprot.readMessageEnd()
2160 
      raise x
4394 rajveer 2161 
    result = addAlert_result()
3064 chandransh 2162 
    result.read(self._iprot)
2163 
    self._iprot.readMessageEnd()
2164 
    return
2165 
 
4444 rajveer 2166 
  def markAlertsAsSeen(self, warehouseId):
2167 
    """
2168 
    Parameters:
2169 
     - warehouseId
2170 
    """
2171 
    self.send_markAlertsAsSeen(warehouseId)
2172 
    self.recv_markAlertsAsSeen()
2173 
 
2174 
  def send_markAlertsAsSeen(self, warehouseId):
2175 
    self._oprot.writeMessageBegin('markAlertsAsSeen', TMessageType.CALL, self._seqid)
2176 
    args = markAlertsAsSeen_args()
2177 
    args.warehouseId = warehouseId
2178 
    args.write(self._oprot)
2179 
    self._oprot.writeMessageEnd()
2180 
    self._oprot.trans.flush()
2181 
 
2182 
  def recv_markAlertsAsSeen(self, ):
2183 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2184 
    if mtype == TMessageType.EXCEPTION:
2185 
      x = TApplicationException()
2186 
      x.read(self._iprot)
2187 
      self._iprot.readMessageEnd()
2188 
      raise x
2189 
    result = markAlertsAsSeen_result()
2190 
    result.read(self._iprot)
2191 
    self._iprot.readMessageEnd()
2192 
    return
2193 
 
3064 chandransh 2194 
  def getValidOrderCount(self, ):
2195 
    """
2196 
    Return the number of valid orders. (OrderStatus >= OrderStatus.SUBMITTED_FOR_PROCESSING)
2197 
    """
2198 
    self.send_getValidOrderCount()
2199 
    return self.recv_getValidOrderCount()
2200 
 
2201 
  def send_getValidOrderCount(self, ):
2202 
    self._oprot.writeMessageBegin('getValidOrderCount', TMessageType.CALL, self._seqid)
2203 
    args = getValidOrderCount_args()
2204 
    args.write(self._oprot)
2205 
    self._oprot.writeMessageEnd()
2206 
    self._oprot.trans.flush()
2207 
 
2208 
  def recv_getValidOrderCount(self, ):
2209 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2210 
    if mtype == TMessageType.EXCEPTION:
2211 
      x = TApplicationException()
2212 
      x.read(self._iprot)
2213 
      self._iprot.readMessageEnd()
2214 
      raise x
2215 
    result = getValidOrderCount_result()
2216 
    result.read(self._iprot)
2217 
    self._iprot.readMessageEnd()
3431 rajveer 2218 
    if result.success is not None:
3064 chandransh 2219 
      return result.success
2220 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getValidOrderCount failed: unknown result");
2221 
 
2222 
  def getNoOfCustomersWithSuccessfulTransaction(self, ):
2223 
    """
2224 
    Returns the number of distinct customers who have done successful transactions
2225 
    """
2226 
    self.send_getNoOfCustomersWithSuccessfulTransaction()
2227 
    return self.recv_getNoOfCustomersWithSuccessfulTransaction()
2228 
 
2229 
  def send_getNoOfCustomersWithSuccessfulTransaction(self, ):
2230 
    self._oprot.writeMessageBegin('getNoOfCustomersWithSuccessfulTransaction', TMessageType.CALL, self._seqid)
2231 
    args = getNoOfCustomersWithSuccessfulTransaction_args()
2232 
    args.write(self._oprot)
2233 
    self._oprot.writeMessageEnd()
2234 
    self._oprot.trans.flush()
2235 
 
2236 
  def recv_getNoOfCustomersWithSuccessfulTransaction(self, ):
2237 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2238 
    if mtype == TMessageType.EXCEPTION:
2239 
      x = TApplicationException()
2240 
      x.read(self._iprot)
2241 
      self._iprot.readMessageEnd()
2242 
      raise x
2243 
    result = getNoOfCustomersWithSuccessfulTransaction_result()
2244 
    result.read(self._iprot)
2245 
    self._iprot.readMessageEnd()
3431 rajveer 2246 
    if result.success is not None:
3064 chandransh 2247 
      return result.success
2248 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getNoOfCustomersWithSuccessfulTransaction failed: unknown result");
2249 
 
2250 
  def getValidOrdersAmountRange(self, ):
2251 
    """
2252 
    Returns the minimum and maximum amounts of a valid order. (OrderStatus >= OrderStatus.SUBMITTED_FOR_PROCESSING)
2253 
    List contains two values, first minimum amount and second maximum amount.
2254 
    """
2255 
    self.send_getValidOrdersAmountRange()
2256 
    return self.recv_getValidOrdersAmountRange()
2257 
 
2258 
  def send_getValidOrdersAmountRange(self, ):
2259 
    self._oprot.writeMessageBegin('getValidOrdersAmountRange', TMessageType.CALL, self._seqid)
2260 
    args = getValidOrdersAmountRange_args()
2261 
    args.write(self._oprot)
2262 
    self._oprot.writeMessageEnd()
2263 
    self._oprot.trans.flush()
2264 
 
2265 
  def recv_getValidOrdersAmountRange(self, ):
2266 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2267 
    if mtype == TMessageType.EXCEPTION:
2268 
      x = TApplicationException()
2269 
      x.read(self._iprot)
2270 
      self._iprot.readMessageEnd()
2271 
      raise x
2272 
    result = getValidOrdersAmountRange_result()
2273 
    result.read(self._iprot)
2274 
    self._iprot.readMessageEnd()
3431 rajveer 2275 
    if result.success is not None:
3064 chandransh 2276 
      return result.success
2277 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getValidOrdersAmountRange failed: unknown result");
2278 
 
5874 rajveer 2279 
  def getValidOrders(self, limit, onlyStore):
3064 chandransh 2280 
    """
2281 
    Returns list of Orders in descending order by Order creation date. List is restricted to limit Orders.
2282 
    If limit is passed as 0, then all valid Orders are returned.
3431 rajveer 2283 
 
3064 chandransh 2284 
    Parameters:
2285 
     - limit
5874 rajveer 2286 
     - onlyStore
3064 chandransh 2287 
    """
5874 rajveer 2288 
    self.send_getValidOrders(limit, onlyStore)
3064 chandransh 2289 
    return self.recv_getValidOrders()
2290 
 
5874 rajveer 2291 
  def send_getValidOrders(self, limit, onlyStore):
3064 chandransh 2292 
    self._oprot.writeMessageBegin('getValidOrders', TMessageType.CALL, self._seqid)
2293 
    args = getValidOrders_args()
2294 
    args.limit = limit
5874 rajveer 2295 
    args.onlyStore = onlyStore
3064 chandransh 2296 
    args.write(self._oprot)
2297 
    self._oprot.writeMessageEnd()
2298 
    self._oprot.trans.flush()
2299 
 
2300 
  def recv_getValidOrders(self, ):
2301 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2302 
    if mtype == TMessageType.EXCEPTION:
2303 
      x = TApplicationException()
2304 
      x.read(self._iprot)
2305 
      self._iprot.readMessageEnd()
2306 
      raise x
2307 
    result = getValidOrders_result()
2308 
    result.read(self._iprot)
2309 
    self._iprot.readMessageEnd()
3431 rajveer 2310 
    if result.success is not None:
3064 chandransh 2311 
      return result.success
2312 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getValidOrders failed: unknown result");
2313 
 
1220 chandransh 2314 
  def batchOrders(self, warehouseId):
2315 
    """
2316 
    Create a batch of all the pending orders for the given warehouse.
2317 
    The returned list is orderd by created_timestamp.
2318 
    If there are no pending orders, an empty list is returned.
3431 rajveer 2319 
 
1220 chandransh 2320 
    Parameters:
2321 
     - warehouseId
2322 
    """
2323 
    self.send_batchOrders(warehouseId)
2324 
    return self.recv_batchOrders()
2325 
 
2326 
  def send_batchOrders(self, warehouseId):
2327 
    self._oprot.writeMessageBegin('batchOrders', TMessageType.CALL, self._seqid)
2328 
    args = batchOrders_args()
2329 
    args.warehouseId = warehouseId
2330 
    args.write(self._oprot)
2331 
    self._oprot.writeMessageEnd()
2332 
    self._oprot.trans.flush()
2333 
 
2334 
  def recv_batchOrders(self, ):
2335 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2336 
    if mtype == TMessageType.EXCEPTION:
2337 
      x = TApplicationException()
2338 
      x.read(self._iprot)
2339 
      self._iprot.readMessageEnd()
2340 
      raise x
2341 
    result = batchOrders_result()
2342 
    result.read(self._iprot)
2343 
    self._iprot.readMessageEnd()
3431 rajveer 2344 
    if result.success is not None:
1220 chandransh 2345 
      return result.success
3431 rajveer 2346 
    if result.ex is not None:
1220 chandransh 2347 
      raise result.ex
2348 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "batchOrders failed: unknown result");
2349 
 
1208 chandransh 2350 
  def markOrderAsOutOfStock(self, orderId):
2351 
    """
2352 
    Mark the given order as out of stock. Throws an exception if the order with the given Id couldn't be found.
3431 rajveer 2353 
 
1208 chandransh 2354 
    Parameters:
2355 
     - orderId
2356 
    """
2357 
    self.send_markOrderAsOutOfStock(orderId)
2358 
    return self.recv_markOrderAsOutOfStock()
2359 
 
2360 
  def send_markOrderAsOutOfStock(self, orderId):
2361 
    self._oprot.writeMessageBegin('markOrderAsOutOfStock', TMessageType.CALL, self._seqid)
2362 
    args = markOrderAsOutOfStock_args()
2363 
    args.orderId = orderId
2364 
    args.write(self._oprot)
2365 
    self._oprot.writeMessageEnd()
2366 
    self._oprot.trans.flush()
2367 
 
2368 
  def recv_markOrderAsOutOfStock(self, ):
2369 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2370 
    if mtype == TMessageType.EXCEPTION:
2371 
      x = TApplicationException()
2372 
      x.read(self._iprot)
2373 
      self._iprot.readMessageEnd()
2374 
      raise x
2375 
    result = markOrderAsOutOfStock_result()
2376 
    result.read(self._iprot)
2377 
    self._iprot.readMessageEnd()
3431 rajveer 2378 
    if result.success is not None:
1208 chandransh 2379 
      return result.success
3431 rajveer 2380 
    if result.ex is not None:
1208 chandransh 2381 
      raise result.ex
2382 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "markOrderAsOutOfStock failed: unknown result");
2383 
 
3064 chandransh 2384 
  def verifyOrder(self, orderId):
759 chandransh 2385 
    """
3064 chandransh 2386 
    Marks the given order as SUBMITTED_FOR_PROCESSING and updates the verified
2387 
    timestamp. It is intended to be used for COD orders but can be harmlessly
2388 
    used for all other orders as well.
2389 
    Throws an exception if no such order exists.
3431 rajveer 2390 
 
759 chandransh 2391 
    Parameters:
3064 chandransh 2392 
     - orderId
759 chandransh 2393 
    """
3064 chandransh 2394 
    self.send_verifyOrder(orderId)
2395 
    return self.recv_verifyOrder()
759 chandransh 2396 
 
3064 chandransh 2397 
  def send_verifyOrder(self, orderId):
2398 
    self._oprot.writeMessageBegin('verifyOrder', TMessageType.CALL, self._seqid)
2399 
    args = verifyOrder_args()
2400 
    args.orderId = orderId
759 chandransh 2401 
    args.write(self._oprot)
2402 
    self._oprot.writeMessageEnd()
2403 
    self._oprot.trans.flush()
2404 
 
3064 chandransh 2405 
  def recv_verifyOrder(self, ):
759 chandransh 2406 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2407 
    if mtype == TMessageType.EXCEPTION:
2408 
      x = TApplicationException()
2409 
      x.read(self._iprot)
2410 
      self._iprot.readMessageEnd()
2411 
      raise x
3064 chandransh 2412 
    result = verifyOrder_result()
759 chandransh 2413 
    result.read(self._iprot)
2414 
    self._iprot.readMessageEnd()
3431 rajveer 2415 
    if result.success is not None:
759 chandransh 2416 
      return result.success
3431 rajveer 2417 
    if result.ex is not None:
759 chandransh 2418 
      raise result.ex
3064 chandransh 2419 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "verifyOrder failed: unknown result");
759 chandransh 2420 
 
3064 chandransh 2421 
  def acceptOrder(self, orderId):
1113 chandransh 2422 
    """
3064 chandransh 2423 
    Marks the given order as ACCEPTED and updates the accepted timestamp. If the
2424 
    given order is not a COD order, it also captures the payment if the same has
2425 
    not been captured.
2426 
    Throws an exception if no such order exists.
3431 rajveer 2427 
 
1113 chandransh 2428 
    Parameters:
3064 chandransh 2429 
     - orderId
1113 chandransh 2430 
    """
3064 chandransh 2431 
    self.send_acceptOrder(orderId)
2432 
    return self.recv_acceptOrder()
1113 chandransh 2433 
 
3064 chandransh 2434 
  def send_acceptOrder(self, orderId):
2435 
    self._oprot.writeMessageBegin('acceptOrder', TMessageType.CALL, self._seqid)
2436 
    args = acceptOrder_args()
2437 
    args.orderId = orderId
1113 chandransh 2438 
    args.write(self._oprot)
2439 
    self._oprot.writeMessageEnd()
2440 
    self._oprot.trans.flush()
2441 
 
3064 chandransh 2442 
  def recv_acceptOrder(self, ):
1113 chandransh 2443 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2444 
    if mtype == TMessageType.EXCEPTION:
2445 
      x = TApplicationException()
2446 
      x.read(self._iprot)
2447 
      self._iprot.readMessageEnd()
2448 
      raise x
3064 chandransh 2449 
    result = acceptOrder_result()
1113 chandransh 2450 
    result.read(self._iprot)
2451 
    self._iprot.readMessageEnd()
3431 rajveer 2452 
    if result.success is not None:
1113 chandransh 2453 
      return result.success
3431 rajveer 2454 
    if result.ex is not None:
1113 chandransh 2455 
      raise result.ex
3064 chandransh 2456 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "acceptOrder failed: unknown result");
1113 chandransh 2457 
 
5110 mandeep.dh 2458 
  def addBillingDetails(self, orderId, invoice_number, serialNumber, itemNumber, billed_by, jacketNumber, billingType, fulfilmentWarehouseId, authorize):
1132 chandransh 2459 
    """
3064 chandransh 2460 
    Add billing details such as the bill number and the biller to the Order.
4658 mandeep.dh 2461 
    Adds jacket number, item number and Serial no. to the order. Doesn't update
4283 anupam.sin 2462 
    the IMEI no. if a -1 is supplied.
2463 
    Also, it generates an invoice number for the order, marks the order as
2464 
    BILLED and sets the billing timestamp.
2465 
    Returns false if it doesn't find the order with the given ID.
3431 rajveer 2466 
 
1135 chandransh 2467 
    Parameters:
3064 chandransh 2468 
     - orderId
2469 
     - invoice_number
4658 mandeep.dh 2470 
     - serialNumber
4283 anupam.sin 2471 
     - itemNumber
3064 chandransh 2472 
     - billed_by
4264 rajveer 2473 
     - jacketNumber
4283 anupam.sin 2474 
     - billingType
5110 mandeep.dh 2475 
     - fulfilmentWarehouseId
4763 rajveer 2476 
     - authorize
1135 chandransh 2477 
    """
5110 mandeep.dh 2478 
    self.send_addBillingDetails(orderId, invoice_number, serialNumber, itemNumber, billed_by, jacketNumber, billingType, fulfilmentWarehouseId, authorize)
3064 chandransh 2479 
    return self.recv_addBillingDetails()
1135 chandransh 2480 
 
5110 mandeep.dh 2481 
  def send_addBillingDetails(self, orderId, invoice_number, serialNumber, itemNumber, billed_by, jacketNumber, billingType, fulfilmentWarehouseId, authorize):
3064 chandransh 2482 
    self._oprot.writeMessageBegin('addBillingDetails', TMessageType.CALL, self._seqid)
2483 
    args = addBillingDetails_args()
2484 
    args.orderId = orderId
2485 
    args.invoice_number = invoice_number
4658 mandeep.dh 2486 
    args.serialNumber = serialNumber
4283 anupam.sin 2487 
    args.itemNumber = itemNumber
3064 chandransh 2488 
    args.billed_by = billed_by
4264 rajveer 2489 
    args.jacketNumber = jacketNumber
4283 anupam.sin 2490 
    args.billingType = billingType
5110 mandeep.dh 2491 
    args.fulfilmentWarehouseId = fulfilmentWarehouseId
4763 rajveer 2492 
    args.authorize = authorize
1135 chandransh 2493 
    args.write(self._oprot)
2494 
    self._oprot.writeMessageEnd()
2495 
    self._oprot.trans.flush()
2496 
 
3064 chandransh 2497 
  def recv_addBillingDetails(self, ):
1135 chandransh 2498 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2499 
    if mtype == TMessageType.EXCEPTION:
2500 
      x = TApplicationException()
2501 
      x.read(self._iprot)
2502 
      self._iprot.readMessageEnd()
2503 
      raise x
3064 chandransh 2504 
    result = addBillingDetails_result()
1135 chandransh 2505 
    result.read(self._iprot)
2506 
    self._iprot.readMessageEnd()
3431 rajveer 2507 
    if result.success is not None:
3064 chandransh 2508 
      return result.success
3431 rajveer 2509 
    if result.ex is not None:
1135 chandransh 2510 
      raise result.ex
3064 chandransh 2511 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "addBillingDetails failed: unknown result");
1135 chandransh 2512 
 
4763 rajveer 2513 
  def addInvoiceNumber(self, orderId, invoiceNumber, color):
4579 rajveer 2514 
    """
2515 
    Add the invoice number to the order.
2516 
 
2517 
    Parameters:
2518 
     - orderId
2519 
     - invoiceNumber
4763 rajveer 2520 
     - color
4579 rajveer 2521 
    """
4763 rajveer 2522 
    self.send_addInvoiceNumber(orderId, invoiceNumber, color)
4579 rajveer 2523 
    self.recv_addInvoiceNumber()
2524 
 
4763 rajveer 2525 
  def send_addInvoiceNumber(self, orderId, invoiceNumber, color):
4579 rajveer 2526 
    self._oprot.writeMessageBegin('addInvoiceNumber', TMessageType.CALL, self._seqid)
2527 
    args = addInvoiceNumber_args()
2528 
    args.orderId = orderId
2529 
    args.invoiceNumber = invoiceNumber
4763 rajveer 2530 
    args.color = color
4579 rajveer 2531 
    args.write(self._oprot)
2532 
    self._oprot.writeMessageEnd()
2533 
    self._oprot.trans.flush()
2534 
 
2535 
  def recv_addInvoiceNumber(self, ):
2536 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2537 
    if mtype == TMessageType.EXCEPTION:
2538 
      x = TApplicationException()
2539 
      x.read(self._iprot)
2540 
      self._iprot.readMessageEnd()
2541 
      raise x
2542 
    result = addInvoiceNumber_result()
2543 
    result.read(self._iprot)
2544 
    self._iprot.readMessageEnd()
2545 
    if result.ex is not None:
2546 
      raise result.ex
2547 
    return
2548 
 
4910 phani.kuma 2549 
  def markOrdersAsShippedFromWarehouse(self, warehouseId, providerId, cod, orderIds):
1408 ankur.sing 2550 
    """
3064 chandransh 2551 
    Depending on the third parameter, marks either all prepaid or all cod orders BILLED by the
4910 phani.kuma 2552 
    given warehouse and were picked up by the given provider as SHIPPED_FROM_WH.
3431 rajveer 2553 
 
1408 ankur.sing 2554 
    Parameters:
3064 chandransh 2555 
     - warehouseId
1408 ankur.sing 2556 
     - providerId
3064 chandransh 2557 
     - cod
4910 phani.kuma 2558 
     - orderIds
1408 ankur.sing 2559 
    """
4910 phani.kuma 2560 
    self.send_markOrdersAsShippedFromWarehouse(warehouseId, providerId, cod, orderIds)
2561 
    return self.recv_markOrdersAsShippedFromWarehouse()
1408 ankur.sing 2562 
 
4910 phani.kuma 2563 
  def send_markOrdersAsShippedFromWarehouse(self, warehouseId, providerId, cod, orderIds):
2564 
    self._oprot.writeMessageBegin('markOrdersAsShippedFromWarehouse', TMessageType.CALL, self._seqid)
2565 
    args = markOrdersAsShippedFromWarehouse_args()
3064 chandransh 2566 
    args.warehouseId = warehouseId
1408 ankur.sing 2567 
    args.providerId = providerId
3064 chandransh 2568 
    args.cod = cod
4910 phani.kuma 2569 
    args.orderIds = orderIds
1408 ankur.sing 2570 
    args.write(self._oprot)
2571 
    self._oprot.writeMessageEnd()
2572 
    self._oprot.trans.flush()
2573 
 
4910 phani.kuma 2574 
  def recv_markOrdersAsShippedFromWarehouse(self, ):
1408 ankur.sing 2575 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2576 
    if mtype == TMessageType.EXCEPTION:
2577 
      x = TApplicationException()
2578 
      x.read(self._iprot)
2579 
      self._iprot.readMessageEnd()
2580 
      raise x
4910 phani.kuma 2581 
    result = markOrdersAsShippedFromWarehouse_result()
1408 ankur.sing 2582 
    result.read(self._iprot)
2583 
    self._iprot.readMessageEnd()
3431 rajveer 2584 
    if result.success is not None:
1408 ankur.sing 2585 
      return result.success
3431 rajveer 2586 
    if result.ex is not None:
3064 chandransh 2587 
      raise result.ex
4910 phani.kuma 2588 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "markOrdersAsShippedFromWarehouse failed: unknown result");
1408 ankur.sing 2589 
 
5713 rajveer 2590 
  def markOrdersAsReturnedFromStore(self, providerId, orderIds, awbs):
5676 rajveer 2591 
    """
2592 
    Parameters:
2593 
     - providerId
2594 
     - orderIds
5713 rajveer 2595 
     - awbs
5676 rajveer 2596 
    """
5713 rajveer 2597 
    self.send_markOrdersAsReturnedFromStore(providerId, orderIds, awbs)
5676 rajveer 2598 
    return self.recv_markOrdersAsReturnedFromStore()
2599 
 
5713 rajveer 2600 
  def send_markOrdersAsReturnedFromStore(self, providerId, orderIds, awbs):
5676 rajveer 2601 
    self._oprot.writeMessageBegin('markOrdersAsReturnedFromStore', TMessageType.CALL, self._seqid)
2602 
    args = markOrdersAsReturnedFromStore_args()
2603 
    args.providerId = providerId
2604 
    args.orderIds = orderIds
5713 rajveer 2605 
    args.awbs = awbs
5676 rajveer 2606 
    args.write(self._oprot)
2607 
    self._oprot.writeMessageEnd()
2608 
    self._oprot.trans.flush()
2609 
 
2610 
  def recv_markOrdersAsReturnedFromStore(self, ):
2611 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2612 
    if mtype == TMessageType.EXCEPTION:
2613 
      x = TApplicationException()
2614 
      x.read(self._iprot)
2615 
      self._iprot.readMessageEnd()
2616 
      raise x
2617 
    result = markOrdersAsReturnedFromStore_result()
2618 
    result.read(self._iprot)
2619 
    self._iprot.readMessageEnd()
2620 
    if result.success is not None:
2621 
      return result.success
2622 
    if result.ex is not None:
2623 
      raise result.ex
2624 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "markOrdersAsReturnedFromStore failed: unknown result");
2625 
 
4910 phani.kuma 2626 
  def markOrdersAsPickedUp(self, providerId, pickupDetails):
4410 rajveer 2627 
    """
4910 phani.kuma 2628 
    Marks all SHIPPED_FROM_WH orders of the previous day for a provider as SHIPPED_TO_LOGISTICS.
2629 
    Raises an exception if we encounter report for an AWB number that we did not ship.
4410 rajveer 2630 
 
2631 
    Parameters:
2632 
     - providerId
4910 phani.kuma 2633 
     - pickupDetails
4410 rajveer 2634 
    """
4910 phani.kuma 2635 
    self.send_markOrdersAsPickedUp(providerId, pickupDetails)
2636 
    self.recv_markOrdersAsPickedUp()
4410 rajveer 2637 
 
4910 phani.kuma 2638 
  def send_markOrdersAsPickedUp(self, providerId, pickupDetails):
2639 
    self._oprot.writeMessageBegin('markOrdersAsPickedUp', TMessageType.CALL, self._seqid)
2640 
    args = markOrdersAsPickedUp_args()
4410 rajveer 2641 
    args.providerId = providerId
4910 phani.kuma 2642 
    args.pickupDetails = pickupDetails
4410 rajveer 2643 
    args.write(self._oprot)
2644 
    self._oprot.writeMessageEnd()
2645 
    self._oprot.trans.flush()
2646 
 
4910 phani.kuma 2647 
  def recv_markOrdersAsPickedUp(self, ):
4410 rajveer 2648 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2649 
    if mtype == TMessageType.EXCEPTION:
2650 
      x = TApplicationException()
2651 
      x.read(self._iprot)
2652 
      self._iprot.readMessageEnd()
2653 
      raise x
4910 phani.kuma 2654 
    result = markOrdersAsPickedUp_result()
4410 rajveer 2655 
    result.read(self._iprot)
2656 
    self._iprot.readMessageEnd()
2657 
    if result.ex is not None:
2658 
      raise result.ex
4910 phani.kuma 2659 
    return
4410 rajveer 2660 
 
4910 phani.kuma 2661 
  def getOrdersNotPickedUp(self, providerId):
94 ashish 2662 
    """
3064 chandransh 2663 
    Returns a list of orders that were shipped from warehouse but did not appear in the pick-up report.
3431 rajveer 2664 
 
94 ashish 2665 
    Parameters:
3064 chandransh 2666 
     - providerId
304 ashish 2667 
    """
4910 phani.kuma 2668 
    self.send_getOrdersNotPickedUp(providerId)
2669 
    return self.recv_getOrdersNotPickedUp()
94 ashish 2670 
 
4910 phani.kuma 2671 
  def send_getOrdersNotPickedUp(self, providerId):
2672 
    self._oprot.writeMessageBegin('getOrdersNotPickedUp', TMessageType.CALL, self._seqid)
2673 
    args = getOrdersNotPickedUp_args()
3064 chandransh 2674 
    args.providerId = providerId
304 ashish 2675 
    args.write(self._oprot)
2676 
    self._oprot.writeMessageEnd()
2677 
    self._oprot.trans.flush()
2678 
 
4910 phani.kuma 2679 
  def recv_getOrdersNotPickedUp(self, ):
304 ashish 2680 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2681 
    if mtype == TMessageType.EXCEPTION:
2682 
      x = TApplicationException()
2683 
      x.read(self._iprot)
2684 
      self._iprot.readMessageEnd()
2685 
      raise x
4910 phani.kuma 2686 
    result = getOrdersNotPickedUp_result()
304 ashish 2687 
    result.read(self._iprot)
2688 
    self._iprot.readMessageEnd()
3431 rajveer 2689 
    if result.success is not None:
304 ashish 2690 
      return result.success
4910 phani.kuma 2691 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getOrdersNotPickedUp failed: unknown result");
304 ashish 2692 
 
3064 chandransh 2693 
  def markOrdersAsDelivered(self, providerId, deliveredOrders):
304 ashish 2694 
    """
3064 chandransh 2695 
    Marks all orders with AWBs in the given map as delivered. Also sets the delivery timestamp and
2696 
    the name of the receiver.
2697 
    Raises an exception if we encounter report for an AWB number that we did not ship.
3431 rajveer 2698 
 
304 ashish 2699 
    Parameters:
3064 chandransh 2700 
     - providerId
2701 
     - deliveredOrders
304 ashish 2702 
    """
3064 chandransh 2703 
    self.send_markOrdersAsDelivered(providerId, deliveredOrders)
2704 
    self.recv_markOrdersAsDelivered()
304 ashish 2705 
 
3064 chandransh 2706 
  def send_markOrdersAsDelivered(self, providerId, deliveredOrders):
2707 
    self._oprot.writeMessageBegin('markOrdersAsDelivered', TMessageType.CALL, self._seqid)
2708 
    args = markOrdersAsDelivered_args()
2709 
    args.providerId = providerId
2710 
    args.deliveredOrders = deliveredOrders
304 ashish 2711 
    args.write(self._oprot)
2712 
    self._oprot.writeMessageEnd()
2713 
    self._oprot.trans.flush()
2714 
 
3064 chandransh 2715 
  def recv_markOrdersAsDelivered(self, ):
304 ashish 2716 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2717 
    if mtype == TMessageType.EXCEPTION:
2718 
      x = TApplicationException()
2719 
      x.read(self._iprot)
2720 
      self._iprot.readMessageEnd()
2721 
      raise x
3064 chandransh 2722 
    result = markOrdersAsDelivered_result()
304 ashish 2723 
    result.read(self._iprot)
2724 
    self._iprot.readMessageEnd()
3431 rajveer 2725 
    if result.ex is not None:
3064 chandransh 2726 
      raise result.ex
304 ashish 2727 
    return
2728 
 
4910 phani.kuma 2729 
  def markAsRTOrders(self, providerId, returnedOrders):
1596 ankur.sing 2730 
    """
4910 phani.kuma 2731 
    Mark all orders with AWBs in the given map as RTO. Also sets the delivery timestamp.
3064 chandransh 2732 
    Raises an exception if we encounter report for an AWB number that we did not ship.
3431 rajveer 2733 
 
3064 chandransh 2734 
    Parameters:
2735 
     - providerId
2736 
     - returnedOrders
1596 ankur.sing 2737 
    """
4910 phani.kuma 2738 
    self.send_markAsRTOrders(providerId, returnedOrders)
2739 
    self.recv_markAsRTOrders()
304 ashish 2740 
 
4910 phani.kuma 2741 
  def send_markAsRTOrders(self, providerId, returnedOrders):
2742 
    self._oprot.writeMessageBegin('markAsRTOrders', TMessageType.CALL, self._seqid)
2743 
    args = markAsRTOrders_args()
3064 chandransh 2744 
    args.providerId = providerId
2745 
    args.returnedOrders = returnedOrders
1596 ankur.sing 2746 
    args.write(self._oprot)
2747 
    self._oprot.writeMessageEnd()
2748 
    self._oprot.trans.flush()
2749 
 
4910 phani.kuma 2750 
  def recv_markAsRTOrders(self, ):
1596 ankur.sing 2751 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2752 
    if mtype == TMessageType.EXCEPTION:
2753 
      x = TApplicationException()
2754 
      x.read(self._iprot)
2755 
      self._iprot.readMessageEnd()
2756 
      raise x
4910 phani.kuma 2757 
    result = markAsRTOrders_result()
1596 ankur.sing 2758 
    result.read(self._iprot)
2759 
    self._iprot.readMessageEnd()
3431 rajveer 2760 
    if result.ex is not None:
3064 chandransh 2761 
      raise result.ex
2762 
    return
1596 ankur.sing 2763 
 
4910 phani.kuma 2764 
  def getRTOrders(self, providerId):
2765 
    """
2766 
    Returns a list of orders that were returned by courier.
2767 
 
2768 
    Parameters:
2769 
     - providerId
2770 
    """
2771 
    self.send_getRTOrders(providerId)
2772 
    return self.recv_getRTOrders()
2773 
 
2774 
  def send_getRTOrders(self, providerId):
2775 
    self._oprot.writeMessageBegin('getRTOrders', TMessageType.CALL, self._seqid)
2776 
    args = getRTOrders_args()
2777 
    args.providerId = providerId
2778 
    args.write(self._oprot)
2779 
    self._oprot.writeMessageEnd()
2780 
    self._oprot.trans.flush()
2781 
 
2782 
  def recv_getRTOrders(self, ):
2783 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2784 
    if mtype == TMessageType.EXCEPTION:
2785 
      x = TApplicationException()
2786 
      x.read(self._iprot)
2787 
      self._iprot.readMessageEnd()
2788 
      raise x
2789 
    result = getRTOrders_result()
2790 
    result.read(self._iprot)
2791 
    self._iprot.readMessageEnd()
2792 
    if result.success is not None:
2793 
      return result.success
2794 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getRTOrders failed: unknown result");
2795 
 
3064 chandransh 2796 
  def updateNonDeliveryReason(self, providerId, undeliveredOrders):
1627 ankur.sing 2797 
    """
3064 chandransh 2798 
    Update the status description of orders whose AWB numbers are keys of the Map.
3431 rajveer 2799 
 
3064 chandransh 2800 
    Parameters:
2801 
     - providerId
2802 
     - undeliveredOrders
1627 ankur.sing 2803 
    """
3064 chandransh 2804 
    self.send_updateNonDeliveryReason(providerId, undeliveredOrders)
4910 phani.kuma 2805 
    self.recv_updateNonDeliveryReason()
1596 ankur.sing 2806 
 
3064 chandransh 2807 
  def send_updateNonDeliveryReason(self, providerId, undeliveredOrders):
2808 
    self._oprot.writeMessageBegin('updateNonDeliveryReason', TMessageType.CALL, self._seqid)
2809 
    args = updateNonDeliveryReason_args()
2810 
    args.providerId = providerId
2811 
    args.undeliveredOrders = undeliveredOrders
1627 ankur.sing 2812 
    args.write(self._oprot)
2813 
    self._oprot.writeMessageEnd()
2814 
    self._oprot.trans.flush()
2815 
 
3064 chandransh 2816 
  def recv_updateNonDeliveryReason(self, ):
1627 ankur.sing 2817 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2818 
    if mtype == TMessageType.EXCEPTION:
2819 
      x = TApplicationException()
2820 
      x.read(self._iprot)
2821 
      self._iprot.readMessageEnd()
2822 
      raise x
3064 chandransh 2823 
    result = updateNonDeliveryReason_result()
1627 ankur.sing 2824 
    result.read(self._iprot)
2825 
    self._iprot.readMessageEnd()
4910 phani.kuma 2826 
    if result.ex is not None:
2827 
      raise result.ex
2828 
    return
2829 
 
2830 
  def getNonDeliveredOrdersbyCourier(self, providerId):
2831 
    """
2832 
    Returns a list of orders that were picked up or shipped four days ago but did not get delivered.
2833 
 
2834 
    Parameters:
2835 
     - providerId
2836 
    """
2837 
    self.send_getNonDeliveredOrdersbyCourier(providerId)
2838 
    return self.recv_getNonDeliveredOrdersbyCourier()
2839 
 
2840 
  def send_getNonDeliveredOrdersbyCourier(self, providerId):
2841 
    self._oprot.writeMessageBegin('getNonDeliveredOrdersbyCourier', TMessageType.CALL, self._seqid)
2842 
    args = getNonDeliveredOrdersbyCourier_args()
2843 
    args.providerId = providerId
2844 
    args.write(self._oprot)
2845 
    self._oprot.writeMessageEnd()
2846 
    self._oprot.trans.flush()
2847 
 
2848 
  def recv_getNonDeliveredOrdersbyCourier(self, ):
2849 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2850 
    if mtype == TMessageType.EXCEPTION:
2851 
      x = TApplicationException()
2852 
      x.read(self._iprot)
2853 
      self._iprot.readMessageEnd()
2854 
      raise x
2855 
    result = getNonDeliveredOrdersbyCourier_result()
2856 
    result.read(self._iprot)
2857 
    self._iprot.readMessageEnd()
4581 phani.kuma 2858 
    if result.success is not None:
2859 
      return result.success
4910 phani.kuma 2860 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getNonDeliveredOrdersbyCourier failed: unknown result");
2861 
 
2862 
  def markOrdersAsLocalConnected(self, providerId, local_connected_orders):
2863 
    """
2864 
    Mark all orders with AWBs in the given map as local connected. Also sets the local connected timestamp.
2865 
 
2866 
    Parameters:
2867 
     - providerId
2868 
     - local_connected_orders
2869 
    """
2870 
    self.send_markOrdersAsLocalConnected(providerId, local_connected_orders)
2871 
    self.recv_markOrdersAsLocalConnected()
2872 
 
2873 
  def send_markOrdersAsLocalConnected(self, providerId, local_connected_orders):
2874 
    self._oprot.writeMessageBegin('markOrdersAsLocalConnected', TMessageType.CALL, self._seqid)
2875 
    args = markOrdersAsLocalConnected_args()
2876 
    args.providerId = providerId
2877 
    args.local_connected_orders = local_connected_orders
2878 
    args.write(self._oprot)
2879 
    self._oprot.writeMessageEnd()
2880 
    self._oprot.trans.flush()
2881 
 
2882 
  def recv_markOrdersAsLocalConnected(self, ):
2883 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2884 
    if mtype == TMessageType.EXCEPTION:
2885 
      x = TApplicationException()
2886 
      x.read(self._iprot)
2887 
      self._iprot.readMessageEnd()
2888 
      raise x
2889 
    result = markOrdersAsLocalConnected_result()
2890 
    result.read(self._iprot)
2891 
    self._iprot.readMessageEnd()
3431 rajveer 2892 
    if result.ex is not None:
3064 chandransh 2893 
      raise result.ex
4910 phani.kuma 2894 
    return
1627 ankur.sing 2895 
 
4910 phani.kuma 2896 
  def getOrdersNotLocalConnected(self, providerId):
2897 
    """
2898 
    Returns a list of orders that were picked up or shipped but pending local connection.
2899 
 
2900 
    Parameters:
2901 
     - providerId
2902 
    """
2903 
    self.send_getOrdersNotLocalConnected(providerId)
2904 
    return self.recv_getOrdersNotLocalConnected()
2905 
 
2906 
  def send_getOrdersNotLocalConnected(self, providerId):
2907 
    self._oprot.writeMessageBegin('getOrdersNotLocalConnected', TMessageType.CALL, self._seqid)
2908 
    args = getOrdersNotLocalConnected_args()
2909 
    args.providerId = providerId
2910 
    args.write(self._oprot)
2911 
    self._oprot.writeMessageEnd()
2912 
    self._oprot.trans.flush()
2913 
 
2914 
  def recv_getOrdersNotLocalConnected(self, ):
2915 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2916 
    if mtype == TMessageType.EXCEPTION:
2917 
      x = TApplicationException()
2918 
      x.read(self._iprot)
2919 
      self._iprot.readMessageEnd()
2920 
      raise x
2921 
    result = getOrdersNotLocalConnected_result()
2922 
    result.read(self._iprot)
2923 
    self._iprot.readMessageEnd()
2924 
    if result.success is not None:
2925 
      return result.success
2926 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getOrdersNotLocalConnected failed: unknown result");
2927 
 
2928 
  def markOrdersAsDestinationCityReached(self, providerId, destination_city_reached_orders):
2929 
    """
2930 
    Mark all orders with AWBs in the given map as reached destination city. Also sets the reached destination timestamp.
2931 
 
2932 
    Parameters:
2933 
     - providerId
2934 
     - destination_city_reached_orders
2935 
    """
2936 
    self.send_markOrdersAsDestinationCityReached(providerId, destination_city_reached_orders)
2937 
    self.recv_markOrdersAsDestinationCityReached()
2938 
 
2939 
  def send_markOrdersAsDestinationCityReached(self, providerId, destination_city_reached_orders):
2940 
    self._oprot.writeMessageBegin('markOrdersAsDestinationCityReached', TMessageType.CALL, self._seqid)
2941 
    args = markOrdersAsDestinationCityReached_args()
2942 
    args.providerId = providerId
2943 
    args.destination_city_reached_orders = destination_city_reached_orders
2944 
    args.write(self._oprot)
2945 
    self._oprot.writeMessageEnd()
2946 
    self._oprot.trans.flush()
2947 
 
2948 
  def recv_markOrdersAsDestinationCityReached(self, ):
2949 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2950 
    if mtype == TMessageType.EXCEPTION:
2951 
      x = TApplicationException()
2952 
      x.read(self._iprot)
2953 
      self._iprot.readMessageEnd()
2954 
      raise x
2955 
    result = markOrdersAsDestinationCityReached_result()
2956 
    result.read(self._iprot)
2957 
    self._iprot.readMessageEnd()
2958 
    if result.ex is not None:
2959 
      raise result.ex
2960 
    return
2961 
 
2962 
  def markOrdersAsFirstDeliveryAttempted(self, providerId, first_atdl_orders):
2963 
    """
2964 
    Mark all orders with AWBs in the given map as first delivery attempt made. Also sets the first delivery attempted timestamp.
2965 
 
2966 
    Parameters:
2967 
     - providerId
2968 
     - first_atdl_orders
2969 
    """
2970 
    self.send_markOrdersAsFirstDeliveryAttempted(providerId, first_atdl_orders)
2971 
    self.recv_markOrdersAsFirstDeliveryAttempted()
2972 
 
2973 
  def send_markOrdersAsFirstDeliveryAttempted(self, providerId, first_atdl_orders):
2974 
    self._oprot.writeMessageBegin('markOrdersAsFirstDeliveryAttempted', TMessageType.CALL, self._seqid)
2975 
    args = markOrdersAsFirstDeliveryAttempted_args()
2976 
    args.providerId = providerId
2977 
    args.first_atdl_orders = first_atdl_orders
2978 
    args.write(self._oprot)
2979 
    self._oprot.writeMessageEnd()
2980 
    self._oprot.trans.flush()
2981 
 
2982 
  def recv_markOrdersAsFirstDeliveryAttempted(self, ):
2983 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2984 
    if mtype == TMessageType.EXCEPTION:
2985 
      x = TApplicationException()
2986 
      x.read(self._iprot)
2987 
      self._iprot.readMessageEnd()
2988 
      raise x
2989 
    result = markOrdersAsFirstDeliveryAttempted_result()
2990 
    result.read(self._iprot)
2991 
    self._iprot.readMessageEnd()
2992 
    if result.ex is not None:
2993 
      raise result.ex
2994 
    return
2995 
 
3064 chandransh 2996 
  def getUndeliveredOrders(self, providerId, warehouseId):
1627 ankur.sing 2997 
    """
3064 chandransh 2998 
    Returns the list of orders whose delivery time has passed but have not been
2999 
    delivered yet for the given provider and warehouse. To get a complete list of
3000 
    undelivered orders, pass them as -1.
3001 
    Returns an empty list if no such orders exist.
3431 rajveer 3002 
 
1886 ankur.sing 3003 
    Parameters:
3064 chandransh 3004 
     - providerId
3005 
     - warehouseId
1886 ankur.sing 3006 
    """
3064 chandransh 3007 
    self.send_getUndeliveredOrders(providerId, warehouseId)
3008 
    return self.recv_getUndeliveredOrders()
1627 ankur.sing 3009 
 
3064 chandransh 3010 
  def send_getUndeliveredOrders(self, providerId, warehouseId):
3011 
    self._oprot.writeMessageBegin('getUndeliveredOrders', TMessageType.CALL, self._seqid)
3012 
    args = getUndeliveredOrders_args()
3013 
    args.providerId = providerId
3014 
    args.warehouseId = warehouseId
1886 ankur.sing 3015 
    args.write(self._oprot)
3016 
    self._oprot.writeMessageEnd()
3017 
    self._oprot.trans.flush()
3018 
 
3064 chandransh 3019 
  def recv_getUndeliveredOrders(self, ):
1886 ankur.sing 3020 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3021 
    if mtype == TMessageType.EXCEPTION:
3022 
      x = TApplicationException()
3023 
      x.read(self._iprot)
3024 
      self._iprot.readMessageEnd()
3025 
      raise x
3064 chandransh 3026 
    result = getUndeliveredOrders_result()
1886 ankur.sing 3027 
    result.read(self._iprot)
3028 
    self._iprot.readMessageEnd()
3431 rajveer 3029 
    if result.success is not None:
1886 ankur.sing 3030 
      return result.success
3064 chandransh 3031 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getUndeliveredOrders failed: unknown result");
1886 ankur.sing 3032 
 
4783 phani.kuma 3033 
  def getUndeliveredOrdersExpectedDeliveryDateNotMet(self, ):
3034 
    """
3035 
    Returns the list of orders whose expected delivery date has passed but have not been
3036 
    delivered yet.
3037 
    Returns an empty list if no such orders exist.
3038 
    """
3039 
    self.send_getUndeliveredOrdersExpectedDeliveryDateNotMet()
3040 
    return self.recv_getUndeliveredOrdersExpectedDeliveryDateNotMet()
3041 
 
3042 
  def send_getUndeliveredOrdersExpectedDeliveryDateNotMet(self, ):
3043 
    self._oprot.writeMessageBegin('getUndeliveredOrdersExpectedDeliveryDateNotMet', TMessageType.CALL, self._seqid)
3044 
    args = getUndeliveredOrdersExpectedDeliveryDateNotMet_args()
3045 
    args.write(self._oprot)
3046 
    self._oprot.writeMessageEnd()
3047 
    self._oprot.trans.flush()
3048 
 
3049 
  def recv_getUndeliveredOrdersExpectedDeliveryDateNotMet(self, ):
3050 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3051 
    if mtype == TMessageType.EXCEPTION:
3052 
      x = TApplicationException()
3053 
      x.read(self._iprot)
3054 
      self._iprot.readMessageEnd()
3055 
      raise x
3056 
    result = getUndeliveredOrdersExpectedDeliveryDateNotMet_result()
3057 
    result.read(self._iprot)
3058 
    self._iprot.readMessageEnd()
3059 
    if result.success is not None:
3060 
      return result.success
3061 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getUndeliveredOrdersExpectedDeliveryDateNotMet failed: unknown result");
3062 
 
2536 chandransh 3063 
  def toggleDOAFlag(self, orderId):
3064 
    """
3065 
    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.
3066 
    Returns the final flag status.
3067 
    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 3068 
 
2536 chandransh 3069 
    Parameters:
3070 
     - orderId
3071 
    """
3072 
    self.send_toggleDOAFlag(orderId)
3073 
    return self.recv_toggleDOAFlag()
1886 ankur.sing 3074 
 
2536 chandransh 3075 
  def send_toggleDOAFlag(self, orderId):
3076 
    self._oprot.writeMessageBegin('toggleDOAFlag', TMessageType.CALL, self._seqid)
3077 
    args = toggleDOAFlag_args()
3078 
    args.orderId = orderId
3079 
    args.write(self._oprot)
3080 
    self._oprot.writeMessageEnd()
3081 
    self._oprot.trans.flush()
3082 
 
3083 
  def recv_toggleDOAFlag(self, ):
3084 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3085 
    if mtype == TMessageType.EXCEPTION:
3086 
      x = TApplicationException()
3087 
      x.read(self._iprot)
3088 
      self._iprot.readMessageEnd()
3089 
      raise x
3090 
    result = toggleDOAFlag_result()
3091 
    result.read(self._iprot)
3092 
    self._iprot.readMessageEnd()
3431 rajveer 3093 
    if result.success is not None:
2536 chandransh 3094 
      return result.success
3431 rajveer 3095 
    if result.ex is not None:
2536 chandransh 3096 
      raise result.ex
3097 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "toggleDOAFlag failed: unknown result");
3098 
 
4712 rajveer 3099 
  def markOrderAsDelivered(self, orderId, deliveryTimestamp, receiver):
3100 
    """
3101 
    Parameters:
3102 
     - orderId
3103 
     - deliveryTimestamp
3104 
     - receiver
3105 
    """
3106 
    self.send_markOrderAsDelivered(orderId, deliveryTimestamp, receiver)
3107 
    self.recv_markOrderAsDelivered()
3108 
 
3109 
  def send_markOrderAsDelivered(self, orderId, deliveryTimestamp, receiver):
3110 
    self._oprot.writeMessageBegin('markOrderAsDelivered', TMessageType.CALL, self._seqid)
3111 
    args = markOrderAsDelivered_args()
3112 
    args.orderId = orderId
3113 
    args.deliveryTimestamp = deliveryTimestamp
3114 
    args.receiver = receiver
3115 
    args.write(self._oprot)
3116 
    self._oprot.writeMessageEnd()
3117 
    self._oprot.trans.flush()
3118 
 
3119 
  def recv_markOrderAsDelivered(self, ):
3120 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3121 
    if mtype == TMessageType.EXCEPTION:
3122 
      x = TApplicationException()
3123 
      x.read(self._iprot)
3124 
      self._iprot.readMessageEnd()
3125 
      raise x
3126 
    result = markOrderAsDelivered_result()
3127 
    result.read(self._iprot)
3128 
    self._iprot.readMessageEnd()
3129 
    if result.ex is not None:
3130 
      raise result.ex
3131 
    return
3132 
 
5553 rajveer 3133 
  def markOrderAsReceivedAtStore(self, orderId, deliveryTimestamp):
3134 
    """
3135 
    Parameters:
3136 
     - orderId
3137 
     - deliveryTimestamp
3138 
    """
3139 
    self.send_markOrderAsReceivedAtStore(orderId, deliveryTimestamp)
3140 
    self.recv_markOrderAsReceivedAtStore()
3141 
 
3142 
  def send_markOrderAsReceivedAtStore(self, orderId, deliveryTimestamp):
3143 
    self._oprot.writeMessageBegin('markOrderAsReceivedAtStore', TMessageType.CALL, self._seqid)
3144 
    args = markOrderAsReceivedAtStore_args()
3145 
    args.orderId = orderId
3146 
    args.deliveryTimestamp = deliveryTimestamp
3147 
    args.write(self._oprot)
3148 
    self._oprot.writeMessageEnd()
3149 
    self._oprot.trans.flush()
3150 
 
3151 
  def recv_markOrderAsReceivedAtStore(self, ):
3152 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3153 
    if mtype == TMessageType.EXCEPTION:
3154 
      x = TApplicationException()
3155 
      x.read(self._iprot)
3156 
      self._iprot.readMessageEnd()
3157 
      raise x
3158 
    result = markOrderAsReceivedAtStore_result()
3159 
    result.read(self._iprot)
3160 
    self._iprot.readMessageEnd()
3161 
    if result.ex is not None:
3162 
      raise result.ex
3163 
    return
3164 
 
4454 rajveer 3165 
  def markOrderDoaRequestReceived(self, orderId):
3166 
    """
3167 
    Once user raise the request for a DOA, order status will be changed from DELVIERY_SUCCESS to DOA_REQUEST_RECEIVED
3168 
 
3169 
    Parameters:
3170 
     - orderId
3171 
    """
3172 
    self.send_markOrderDoaRequestReceived(orderId)
3173 
    return self.recv_markOrderDoaRequestReceived()
3174 
 
3175 
  def send_markOrderDoaRequestReceived(self, orderId):
3176 
    self._oprot.writeMessageBegin('markOrderDoaRequestReceived', TMessageType.CALL, self._seqid)
3177 
    args = markOrderDoaRequestReceived_args()
3178 
    args.orderId = orderId
3179 
    args.write(self._oprot)
3180 
    self._oprot.writeMessageEnd()
3181 
    self._oprot.trans.flush()
3182 
 
3183 
  def recv_markOrderDoaRequestReceived(self, ):
3184 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3185 
    if mtype == TMessageType.EXCEPTION:
3186 
      x = TApplicationException()
3187 
      x.read(self._iprot)
3188 
      self._iprot.readMessageEnd()
3189 
      raise x
3190 
    result = markOrderDoaRequestReceived_result()
3191 
    result.read(self._iprot)
3192 
    self._iprot.readMessageEnd()
3193 
    if result.success is not None:
3194 
      return result.success
3195 
    if result.ex is not None:
3196 
      raise result.ex
3197 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "markOrderDoaRequestReceived failed: unknown result");
3198 
 
3199 
  def markOrderDoaRequestAuthorized(self, orderId, isAuthorized):
3200 
    """
3201 
    CRM person can authorize or deny the request reised by customer. If he authorizes order will change from DOA_REQUEST_RECEIVED
3202 
    to DOA_REQUEST_AUTHORIZED. If he denies, status will be changed back to DELVIERY_SUCCESS.
3203 
 
3204 
    Parameters:
3205 
     - orderId
3206 
     - isAuthorized
3207 
    """
3208 
    self.send_markOrderDoaRequestAuthorized(orderId, isAuthorized)
3209 
    return self.recv_markOrderDoaRequestAuthorized()
3210 
 
3211 
  def send_markOrderDoaRequestAuthorized(self, orderId, isAuthorized):
3212 
    self._oprot.writeMessageBegin('markOrderDoaRequestAuthorized', TMessageType.CALL, self._seqid)
3213 
    args = markOrderDoaRequestAuthorized_args()
3214 
    args.orderId = orderId
3215 
    args.isAuthorized = isAuthorized
3216 
    args.write(self._oprot)
3217 
    self._oprot.writeMessageEnd()
3218 
    self._oprot.trans.flush()
3219 
 
3220 
  def recv_markOrderDoaRequestAuthorized(self, ):
3221 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3222 
    if mtype == TMessageType.EXCEPTION:
3223 
      x = TApplicationException()
3224 
      x.read(self._iprot)
3225 
      self._iprot.readMessageEnd()
3226 
      raise x
3227 
    result = markOrderDoaRequestAuthorized_result()
3228 
    result.read(self._iprot)
3229 
    self._iprot.readMessageEnd()
3230 
    if result.success is not None:
3231 
      return result.success
3232 
    if result.ex is not None:
3233 
      raise result.ex
3234 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "markOrderDoaRequestAuthorized failed: unknown result");
3235 
 
4488 rajveer 3236 
  def markOrderReturnRequestReceived(self, orderId):
3237 
    """
3238 
    Once user raise the request for a RET, order status will be changed from DELVIERY_SUCCESS to RET_REQUEST_RECEIVED
3239 
 
3240 
    Parameters:
3241 
     - orderId
3242 
    """
3243 
    self.send_markOrderReturnRequestReceived(orderId)
3244 
    return self.recv_markOrderReturnRequestReceived()
3245 
 
3246 
  def send_markOrderReturnRequestReceived(self, orderId):
3247 
    self._oprot.writeMessageBegin('markOrderReturnRequestReceived', TMessageType.CALL, self._seqid)
3248 
    args = markOrderReturnRequestReceived_args()
3249 
    args.orderId = orderId
3250 
    args.write(self._oprot)
3251 
    self._oprot.writeMessageEnd()
3252 
    self._oprot.trans.flush()
3253 
 
3254 
  def recv_markOrderReturnRequestReceived(self, ):
3255 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3256 
    if mtype == TMessageType.EXCEPTION:
3257 
      x = TApplicationException()
3258 
      x.read(self._iprot)
3259 
      self._iprot.readMessageEnd()
3260 
      raise x
3261 
    result = markOrderReturnRequestReceived_result()
3262 
    result.read(self._iprot)
3263 
    self._iprot.readMessageEnd()
3264 
    if result.success is not None:
3265 
      return result.success
3266 
    if result.ex is not None:
3267 
      raise result.ex
3268 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "markOrderReturnRequestReceived failed: unknown result");
3269 
 
3270 
  def markOrderReturnRequestAuthorized(self, orderId, isAuthorized):
3271 
    """
3272 
    CRM person can authorize or deny the request reised by customer. If he authorizes order will change from RET_REQUEST_RECEIVED
3273 
    to RET_REQUEST_AUTHORIZED. If he denies, status will be changed back to DELVIERY_SUCCESS.
3274 
 
3275 
    Parameters:
3276 
     - orderId
3277 
     - isAuthorized
3278 
    """
3279 
    self.send_markOrderReturnRequestAuthorized(orderId, isAuthorized)
3280 
    return self.recv_markOrderReturnRequestAuthorized()
3281 
 
3282 
  def send_markOrderReturnRequestAuthorized(self, orderId, isAuthorized):
3283 
    self._oprot.writeMessageBegin('markOrderReturnRequestAuthorized', TMessageType.CALL, self._seqid)
3284 
    args = markOrderReturnRequestAuthorized_args()
3285 
    args.orderId = orderId
3286 
    args.isAuthorized = isAuthorized
3287 
    args.write(self._oprot)
3288 
    self._oprot.writeMessageEnd()
3289 
    self._oprot.trans.flush()
3290 
 
3291 
  def recv_markOrderReturnRequestAuthorized(self, ):
3292 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3293 
    if mtype == TMessageType.EXCEPTION:
3294 
      x = TApplicationException()
3295 
      x.read(self._iprot)
3296 
      self._iprot.readMessageEnd()
3297 
      raise x
3298 
    result = markOrderReturnRequestAuthorized_result()
3299 
    result.read(self._iprot)
3300 
    self._iprot.readMessageEnd()
3301 
    if result.success is not None:
3302 
      return result.success
3303 
    if result.ex is not None:
3304 
      raise result.ex
3305 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "markOrderReturnRequestAuthorized failed: unknown result");
3306 
 
4579 rajveer 3307 
  def requestPickupNumber(self, orderId, providerId):
2536 chandransh 3308 
    """
3309 
    Sends out an email to the account manager of the original courier provider used to ship the order.
4452 rajveer 3310 
    If the order status was DELIVERY_SUCCESS, it is changed to be DOA_PICKUP_REQUEST_RAISED.
3311 
    If the order status was DOA_PICKUP_REQUEST_RAISED, it is left unchanged.
2536 chandransh 3312 
    For any other status, it returns false.
3313 
    Throws an exception if the order with the given id couldn't be found.
3431 rajveer 3314 
 
2536 chandransh 3315 
    Parameters:
3316 
     - orderId
4579 rajveer 3317 
     - providerId
2536 chandransh 3318 
    """
4579 rajveer 3319 
    self.send_requestPickupNumber(orderId, providerId)
2536 chandransh 3320 
    return self.recv_requestPickupNumber()
3321 
 
4579 rajveer 3322 
  def send_requestPickupNumber(self, orderId, providerId):
2536 chandransh 3323 
    self._oprot.writeMessageBegin('requestPickupNumber', TMessageType.CALL, self._seqid)
3324 
    args = requestPickupNumber_args()
3325 
    args.orderId = orderId
4579 rajveer 3326 
    args.providerId = providerId
2536 chandransh 3327 
    args.write(self._oprot)
3328 
    self._oprot.writeMessageEnd()
3329 
    self._oprot.trans.flush()
3330 
 
3331 
  def recv_requestPickupNumber(self, ):
3332 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3333 
    if mtype == TMessageType.EXCEPTION:
3334 
      x = TApplicationException()
3335 
      x.read(self._iprot)
3336 
      self._iprot.readMessageEnd()
3337 
      raise x
3338 
    result = requestPickupNumber_result()
3339 
    result.read(self._iprot)
3340 
    self._iprot.readMessageEnd()
3431 rajveer 3341 
    if result.success is not None:
2536 chandransh 3342 
      return result.success
3431 rajveer 3343 
    if result.ex is not None:
2536 chandransh 3344 
      raise result.ex
3345 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "requestPickupNumber failed: unknown result");
3346 
 
4602 rajveer 3347 
  def authorizePickup(self, orderId, pickupNumber, providerId):
2536 chandransh 3348 
    """
4452 rajveer 3349 
    If the order status is DOA_PICKUP_REQUEST_RAISED, it does the following
2536 chandransh 3350 
    	1. Sends out an email to the customer with the dispatch advice that he has to print as an attachment.
3351 
    	2. Changes order status to be DOA_PICKUP_AUTHORIZED.
3352 
    	3. Returns true
2591 chandransh 3353 
    If the order is in any other status, it returns false.
2536 chandransh 3354 
    Throws an exception if the order with the given id couldn't be found.
3431 rajveer 3355 
 
2536 chandransh 3356 
    Parameters:
3357 
     - orderId
3358 
     - pickupNumber
4602 rajveer 3359 
     - providerId
2536 chandransh 3360 
    """
4602 rajveer 3361 
    self.send_authorizePickup(orderId, pickupNumber, providerId)
2536 chandransh 3362 
    return self.recv_authorizePickup()
3363 
 
4602 rajveer 3364 
  def send_authorizePickup(self, orderId, pickupNumber, providerId):
2536 chandransh 3365 
    self._oprot.writeMessageBegin('authorizePickup', TMessageType.CALL, self._seqid)
3366 
    args = authorizePickup_args()
3367 
    args.orderId = orderId
3368 
    args.pickupNumber = pickupNumber
4602 rajveer 3369 
    args.providerId = providerId
2536 chandransh 3370 
    args.write(self._oprot)
3371 
    self._oprot.writeMessageEnd()
3372 
    self._oprot.trans.flush()
3373 
 
3374 
  def recv_authorizePickup(self, ):
3375 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3376 
    if mtype == TMessageType.EXCEPTION:
3377 
      x = TApplicationException()
3378 
      x.read(self._iprot)
3379 
      self._iprot.readMessageEnd()
3380 
      raise x
3381 
    result = authorizePickup_result()
3382 
    result.read(self._iprot)
3383 
    self._iprot.readMessageEnd()
3431 rajveer 3384 
    if result.success is not None:
2536 chandransh 3385 
      return result.success
3431 rajveer 3386 
    if result.ex is not None:
2536 chandransh 3387 
      raise result.ex
3388 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "authorizePickup failed: unknown result");
3389 
 
2764 chandransh 3390 
  def markDoasAsPickedUp(self, providerId, pickupDetails):
3391 
    """
3392 
    Marks all DOA_PICKUP_AUTHORIZED orders of the previous day for a provider as DOA_RETURN_IN_TRANSIT.
3431 rajveer 3393 
 
2764 chandransh 3394 
    Parameters:
3395 
     - providerId
3396 
     - pickupDetails
3397 
    """
3398 
    self.send_markDoasAsPickedUp(providerId, pickupDetails)
4910 phani.kuma 3399 
    self.recv_markDoasAsPickedUp()
2764 chandransh 3400 
 
3401 
  def send_markDoasAsPickedUp(self, providerId, pickupDetails):
3402 
    self._oprot.writeMessageBegin('markDoasAsPickedUp', TMessageType.CALL, self._seqid)
3403 
    args = markDoasAsPickedUp_args()
3404 
    args.providerId = providerId
3405 
    args.pickupDetails = pickupDetails
3406 
    args.write(self._oprot)
3407 
    self._oprot.writeMessageEnd()
3408 
    self._oprot.trans.flush()
3409 
 
3410 
  def recv_markDoasAsPickedUp(self, ):
3411 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3412 
    if mtype == TMessageType.EXCEPTION:
3413 
      x = TApplicationException()
3414 
      x.read(self._iprot)
3415 
      self._iprot.readMessageEnd()
3416 
      raise x
3417 
    result = markDoasAsPickedUp_result()
3418 
    result.read(self._iprot)
3419 
    self._iprot.readMessageEnd()
4910 phani.kuma 3420 
    return
3421 
 
3422 
  def getDoasNotPickedUp(self, providerId):
3423 
    """
3424 
    Returns a list of orders that were authorized for pickup but did not appear in the pick-up report.
3425 
 
3426 
    Parameters:
3427 
     - providerId
3428 
    """
3429 
    self.send_getDoasNotPickedUp(providerId)
3430 
    return self.recv_getDoasNotPickedUp()
3431 
 
3432 
  def send_getDoasNotPickedUp(self, providerId):
3433 
    self._oprot.writeMessageBegin('getDoasNotPickedUp', TMessageType.CALL, self._seqid)
3434 
    args = getDoasNotPickedUp_args()
3435 
    args.providerId = providerId
3436 
    args.write(self._oprot)
3437 
    self._oprot.writeMessageEnd()
3438 
    self._oprot.trans.flush()
3439 
 
3440 
  def recv_getDoasNotPickedUp(self, ):
3441 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3442 
    if mtype == TMessageType.EXCEPTION:
3443 
      x = TApplicationException()
3444 
      x.read(self._iprot)
3445 
      self._iprot.readMessageEnd()
3446 
      raise x
3447 
    result = getDoasNotPickedUp_result()
3448 
    result.read(self._iprot)
3449 
    self._iprot.readMessageEnd()
3431 rajveer 3450 
    if result.success is not None:
2764 chandransh 3451 
      return result.success
4910 phani.kuma 3452 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getDoasNotPickedUp failed: unknown result");
2764 chandransh 3453 
 
4741 phani.kuma 3454 
  def markReturnOrdersAsPickedUp(self, providerId, pickupDetails):
3455 
    """
3456 
    Marks all RET_PICKUP_CONFIRMED orders of the previous day for a provider as RET_RETURN_IN_TRANSIT.
3457 
 
3458 
    Parameters:
3459 
     - providerId
3460 
     - pickupDetails
3461 
    """
3462 
    self.send_markReturnOrdersAsPickedUp(providerId, pickupDetails)
4910 phani.kuma 3463 
    self.recv_markReturnOrdersAsPickedUp()
4741 phani.kuma 3464 
 
3465 
  def send_markReturnOrdersAsPickedUp(self, providerId, pickupDetails):
3466 
    self._oprot.writeMessageBegin('markReturnOrdersAsPickedUp', TMessageType.CALL, self._seqid)
3467 
    args = markReturnOrdersAsPickedUp_args()
3468 
    args.providerId = providerId
3469 
    args.pickupDetails = pickupDetails
3470 
    args.write(self._oprot)
3471 
    self._oprot.writeMessageEnd()
3472 
    self._oprot.trans.flush()
3473 
 
3474 
  def recv_markReturnOrdersAsPickedUp(self, ):
3475 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3476 
    if mtype == TMessageType.EXCEPTION:
3477 
      x = TApplicationException()
3478 
      x.read(self._iprot)
3479 
      self._iprot.readMessageEnd()
3480 
      raise x
3481 
    result = markReturnOrdersAsPickedUp_result()
3482 
    result.read(self._iprot)
3483 
    self._iprot.readMessageEnd()
4910 phani.kuma 3484 
    return
3485 
 
3486 
  def getReturnOrdersNotPickedUp(self, providerId):
3487 
    """
3488 
    Returns a list of orders that were authorized for pickup but did not appear in the pick-up report.
3489 
 
3490 
    Parameters:
3491 
     - providerId
3492 
    """
3493 
    self.send_getReturnOrdersNotPickedUp(providerId)
3494 
    return self.recv_getReturnOrdersNotPickedUp()
3495 
 
3496 
  def send_getReturnOrdersNotPickedUp(self, providerId):
3497 
    self._oprot.writeMessageBegin('getReturnOrdersNotPickedUp', TMessageType.CALL, self._seqid)
3498 
    args = getReturnOrdersNotPickedUp_args()
3499 
    args.providerId = providerId
3500 
    args.write(self._oprot)
3501 
    self._oprot.writeMessageEnd()
3502 
    self._oprot.trans.flush()
3503 
 
3504 
  def recv_getReturnOrdersNotPickedUp(self, ):
3505 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3506 
    if mtype == TMessageType.EXCEPTION:
3507 
      x = TApplicationException()
3508 
      x.read(self._iprot)
3509 
      self._iprot.readMessageEnd()
3510 
      raise x
3511 
    result = getReturnOrdersNotPickedUp_result()
3512 
    result.read(self._iprot)
3513 
    self._iprot.readMessageEnd()
4741 phani.kuma 3514 
    if result.success is not None:
3515 
      return result.success
4910 phani.kuma 3516 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getReturnOrdersNotPickedUp failed: unknown result");
4741 phani.kuma 3517 
 
4479 rajveer 3518 
  def receiveReturn(self, orderId, receiveCondition):
2591 chandransh 3519 
    """
4452 rajveer 3520 
    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 3521 
    If the order status is RTO_IN_TRANSIT, marks the order status as RTO_RECEIVED_PRESTINE and returns true.
2591 chandransh 3522 
    If the order is in any other state, it returns false.
3523 
    Throws an exception if the order with the given id couldn't be found.
3431 rajveer 3524 
 
2591 chandransh 3525 
    Parameters:
3526 
     - orderId
4479 rajveer 3527 
     - receiveCondition
2591 chandransh 3528 
    """
4479 rajveer 3529 
    self.send_receiveReturn(orderId, receiveCondition)
2616 chandransh 3530 
    return self.recv_receiveReturn()
2536 chandransh 3531 
 
4479 rajveer 3532 
  def send_receiveReturn(self, orderId, receiveCondition):
2616 chandransh 3533 
    self._oprot.writeMessageBegin('receiveReturn', TMessageType.CALL, self._seqid)
3534 
    args = receiveReturn_args()
2591 chandransh 3535 
    args.orderId = orderId
4479 rajveer 3536 
    args.receiveCondition = receiveCondition
2591 chandransh 3537 
    args.write(self._oprot)
3538 
    self._oprot.writeMessageEnd()
3539 
    self._oprot.trans.flush()
3540 
 
2616 chandransh 3541 
  def recv_receiveReturn(self, ):
2591 chandransh 3542 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3543 
    if mtype == TMessageType.EXCEPTION:
3544 
      x = TApplicationException()
3545 
      x.read(self._iprot)
3546 
      self._iprot.readMessageEnd()
3547 
      raise x
2616 chandransh 3548 
    result = receiveReturn_result()
2591 chandransh 3549 
    result.read(self._iprot)
3550 
    self._iprot.readMessageEnd()
3431 rajveer 3551 
    if result.success is not None:
2591 chandransh 3552 
      return result.success
3431 rajveer 3553 
    if result.ex is not None:
2591 chandransh 3554 
      raise result.ex
2616 chandransh 3555 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "receiveReturn failed: unknown result");
2591 chandransh 3556 
 
3557 
  def validateDoa(self, orderId, isValid):
3558 
    """
4452 rajveer 3559 
    Used to validate the DOA certificate for an order in the DOA_RECEIVED_PRESTINE state. If the certificate is valid,
2616 chandransh 3560 
    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 3561 
    If the order is in any other state, it returns false.
3562 
    Throws an exception if the order with the given id couldn't be found.
3431 rajveer 3563 
 
2591 chandransh 3564 
    Parameters:
3565 
     - orderId
3566 
     - isValid
3567 
    """
3568 
    self.send_validateDoa(orderId, isValid)
3569 
    return self.recv_validateDoa()
3570 
 
3571 
  def send_validateDoa(self, orderId, isValid):
3572 
    self._oprot.writeMessageBegin('validateDoa', TMessageType.CALL, self._seqid)
3573 
    args = validateDoa_args()
3574 
    args.orderId = orderId
3575 
    args.isValid = isValid
3576 
    args.write(self._oprot)
3577 
    self._oprot.writeMessageEnd()
3578 
    self._oprot.trans.flush()
3579 
 
3580 
  def recv_validateDoa(self, ):
3581 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3582 
    if mtype == TMessageType.EXCEPTION:
3583 
      x = TApplicationException()
3584 
      x.read(self._iprot)
3585 
      self._iprot.readMessageEnd()
3586 
      raise x
3587 
    result = validateDoa_result()
3588 
    result.read(self._iprot)
3589 
    self._iprot.readMessageEnd()
3431 rajveer 3590 
    if result.success is not None:
2591 chandransh 3591 
      return result.success
3431 rajveer 3592 
    if result.ex is not None:
2591 chandransh 3593 
      raise result.ex
3594 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "validateDoa failed: unknown result");
3595 
 
4495 rajveer 3596 
  def validateReturnProduct(self, orderId, isUsable):
3597 
    """
3598 
    Parameters:
3599 
     - orderId
3600 
     - isUsable
3601 
    """
3602 
    self.send_validateReturnProduct(orderId, isUsable)
3603 
    return self.recv_validateReturnProduct()
3604 
 
3605 
  def send_validateReturnProduct(self, orderId, isUsable):
3606 
    self._oprot.writeMessageBegin('validateReturnProduct', TMessageType.CALL, self._seqid)
3607 
    args = validateReturnProduct_args()
3608 
    args.orderId = orderId
3609 
    args.isUsable = isUsable
3610 
    args.write(self._oprot)
3611 
    self._oprot.writeMessageEnd()
3612 
    self._oprot.trans.flush()
3613 
 
3614 
  def recv_validateReturnProduct(self, ):
3615 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3616 
    if mtype == TMessageType.EXCEPTION:
3617 
      x = TApplicationException()
3618 
      x.read(self._iprot)
3619 
      self._iprot.readMessageEnd()
3620 
      raise x
3621 
    result = validateReturnProduct_result()
3622 
    result.read(self._iprot)
3623 
    self._iprot.readMessageEnd()
3624 
    if result.success is not None:
3625 
      return result.success
3626 
    if result.ex is not None:
3627 
      raise result.ex
3628 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "validateReturnProduct failed: unknown result");
3629 
 
2616 chandransh 3630 
  def reshipOrder(self, orderId):
3631 
    """
4484 rajveer 3632 
    If the order is in RTO_RECEIVED_PRESTINE or DOA_CERT_INVALID state, it does the following:
2616 chandransh 3633 
    	1. Creates a new order for processing in the BILLED state. All billing information is saved.
4484 rajveer 3634 
    	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 3635 
 
3636 
    If the order is in DOA_CERT_VALID state, it does the following:
3637 
    	1. Creates a new order for processing in the SUBMITTED_FOR_PROCESSING state.
3638 
    	2. Creates a return order for the warehouse executive to return the DOA material.
4452 rajveer 3639 
    	3. Marks the current order as the final DOA_VALID_RESHIPPED state.
3431 rajveer 3640 
 
2616 chandransh 3641 
    Returns the id of the newly created order.
3431 rajveer 3642 
 
2616 chandransh 3643 
    Throws an exception if the order with the given id couldn't be found.
3431 rajveer 3644 
 
2616 chandransh 3645 
    Parameters:
3646 
     - orderId
3647 
    """
3648 
    self.send_reshipOrder(orderId)
3649 
    return self.recv_reshipOrder()
2591 chandransh 3650 
 
2616 chandransh 3651 
  def send_reshipOrder(self, orderId):
3652 
    self._oprot.writeMessageBegin('reshipOrder', TMessageType.CALL, self._seqid)
3653 
    args = reshipOrder_args()
3654 
    args.orderId = orderId
3655 
    args.write(self._oprot)
3656 
    self._oprot.writeMessageEnd()
3657 
    self._oprot.trans.flush()
3658 
 
3659 
  def recv_reshipOrder(self, ):
3660 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3661 
    if mtype == TMessageType.EXCEPTION:
3662 
      x = TApplicationException()
3663 
      x.read(self._iprot)
3664 
      self._iprot.readMessageEnd()
3665 
      raise x
3666 
    result = reshipOrder_result()
3667 
    result.read(self._iprot)
3668 
    self._iprot.readMessageEnd()
3431 rajveer 3669 
    if result.success is not None:
2616 chandransh 3670 
      return result.success
3431 rajveer 3671 
    if result.ex is not None:
2616 chandransh 3672 
      raise result.ex
3673 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "reshipOrder failed: unknown result");
3674 
 
3226 chandransh 3675 
  def refundOrder(self, orderId, refundedBy, reason):
2616 chandransh 3676 
    """
4484 rajveer 3677 
    If the order is in RTO_RECEIVED_PRESTINE, DOA_CERT_VALID or DOA_CERT_INVALID state, it does the following:
2616 chandransh 3678 
    	1. Creates a refund request for batch processing.
3679 
    	2. Creates a return order for the warehouse executive to return the shipped material.
4484 rajveer 3680 
    	3. Marks the current order as RTO_REFUNDED, DOA_VALID_REFUNDED or DOA_INVALID_REFUNDED final states.
3431 rajveer 3681 
 
2616 chandransh 3682 
    If the order is in SUBMITTED_FOR_PROCESSING or INVENTORY_LOW state, it does the following:
3683 
    	1. Creates a refund request for batch processing.
3226 chandransh 3684 
    	2. Cancels the reservation of the item in the warehouse.
3685 
    	3. Marks the current order as the REFUNDED final state.
3431 rajveer 3686 
 
3226 chandransh 3687 
    For all COD orders, if the order is in INIT, SUBMITTED_FOR_PROCESSING or INVENTORY_LOW state, it does the following:
3688 
    	1. Cancels the reservation of the item in the warehouse.
3689 
    	2. Marks the current order as CANCELED.
3690 
 
3691 
    In all cases, it updates the reason for cancellation or refund and the person who performed the action.
3692 
 
2616 chandransh 3693 
    Returns True if it is successful, False otherwise.
3431 rajveer 3694 
 
2616 chandransh 3695 
    Throws an exception if the order with the given id couldn't be found.
3431 rajveer 3696 
 
2616 chandransh 3697 
    Parameters:
3698 
     - orderId
3226 chandransh 3699 
     - refundedBy
3700 
     - reason
2616 chandransh 3701 
    """
3226 chandransh 3702 
    self.send_refundOrder(orderId, refundedBy, reason)
2616 chandransh 3703 
    return self.recv_refundOrder()
3704 
 
3226 chandransh 3705 
  def send_refundOrder(self, orderId, refundedBy, reason):
2616 chandransh 3706 
    self._oprot.writeMessageBegin('refundOrder', TMessageType.CALL, self._seqid)
3707 
    args = refundOrder_args()
3708 
    args.orderId = orderId
3226 chandransh 3709 
    args.refundedBy = refundedBy
3710 
    args.reason = reason
2616 chandransh 3711 
    args.write(self._oprot)
3712 
    self._oprot.writeMessageEnd()
3713 
    self._oprot.trans.flush()
3714 
 
3715 
  def recv_refundOrder(self, ):
3716 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3717 
    if mtype == TMessageType.EXCEPTION:
3718 
      x = TApplicationException()
3719 
      x.read(self._iprot)
3720 
      self._iprot.readMessageEnd()
3721 
      raise x
3722 
    result = refundOrder_result()
3723 
    result.read(self._iprot)
3724 
    self._iprot.readMessageEnd()
3431 rajveer 3725 
    if result.success is not None:
2616 chandransh 3726 
      return result.success
3431 rajveer 3727 
    if result.ex is not None:
2616 chandransh 3728 
      raise result.ex
3729 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "refundOrder failed: unknown result");
3730 
 
2690 chandransh 3731 
  def getReturnOrders(self, warehouseId, fromDate, toDate):
3732 
    """
3733 
    Get all return orders created between the from and to dates for the given warehouse.
3734 
    Ignores the warehouse if it is passed as -1.
3431 rajveer 3735 
 
2690 chandransh 3736 
    Parameters:
3737 
     - warehouseId
3738 
     - fromDate
3739 
     - toDate
3740 
    """
3741 
    self.send_getReturnOrders(warehouseId, fromDate, toDate)
3742 
    return self.recv_getReturnOrders()
2616 chandransh 3743 
 
2690 chandransh 3744 
  def send_getReturnOrders(self, warehouseId, fromDate, toDate):
3745 
    self._oprot.writeMessageBegin('getReturnOrders', TMessageType.CALL, self._seqid)
3746 
    args = getReturnOrders_args()
3747 
    args.warehouseId = warehouseId
3748 
    args.fromDate = fromDate
3749 
    args.toDate = toDate
3750 
    args.write(self._oprot)
3751 
    self._oprot.writeMessageEnd()
3752 
    self._oprot.trans.flush()
3753 
 
3754 
  def recv_getReturnOrders(self, ):
3755 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3756 
    if mtype == TMessageType.EXCEPTION:
3757 
      x = TApplicationException()
3758 
      x.read(self._iprot)
3759 
      self._iprot.readMessageEnd()
3760 
      raise x
3761 
    result = getReturnOrders_result()
3762 
    result.read(self._iprot)
3763 
    self._iprot.readMessageEnd()
3431 rajveer 3764 
    if result.success is not None:
2690 chandransh 3765 
      return result.success
3766 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getReturnOrders failed: unknown result");
3767 
 
5481 phani.kuma 3768 
  def getAllReturnOrders(self, onlyNotProcessed, fromDate, toDate):
3769 
    """
3770 
    Get all return orders created between the from and to dates.
3771 
 
3772 
    Parameters:
3773 
     - onlyNotProcessed
3774 
     - fromDate
3775 
     - toDate
3776 
    """
3777 
    self.send_getAllReturnOrders(onlyNotProcessed, fromDate, toDate)
3778 
    return self.recv_getAllReturnOrders()
3779 
 
3780 
  def send_getAllReturnOrders(self, onlyNotProcessed, fromDate, toDate):
3781 
    self._oprot.writeMessageBegin('getAllReturnOrders', TMessageType.CALL, self._seqid)
3782 
    args = getAllReturnOrders_args()
3783 
    args.onlyNotProcessed = onlyNotProcessed
3784 
    args.fromDate = fromDate
3785 
    args.toDate = toDate
3786 
    args.write(self._oprot)
3787 
    self._oprot.writeMessageEnd()
3788 
    self._oprot.trans.flush()
3789 
 
3790 
  def recv_getAllReturnOrders(self, ):
3791 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3792 
    if mtype == TMessageType.EXCEPTION:
3793 
      x = TApplicationException()
3794 
      x.read(self._iprot)
3795 
      self._iprot.readMessageEnd()
3796 
      raise x
3797 
    result = getAllReturnOrders_result()
3798 
    result.read(self._iprot)
3799 
    self._iprot.readMessageEnd()
3800 
    if result.success is not None:
3801 
      return result.success
3802 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAllReturnOrders failed: unknown result");
3803 
 
2700 chandransh 3804 
  def getReturnOrder(self, id):
3805 
    """
3806 
    Returns the ReturnOrder corresponding to the given id.
3807 
    Throws an exception if the return order with the given id couldn't be found.
3431 rajveer 3808 
 
2700 chandransh 3809 
    Parameters:
3810 
     - id
3811 
    """
3812 
    self.send_getReturnOrder(id)
3813 
    return self.recv_getReturnOrder()
3814 
 
3815 
  def send_getReturnOrder(self, id):
3816 
    self._oprot.writeMessageBegin('getReturnOrder', TMessageType.CALL, self._seqid)
3817 
    args = getReturnOrder_args()
3818 
    args.id = id
3819 
    args.write(self._oprot)
3820 
    self._oprot.writeMessageEnd()
3821 
    self._oprot.trans.flush()
3822 
 
3823 
  def recv_getReturnOrder(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 = getReturnOrder_result()
3831 
    result.read(self._iprot)
3832 
    self._iprot.readMessageEnd()
3431 rajveer 3833 
    if result.success is not None:
2700 chandransh 3834 
      return result.success
3431 rajveer 3835 
    if result.ex is not None:
2700 chandransh 3836 
      raise result.ex
3837 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getReturnOrder failed: unknown result");
3838 
 
2690 chandransh 3839 
  def processReturn(self, returnOrderId):
3840 
    """
3841 
    Marks the return order with the given id as processed. Raises an exception if no such return order exists.
3431 rajveer 3842 
 
2690 chandransh 3843 
    Parameters:
3844 
     - returnOrderId
3845 
    """
3846 
    self.send_processReturn(returnOrderId)
3847 
    self.recv_processReturn()
3848 
 
3849 
  def send_processReturn(self, returnOrderId):
3850 
    self._oprot.writeMessageBegin('processReturn', TMessageType.CALL, self._seqid)
3851 
    args = processReturn_args()
3852 
    args.returnOrderId = returnOrderId
3853 
    args.write(self._oprot)
3854 
    self._oprot.writeMessageEnd()
3855 
    self._oprot.trans.flush()
3856 
 
3857 
  def recv_processReturn(self, ):
3858 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3859 
    if mtype == TMessageType.EXCEPTION:
3860 
      x = TApplicationException()
3861 
      x.read(self._iprot)
3862 
      self._iprot.readMessageEnd()
3863 
      raise x
3864 
    result = processReturn_result()
3865 
    result.read(self._iprot)
3866 
    self._iprot.readMessageEnd()
3431 rajveer 3867 
    if result.ex is not None:
2690 chandransh 3868 
      raise result.ex
3869 
    return
3870 
 
3451 chandransh 3871 
  def updateWeight(self, orderId, weight):
3872 
    """
3873 
    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 3874 
 
3451 chandransh 3875 
    Parameters:
3876 
     - orderId
3877 
     - weight
3878 
    """
3879 
    self.send_updateWeight(orderId, weight)
3880 
    return self.recv_updateWeight()
3881 
 
3882 
  def send_updateWeight(self, orderId, weight):
3883 
    self._oprot.writeMessageBegin('updateWeight', TMessageType.CALL, self._seqid)
3884 
    args = updateWeight_args()
3885 
    args.orderId = orderId
3886 
    args.weight = weight
3887 
    args.write(self._oprot)
3888 
    self._oprot.writeMessageEnd()
3889 
    self._oprot.trans.flush()
3890 
 
3891 
  def recv_updateWeight(self, ):
3892 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3893 
    if mtype == TMessageType.EXCEPTION:
3894 
      x = TApplicationException()
3895 
      x.read(self._iprot)
3896 
      self._iprot.readMessageEnd()
3897 
      raise x
3898 
    result = updateWeight_result()
3899 
    result.read(self._iprot)
3900 
    self._iprot.readMessageEnd()
3901 
    if result.success is not None:
3902 
      return result.success
3903 
    if result.ex is not None:
3904 
      raise result.ex
3905 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "updateWeight failed: unknown result");
3906 
 
3469 chandransh 3907 
  def changeItem(self, orderId, itemId):
3908 
    """
3909 
    Change the item to be shipped for this order. Also adjusts the reservation in the inventory accordingly.
3910 
    Currently, it also ensures that only a different color of the given item is shipped.
3451 chandransh 3911 
 
3469 chandransh 3912 
    Parameters:
3913 
     - orderId
3914 
     - itemId
3915 
    """
3916 
    self.send_changeItem(orderId, itemId)
3917 
    return self.recv_changeItem()
3918 
 
3919 
  def send_changeItem(self, orderId, itemId):
3920 
    self._oprot.writeMessageBegin('changeItem', TMessageType.CALL, self._seqid)
3921 
    args = changeItem_args()
3922 
    args.orderId = orderId
3923 
    args.itemId = itemId
3924 
    args.write(self._oprot)
3925 
    self._oprot.writeMessageEnd()
3926 
    self._oprot.trans.flush()
3927 
 
3928 
  def recv_changeItem(self, ):
3929 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3930 
    if mtype == TMessageType.EXCEPTION:
3931 
      x = TApplicationException()
3932 
      x.read(self._iprot)
3933 
      self._iprot.readMessageEnd()
3934 
      raise x
3935 
    result = changeItem_result()
3936 
    result.read(self._iprot)
3937 
    self._iprot.readMessageEnd()
3938 
    if result.success is not None:
3939 
      return result.success
3940 
    if result.ex is not None:
3941 
      raise result.ex
3942 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "changeItem failed: unknown result");
3943 
 
3944 
  def shiftToWarehouse(self, orderId, warehouseId):
3945 
    """
3946 
    Moves the given order to the given warehouse. Also adjusts the inventory reservations accordingly.
3947 
 
3948 
    Parameters:
3949 
     - orderId
3950 
     - warehouseId
3951 
    """
3952 
    self.send_shiftToWarehouse(orderId, warehouseId)
3953 
    return self.recv_shiftToWarehouse()
3954 
 
3955 
  def send_shiftToWarehouse(self, orderId, warehouseId):
3956 
    self._oprot.writeMessageBegin('shiftToWarehouse', TMessageType.CALL, self._seqid)
3957 
    args = shiftToWarehouse_args()
3958 
    args.orderId = orderId
3959 
    args.warehouseId = warehouseId
3960 
    args.write(self._oprot)
3961 
    self._oprot.writeMessageEnd()
3962 
    self._oprot.trans.flush()
3963 
 
3964 
  def recv_shiftToWarehouse(self, ):
3965 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3966 
    if mtype == TMessageType.EXCEPTION:
3967 
      x = TApplicationException()
3968 
      x.read(self._iprot)
3969 
      self._iprot.readMessageEnd()
3970 
      raise x
3971 
    result = shiftToWarehouse_result()
3972 
    result.read(self._iprot)
3973 
    self._iprot.readMessageEnd()
3974 
    if result.success is not None:
3975 
      return result.success
3976 
    if result.ex is not None:
3977 
      raise result.ex
3978 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "shiftToWarehouse failed: unknown result");
3979 
 
4647 rajveer 3980 
  def addDelayReason(self, orderId, delayReason, furtherDelay, delayReasonText):
3553 chandransh 3981 
    """
3982 
    Adds the given delay reason to the given order.
3986 chandransh 3983 
    Increases the expected delivery time of the given order by the given no. of days.
3553 chandransh 3984 
    Raises an exception if no order with the given id can be found.
3469 chandransh 3985 
 
3553 chandransh 3986 
    Parameters:
3987 
     - orderId
3988 
     - delayReason
3986 chandransh 3989 
     - furtherDelay
4647 rajveer 3990 
     - delayReasonText
3553 chandransh 3991 
    """
4647 rajveer 3992 
    self.send_addDelayReason(orderId, delayReason, furtherDelay, delayReasonText)
3553 chandransh 3993 
    return self.recv_addDelayReason()
3994 
 
4647 rajveer 3995 
  def send_addDelayReason(self, orderId, delayReason, furtherDelay, delayReasonText):
3553 chandransh 3996 
    self._oprot.writeMessageBegin('addDelayReason', TMessageType.CALL, self._seqid)
3997 
    args = addDelayReason_args()
3998 
    args.orderId = orderId
3999 
    args.delayReason = delayReason
3986 chandransh 4000 
    args.furtherDelay = furtherDelay
4647 rajveer 4001 
    args.delayReasonText = delayReasonText
3553 chandransh 4002 
    args.write(self._oprot)
4003 
    self._oprot.writeMessageEnd()
4004 
    self._oprot.trans.flush()
4005 
 
4006 
  def recv_addDelayReason(self, ):
4007 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4008 
    if mtype == TMessageType.EXCEPTION:
4009 
      x = TApplicationException()
4010 
      x.read(self._iprot)
4011 
      self._iprot.readMessageEnd()
4012 
      raise x
4013 
    result = addDelayReason_result()
4014 
    result.read(self._iprot)
4015 
    self._iprot.readMessageEnd()
4016 
    if result.success is not None:
4017 
      return result.success
4018 
    if result.ex is not None:
4019 
      raise result.ex
4020 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "addDelayReason failed: unknown result");
4021 
 
3956 chandransh 4022 
  def reconcileCodCollection(self, collectedAmountMap, xferBy, xferTxnId, xferDate):
4023 
    """
4024 
    Marks the COD orders with given AWB nos. as having been processed.
4025 
    Updates the captured amount for the corresponding payment.
3553 chandransh 4026 
 
3956 chandransh 4027 
    Returns a map of AWBs which were not processed and the associated reason. An AWB is not processed if:
4028 
    1. There is no order corresponding to an AWB number.
4029 
    2. The captured amount for a payment exceeds the total payment.
4030 
    3. The order corresponding to an AWB no. is in a state prior to DELIVERY_SUCCESS.
4031 
 
4032 
    Parameters:
4033 
     - collectedAmountMap
4034 
     - xferBy
4035 
     - xferTxnId
4036 
     - xferDate
4037 
    """
4038 
    self.send_reconcileCodCollection(collectedAmountMap, xferBy, xferTxnId, xferDate)
4039 
    return self.recv_reconcileCodCollection()
4040 
 
4041 
  def send_reconcileCodCollection(self, collectedAmountMap, xferBy, xferTxnId, xferDate):
4042 
    self._oprot.writeMessageBegin('reconcileCodCollection', TMessageType.CALL, self._seqid)
4043 
    args = reconcileCodCollection_args()
4044 
    args.collectedAmountMap = collectedAmountMap
4045 
    args.xferBy = xferBy
4046 
    args.xferTxnId = xferTxnId
4047 
    args.xferDate = xferDate
4048 
    args.write(self._oprot)
4049 
    self._oprot.writeMessageEnd()
4050 
    self._oprot.trans.flush()
4051 
 
4052 
  def recv_reconcileCodCollection(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 = reconcileCodCollection_result()
4060 
    result.read(self._iprot)
4061 
    self._iprot.readMessageEnd()
4062 
    if result.success is not None:
4063 
      return result.success
4064 
    if result.ex is not None:
4065 
      raise result.ex
4066 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "reconcileCodCollection failed: unknown result");
4067 
 
4008 mandeep.dh 4068 
  def getTransactionsRequiringExtraProcessing(self, category):
4069 
    """
4065 mandeep.dh 4070 
    Returns the list of transaction ids that require some extra processing and
4008 mandeep.dh 4071 
    which belong to a particular category. This is currently used by CRM
4065 mandeep.dh 4072 
    application. If no such transaction ids are present, it returns an empty list.
3956 chandransh 4073 
 
4008 mandeep.dh 4074 
    Parameters:
4075 
     - category
4076 
    """
4077 
    self.send_getTransactionsRequiringExtraProcessing(category)
4078 
    return self.recv_getTransactionsRequiringExtraProcessing()
4079 
 
4080 
  def send_getTransactionsRequiringExtraProcessing(self, category):
4081 
    self._oprot.writeMessageBegin('getTransactionsRequiringExtraProcessing', TMessageType.CALL, self._seqid)
4082 
    args = getTransactionsRequiringExtraProcessing_args()
4083 
    args.category = category
4084 
    args.write(self._oprot)
4085 
    self._oprot.writeMessageEnd()
4086 
    self._oprot.trans.flush()
4087 
 
4088 
  def recv_getTransactionsRequiringExtraProcessing(self, ):
4089 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4090 
    if mtype == TMessageType.EXCEPTION:
4091 
      x = TApplicationException()
4092 
      x.read(self._iprot)
4093 
      self._iprot.readMessageEnd()
4094 
      raise x
4095 
    result = getTransactionsRequiringExtraProcessing_result()
4096 
    result.read(self._iprot)
4097 
    self._iprot.readMessageEnd()
4098 
    if result.success is not None:
4099 
      return result.success
4100 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getTransactionsRequiringExtraProcessing failed: unknown result");
4101 
 
4102 
  def markTransactionAsProcessed(self, transactionId, category):
4103 
    """
4104 
    Marks a particular transaction as processed for a particular cateogory.
4065 mandeep.dh 4105 
    It essentially deletes the transaction id record for a particular
4106 
    processing type category (if present) from DB.
4107 
    This is currently used by CRM application.
4008 mandeep.dh 4108 
 
4109 
    Parameters:
4110 
     - transactionId
4111 
     - category
4112 
    """
4113 
    self.send_markTransactionAsProcessed(transactionId, category)
4114 
    self.recv_markTransactionAsProcessed()
4115 
 
4116 
  def send_markTransactionAsProcessed(self, transactionId, category):
4117 
    self._oprot.writeMessageBegin('markTransactionAsProcessed', TMessageType.CALL, self._seqid)
4118 
    args = markTransactionAsProcessed_args()
4119 
    args.transactionId = transactionId
4120 
    args.category = category
4121 
    args.write(self._oprot)
4122 
    self._oprot.writeMessageEnd()
4123 
    self._oprot.trans.flush()
4124 
 
4125 
  def recv_markTransactionAsProcessed(self, ):
4126 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4127 
    if mtype == TMessageType.EXCEPTION:
4128 
      x = TApplicationException()
4129 
      x.read(self._iprot)
4130 
      self._iprot.readMessageEnd()
4131 
      raise x
4132 
    result = markTransactionAsProcessed_result()
4133 
    result.read(self._iprot)
4134 
    self._iprot.readMessageEnd()
4135 
    return
4136 
 
4018 chandransh 4137 
  def getItemWiseRiskyOrdersCount(self, ):
4138 
    """
4139 
    Returns a map containing the number of risky orders keyed by item id. A risky order
4140 
    is defined as one whose shipping date is about to expire.
4141 
    """
4142 
    self.send_getItemWiseRiskyOrdersCount()
4143 
    return self.recv_getItemWiseRiskyOrdersCount()
4008 mandeep.dh 4144 
 
4018 chandransh 4145 
  def send_getItemWiseRiskyOrdersCount(self, ):
4146 
    self._oprot.writeMessageBegin('getItemWiseRiskyOrdersCount', TMessageType.CALL, self._seqid)
4147 
    args = getItemWiseRiskyOrdersCount_args()
4148 
    args.write(self._oprot)
4149 
    self._oprot.writeMessageEnd()
4150 
    self._oprot.trans.flush()
4151 
 
4152 
  def recv_getItemWiseRiskyOrdersCount(self, ):
4153 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4154 
    if mtype == TMessageType.EXCEPTION:
4155 
      x = TApplicationException()
4156 
      x.read(self._iprot)
4157 
      self._iprot.readMessageEnd()
4158 
      raise x
4159 
    result = getItemWiseRiskyOrdersCount_result()
4160 
    result.read(self._iprot)
4161 
    self._iprot.readMessageEnd()
4162 
    if result.success is not None:
4163 
      return result.success
4164 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getItemWiseRiskyOrdersCount failed: unknown result");
4165 
 
4295 varun.gupt 4166 
  def getOrdersForItemIds(self, itemIds):
4167 
    """
4168 
    Returns a list of all orders which have items with given id
4169 
 
4170 
    Parameters:
4171 
     - itemIds
4172 
    """
4173 
    self.send_getOrdersForItemIds(itemIds)
4174 
    return self.recv_getOrdersForItemIds()
4175 
 
4176 
  def send_getOrdersForItemIds(self, itemIds):
4177 
    self._oprot.writeMessageBegin('getOrdersForItemIds', TMessageType.CALL, self._seqid)
4178 
    args = getOrdersForItemIds_args()
4179 
    args.itemIds = itemIds
4180 
    args.write(self._oprot)
4181 
    self._oprot.writeMessageEnd()
4182 
    self._oprot.trans.flush()
4183 
 
4184 
  def recv_getOrdersForItemIds(self, ):
4185 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4186 
    if mtype == TMessageType.EXCEPTION:
4187 
      x = TApplicationException()
4188 
      x.read(self._iprot)
4189 
      self._iprot.readMessageEnd()
4190 
      raise x
4191 
    result = getOrdersForItemIds_result()
4192 
    result.read(self._iprot)
4193 
    self._iprot.readMessageEnd()
4194 
    if result.success is not None:
4195 
      return result.success
4196 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getOrdersForItemIds failed: unknown result");
4197 
 
4247 rajveer 4198 
  def markOrderCancellationRequestReceived(self, orderId):
4199 
    """
4200 
    Mark order as cancellation request received. If customer sends request of cancellation of
4201 
    a particular order, this method will be called. It will just change status of the order
4202 
    depending on its current status. It also records the previous status, so that we can move
4203 
    back to that status if cancellation request is denied.
4018 chandransh 4204 
 
4247 rajveer 4205 
    Parameters:
4206 
     - orderId
4207 
    """
4208 
    self.send_markOrderCancellationRequestReceived(orderId)
4209 
    self.recv_markOrderCancellationRequestReceived()
4210 
 
4211 
  def send_markOrderCancellationRequestReceived(self, orderId):
4212 
    self._oprot.writeMessageBegin('markOrderCancellationRequestReceived', TMessageType.CALL, self._seqid)
4213 
    args = markOrderCancellationRequestReceived_args()
4214 
    args.orderId = orderId
4215 
    args.write(self._oprot)
4216 
    self._oprot.writeMessageEnd()
4217 
    self._oprot.trans.flush()
4218 
 
4219 
  def recv_markOrderCancellationRequestReceived(self, ):
4220 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4221 
    if mtype == TMessageType.EXCEPTION:
4222 
      x = TApplicationException()
4223 
      x.read(self._iprot)
4224 
      self._iprot.readMessageEnd()
4225 
      raise x
4226 
    result = markOrderCancellationRequestReceived_result()
4227 
    result.read(self._iprot)
4228 
    self._iprot.readMessageEnd()
4229 
    if result.ex is not None:
4230 
      raise result.ex
4231 
    return
4232 
 
4233 
  def markOrderCancellationRequestConfirmed(self, orderId):
4234 
    """
4235 
    If we decide to to cancel order, CRM will call this method to move the status of order to
4236 
    cancellation request confirmed. After this OM will be able to cancel the order.
4237 
 
4238 
    Parameters:
4239 
     - orderId
4240 
    """
4241 
    self.send_markOrderCancellationRequestConfirmed(orderId)
4242 
    self.recv_markOrderCancellationRequestConfirmed()
4243 
 
4244 
  def send_markOrderCancellationRequestConfirmed(self, orderId):
4245 
    self._oprot.writeMessageBegin('markOrderCancellationRequestConfirmed', TMessageType.CALL, self._seqid)
4246 
    args = markOrderCancellationRequestConfirmed_args()
4247 
    args.orderId = orderId
4248 
    args.write(self._oprot)
4249 
    self._oprot.writeMessageEnd()
4250 
    self._oprot.trans.flush()
4251 
 
4252 
  def recv_markOrderCancellationRequestConfirmed(self, ):
4253 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4254 
    if mtype == TMessageType.EXCEPTION:
4255 
      x = TApplicationException()
4256 
      x.read(self._iprot)
4257 
      self._iprot.readMessageEnd()
4258 
      raise x
4259 
    result = markOrderCancellationRequestConfirmed_result()
4260 
    result.read(self._iprot)
4261 
    self._iprot.readMessageEnd()
4262 
    if result.ex is not None:
4263 
      raise result.ex
4264 
    return
4265 
 
4266 
  def markOrderCancellationRequestDenied(self, orderId):
4267 
    """
4268 
    If we decide to not to cancel order, we will move the order ro previous status.
4269 
 
4270 
    Parameters:
4271 
     - orderId
4272 
    """
4273 
    self.send_markOrderCancellationRequestDenied(orderId)
4274 
    self.recv_markOrderCancellationRequestDenied()
4275 
 
4276 
  def send_markOrderCancellationRequestDenied(self, orderId):
4277 
    self._oprot.writeMessageBegin('markOrderCancellationRequestDenied', TMessageType.CALL, self._seqid)
4278 
    args = markOrderCancellationRequestDenied_args()
4279 
    args.orderId = orderId
4280 
    args.write(self._oprot)
4281 
    self._oprot.writeMessageEnd()
4282 
    self._oprot.trans.flush()
4283 
 
4284 
  def recv_markOrderCancellationRequestDenied(self, ):
4285 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4286 
    if mtype == TMessageType.EXCEPTION:
4287 
      x = TApplicationException()
4288 
      x.read(self._iprot)
4289 
      self._iprot.readMessageEnd()
4290 
      raise x
4291 
    result = markOrderCancellationRequestDenied_result()
4292 
    result.read(self._iprot)
4293 
    self._iprot.readMessageEnd()
4294 
    if result.ex is not None:
4295 
      raise result.ex
4296 
    return
4297 
 
4258 rajveer 4298 
  def markTransactionAsPaymentFlagRemoved(self, transactionId):
4247 rajveer 4299 
    """
4258 rajveer 4300 
    If we and/or payment gateway has decided to accept the payment, this method needs to be called.
4301 
    Changed transaction and all orders status to payment accepted.
4247 rajveer 4302 
 
4303 
    Parameters:
4258 rajveer 4304 
     - transactionId
4247 rajveer 4305 
    """
4258 rajveer 4306 
    self.send_markTransactionAsPaymentFlagRemoved(transactionId)
4307 
    self.recv_markTransactionAsPaymentFlagRemoved()
4247 rajveer 4308 
 
4258 rajveer 4309 
  def send_markTransactionAsPaymentFlagRemoved(self, transactionId):
4310 
    self._oprot.writeMessageBegin('markTransactionAsPaymentFlagRemoved', TMessageType.CALL, self._seqid)
4311 
    args = markTransactionAsPaymentFlagRemoved_args()
4312 
    args.transactionId = transactionId
4247 rajveer 4313 
    args.write(self._oprot)
4314 
    self._oprot.writeMessageEnd()
4315 
    self._oprot.trans.flush()
4316 
 
4258 rajveer 4317 
  def recv_markTransactionAsPaymentFlagRemoved(self, ):
4247 rajveer 4318 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4319 
    if mtype == TMessageType.EXCEPTION:
4320 
      x = TApplicationException()
4321 
      x.read(self._iprot)
4322 
      self._iprot.readMessageEnd()
4323 
      raise x
4258 rajveer 4324 
    result = markTransactionAsPaymentFlagRemoved_result()
4247 rajveer 4325 
    result.read(self._iprot)
4326 
    self._iprot.readMessageEnd()
4327 
    if result.ex is not None:
4328 
      raise result.ex
4329 
    return
4330 
 
4259 anupam.sin 4331 
  def refundTransaction(self, transactionId, refundedBy, reason):
4332 
    """
4333 
    This method is called when a flagged payment is deemed unserviceable and the corresponding orders
4334 
    need to be cancelled
4247 rajveer 4335 
 
4259 anupam.sin 4336 
    Parameters:
4337 
     - transactionId
4338 
     - refundedBy
4339 
     - reason
4340 
    """
4341 
    self.send_refundTransaction(transactionId, refundedBy, reason)
4342 
    self.recv_refundTransaction()
4343 
 
4344 
  def send_refundTransaction(self, transactionId, refundedBy, reason):
4345 
    self._oprot.writeMessageBegin('refundTransaction', TMessageType.CALL, self._seqid)
4346 
    args = refundTransaction_args()
4347 
    args.transactionId = transactionId
4348 
    args.refundedBy = refundedBy
4349 
    args.reason = reason
4350 
    args.write(self._oprot)
4351 
    self._oprot.writeMessageEnd()
4352 
    self._oprot.trans.flush()
4353 
 
4354 
  def recv_refundTransaction(self, ):
4355 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4356 
    if mtype == TMessageType.EXCEPTION:
4357 
      x = TApplicationException()
4358 
      x.read(self._iprot)
4359 
      self._iprot.readMessageEnd()
4360 
      raise x
4361 
    result = refundTransaction_result()
4362 
    result.read(self._iprot)
4363 
    self._iprot.readMessageEnd()
4364 
    if result.ex is not None:
4365 
      raise result.ex
4366 
    return
4367 
 
4324 mandeep.dh 4368 
  def updateShipmentAddress(self, orderId, addressId):
4369 
    """
4370 
    Updates shipment address of an order. Delivery and shipping date estimates
4371 
    etc. are also updated here.
4372 
 
4373 
    Throws TransactionServiceException in case address change is not
4374 
    possible due to certain reasons such as new pincode in address is
4375 
    not serviceable etc.
4376 
 
4377 
    Parameters:
4378 
     - orderId
4379 
     - addressId
4380 
    """
4381 
    self.send_updateShipmentAddress(orderId, addressId)
4382 
    self.recv_updateShipmentAddress()
4383 
 
4384 
  def send_updateShipmentAddress(self, orderId, addressId):
4385 
    self._oprot.writeMessageBegin('updateShipmentAddress', TMessageType.CALL, self._seqid)
4386 
    args = updateShipmentAddress_args()
4387 
    args.orderId = orderId
4388 
    args.addressId = addressId
4389 
    args.write(self._oprot)
4390 
    self._oprot.writeMessageEnd()
4391 
    self._oprot.trans.flush()
4392 
 
4393 
  def recv_updateShipmentAddress(self, ):
4394 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4395 
    if mtype == TMessageType.EXCEPTION:
4396 
      x = TApplicationException()
4397 
      x.read(self._iprot)
4398 
      self._iprot.readMessageEnd()
4399 
      raise x
4400 
    result = updateShipmentAddress_result()
4401 
    result.read(self._iprot)
4402 
    self._iprot.readMessageEnd()
4403 
    if result.ex is not None:
4404 
      raise result.ex
4405 
    return
4406 
 
4285 rajveer 4407 
  def acceptOrdersForItemId(self, itemId, inventory):
4408 
    """
4409 
    Marks the orders as ACCEPTED for the given itemId and inventory. It also updates the accepted timestamp. If the
4410 
    given order is not a COD order, it also captures the payment if the same has not been captured.
4259 anupam.sin 4411 
 
4285 rajveer 4412 
    Parameters:
4413 
     - itemId
4414 
     - inventory
4415 
    """
4416 
    self.send_acceptOrdersForItemId(itemId, inventory)
4417 
    return self.recv_acceptOrdersForItemId()
4418 
 
4419 
  def send_acceptOrdersForItemId(self, itemId, inventory):
4420 
    self._oprot.writeMessageBegin('acceptOrdersForItemId', TMessageType.CALL, self._seqid)
4421 
    args = acceptOrdersForItemId_args()
4422 
    args.itemId = itemId
4423 
    args.inventory = inventory
4424 
    args.write(self._oprot)
4425 
    self._oprot.writeMessageEnd()
4426 
    self._oprot.trans.flush()
4427 
 
4428 
  def recv_acceptOrdersForItemId(self, ):
4429 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4430 
    if mtype == TMessageType.EXCEPTION:
4431 
      x = TApplicationException()
4432 
      x.read(self._iprot)
4433 
      self._iprot.readMessageEnd()
4434 
      raise x
4435 
    result = acceptOrdersForItemId_result()
4436 
    result.read(self._iprot)
4437 
    self._iprot.readMessageEnd()
4438 
    if result.success is not None:
4439 
      return result.success
4440 
    if result.ex is not None:
4441 
      raise result.ex
4442 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "acceptOrdersForItemId failed: unknown result");
4443 
 
4369 rajveer 4444 
  def markOrdersAsPORaised(self, vendorId, itemId, quantity, estimate, isReminder):
4303 rajveer 4445 
    """
4446 
    Parameters:
4447 
     - vendorId
4448 
     - itemId
4449 
     - quantity
4450 
     - estimate
4369 rajveer 4451 
     - isReminder
4303 rajveer 4452 
    """
4369 rajveer 4453 
    self.send_markOrdersAsPORaised(vendorId, itemId, quantity, estimate, isReminder)
4303 rajveer 4454 
    self.recv_markOrdersAsPORaised()
4285 rajveer 4455 
 
4369 rajveer 4456 
  def send_markOrdersAsPORaised(self, vendorId, itemId, quantity, estimate, isReminder):
4303 rajveer 4457 
    self._oprot.writeMessageBegin('markOrdersAsPORaised', TMessageType.CALL, self._seqid)
4458 
    args = markOrdersAsPORaised_args()
4459 
    args.vendorId = vendorId
4460 
    args.itemId = itemId
4461 
    args.quantity = quantity
4462 
    args.estimate = estimate
4369 rajveer 4463 
    args.isReminder = isReminder
4303 rajveer 4464 
    args.write(self._oprot)
4465 
    self._oprot.writeMessageEnd()
4466 
    self._oprot.trans.flush()
4467 
 
4468 
  def recv_markOrdersAsPORaised(self, ):
4469 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4470 
    if mtype == TMessageType.EXCEPTION:
4471 
      x = TApplicationException()
4472 
      x.read(self._iprot)
4473 
      self._iprot.readMessageEnd()
4474 
      raise x
4475 
    result = markOrdersAsPORaised_result()
4476 
    result.read(self._iprot)
4477 
    self._iprot.readMessageEnd()
4478 
    if result.ex is not None:
4479 
      raise result.ex
4480 
    return
4481 
 
4369 rajveer 4482 
  def markOrdersAsReversalInitiated(self, vendorId, itemId, quantity, estimate, isReminder):
4303 rajveer 4483 
    """
4484 
    Parameters:
4485 
     - vendorId
4486 
     - itemId
4487 
     - quantity
4488 
     - estimate
4369 rajveer 4489 
     - isReminder
4303 rajveer 4490 
    """
4369 rajveer 4491 
    self.send_markOrdersAsReversalInitiated(vendorId, itemId, quantity, estimate, isReminder)
4303 rajveer 4492 
    self.recv_markOrdersAsReversalInitiated()
4493 
 
4369 rajveer 4494 
  def send_markOrdersAsReversalInitiated(self, vendorId, itemId, quantity, estimate, isReminder):
4303 rajveer 4495 
    self._oprot.writeMessageBegin('markOrdersAsReversalInitiated', TMessageType.CALL, self._seqid)
4496 
    args = markOrdersAsReversalInitiated_args()
4497 
    args.vendorId = vendorId
4498 
    args.itemId = itemId
4499 
    args.quantity = quantity
4500 
    args.estimate = estimate
4369 rajveer 4501 
    args.isReminder = isReminder
4303 rajveer 4502 
    args.write(self._oprot)
4503 
    self._oprot.writeMessageEnd()
4504 
    self._oprot.trans.flush()
4505 
 
4506 
  def recv_markOrdersAsReversalInitiated(self, ):
4507 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4508 
    if mtype == TMessageType.EXCEPTION:
4509 
      x = TApplicationException()
4510 
      x.read(self._iprot)
4511 
      self._iprot.readMessageEnd()
4512 
      raise x
4513 
    result = markOrdersAsReversalInitiated_result()
4514 
    result.read(self._iprot)
4515 
    self._iprot.readMessageEnd()
4516 
    if result.ex is not None:
4517 
      raise result.ex
4518 
    return
4519 
 
4369 rajveer 4520 
  def markOrdersAsNotAvailabke(self, vendorId, itemId, quantity, estimate, isReminder):
4303 rajveer 4521 
    """
4522 
    Parameters:
4523 
     - vendorId
4524 
     - itemId
4525 
     - quantity
4526 
     - estimate
4369 rajveer 4527 
     - isReminder
4303 rajveer 4528 
    """
4369 rajveer 4529 
    self.send_markOrdersAsNotAvailabke(vendorId, itemId, quantity, estimate, isReminder)
4303 rajveer 4530 
    self.recv_markOrdersAsNotAvailabke()
4531 
 
4369 rajveer 4532 
  def send_markOrdersAsNotAvailabke(self, vendorId, itemId, quantity, estimate, isReminder):
4303 rajveer 4533 
    self._oprot.writeMessageBegin('markOrdersAsNotAvailabke', TMessageType.CALL, self._seqid)
4534 
    args = markOrdersAsNotAvailabke_args()
4535 
    args.vendorId = vendorId
4536 
    args.itemId = itemId
4537 
    args.quantity = quantity
4538 
    args.estimate = estimate
4369 rajveer 4539 
    args.isReminder = isReminder
4303 rajveer 4540 
    args.write(self._oprot)
4541 
    self._oprot.writeMessageEnd()
4542 
    self._oprot.trans.flush()
4543 
 
4544 
  def recv_markOrdersAsNotAvailabke(self, ):
4545 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4546 
    if mtype == TMessageType.EXCEPTION:
4547 
      x = TApplicationException()
4548 
      x.read(self._iprot)
4549 
      self._iprot.readMessageEnd()
4550 
      raise x
4551 
    result = markOrdersAsNotAvailabke_result()
4552 
    result.read(self._iprot)
4553 
    self._iprot.readMessageEnd()
4554 
    if result.ex is not None:
4555 
      raise result.ex
4556 
    return
4557 
 
4369 rajveer 4558 
  def markOrdersAsTimeout(self, vendorId):
4559 
    """
4560 
    Parameters:
4561 
     - vendorId
4562 
    """
4563 
    self.send_markOrdersAsTimeout(vendorId)
4564 
    return self.recv_markOrdersAsTimeout()
4303 rajveer 4565 
 
4369 rajveer 4566 
  def send_markOrdersAsTimeout(self, vendorId):
4567 
    self._oprot.writeMessageBegin('markOrdersAsTimeout', TMessageType.CALL, self._seqid)
4568 
    args = markOrdersAsTimeout_args()
4569 
    args.vendorId = vendorId
4570 
    args.write(self._oprot)
4571 
    self._oprot.writeMessageEnd()
4572 
    self._oprot.trans.flush()
4573 
 
4574 
  def recv_markOrdersAsTimeout(self, ):
4575 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4576 
    if mtype == TMessageType.EXCEPTION:
4577 
      x = TApplicationException()
4578 
      x.read(self._iprot)
4579 
      self._iprot.readMessageEnd()
4580 
      raise x
4581 
    result = markOrdersAsTimeout_result()
4582 
    result.read(self._iprot)
4583 
    self._iprot.readMessageEnd()
4584 
    if result.success is not None:
4585 
      return result.success
4586 
    if result.ex is not None:
4587 
      raise result.ex
4588 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "markOrdersAsTimeout failed: unknown result");
4589 
 
4662 rajveer 4590 
  def markOrderAsLostInTransit(self, orderId):
4591 
    """
4592 
    Mark order as LOST_IN_TRANSIT
4593 
 
4594 
    Parameters:
4595 
     - orderId
4596 
    """
4597 
    self.send_markOrderAsLostInTransit(orderId)
4598 
    return self.recv_markOrderAsLostInTransit()
4599 
 
4600 
  def send_markOrderAsLostInTransit(self, orderId):
4601 
    self._oprot.writeMessageBegin('markOrderAsLostInTransit', TMessageType.CALL, self._seqid)
4602 
    args = markOrderAsLostInTransit_args()
4603 
    args.orderId = orderId
4604 
    args.write(self._oprot)
4605 
    self._oprot.writeMessageEnd()
4606 
    self._oprot.trans.flush()
4607 
 
4608 
  def recv_markOrderAsLostInTransit(self, ):
4609 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4610 
    if mtype == TMessageType.EXCEPTION:
4611 
      x = TApplicationException()
4612 
      x.read(self._iprot)
4613 
      self._iprot.readMessageEnd()
4614 
      raise x
4615 
    result = markOrderAsLostInTransit_result()
4616 
    result.read(self._iprot)
4617 
    self._iprot.readMessageEnd()
4618 
    if result.success is not None:
4619 
      return result.success
4620 
    if result.ex is not None:
4621 
      raise result.ex
4622 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "markOrderAsLostInTransit failed: unknown result");
4623 
 
4386 anupam.sin 4624 
  def getOrderForAwb(self, awb):
4625 
    """
4626 
    Returns the order corresponding to an AWB number
4369 rajveer 4627 
 
4386 anupam.sin 4628 
    Parameters:
4629 
     - awb
4630 
    """
4631 
    self.send_getOrderForAwb(awb)
4632 
    return self.recv_getOrderForAwb()
4633 
 
4634 
  def send_getOrderForAwb(self, awb):
4635 
    self._oprot.writeMessageBegin('getOrderForAwb', TMessageType.CALL, self._seqid)
4636 
    args = getOrderForAwb_args()
4637 
    args.awb = awb
4638 
    args.write(self._oprot)
4639 
    self._oprot.writeMessageEnd()
4640 
    self._oprot.trans.flush()
4641 
 
4642 
  def recv_getOrderForAwb(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 = getOrderForAwb_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, "getOrderForAwb failed: unknown result");
4657 
 
4910 phani.kuma 4658 
  def getOrdersForProviderForStatus(self, logistics_provider_id, order_status_list):
4506 phani.kuma 4659 
    """
4910 phani.kuma 4660 
    Returns the order corresponding to a logistics provider id for a given list of order status
4386 anupam.sin 4661 
 
4506 phani.kuma 4662 
    Parameters:
4663 
     - logistics_provider_id
4910 phani.kuma 4664 
     - order_status_list
4506 phani.kuma 4665 
    """
4910 phani.kuma 4666 
    self.send_getOrdersForProviderForStatus(logistics_provider_id, order_status_list)
4506 phani.kuma 4667 
    return self.recv_getOrdersForProviderForStatus()
4668 
 
4910 phani.kuma 4669 
  def send_getOrdersForProviderForStatus(self, logistics_provider_id, order_status_list):
4506 phani.kuma 4670 
    self._oprot.writeMessageBegin('getOrdersForProviderForStatus', TMessageType.CALL, self._seqid)
4671 
    args = getOrdersForProviderForStatus_args()
4672 
    args.logistics_provider_id = logistics_provider_id
4910 phani.kuma 4673 
    args.order_status_list = order_status_list
4506 phani.kuma 4674 
    args.write(self._oprot)
4675 
    self._oprot.writeMessageEnd()
4676 
    self._oprot.trans.flush()
4677 
 
4678 
  def recv_getOrdersForProviderForStatus(self, ):
4679 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4680 
    if mtype == TMessageType.EXCEPTION:
4681 
      x = TApplicationException()
4682 
      x.read(self._iprot)
4683 
      self._iprot.readMessageEnd()
4684 
      raise x
4685 
    result = getOrdersForProviderForStatus_result()
4686 
    result.read(self._iprot)
4687 
    self._iprot.readMessageEnd()
4688 
    if result.success is not None:
4689 
      return result.success
4690 
    if result.ex is not None:
4691 
      raise result.ex
4692 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getOrdersForProviderForStatus failed: unknown result");
4693 
 
4600 varun.gupt 4694 
  def getBilledOrdersForVendor(self, vendorId, billingDateFrom, billingDateTo):
4695 
    """
4696 
    Returns list of orders fullfiled from a certain vendor and billed in a given date range
4506 phani.kuma 4697 
 
4600 varun.gupt 4698 
    Parameters:
4699 
     - vendorId
4700 
     - billingDateFrom
4701 
     - billingDateTo
4702 
    """
4703 
    self.send_getBilledOrdersForVendor(vendorId, billingDateFrom, billingDateTo)
4704 
    return self.recv_getBilledOrdersForVendor()
4705 
 
4706 
  def send_getBilledOrdersForVendor(self, vendorId, billingDateFrom, billingDateTo):
4707 
    self._oprot.writeMessageBegin('getBilledOrdersForVendor', TMessageType.CALL, self._seqid)
4708 
    args = getBilledOrdersForVendor_args()
4709 
    args.vendorId = vendorId
4710 
    args.billingDateFrom = billingDateFrom
4711 
    args.billingDateTo = billingDateTo
4712 
    args.write(self._oprot)
4713 
    self._oprot.writeMessageEnd()
4714 
    self._oprot.trans.flush()
4715 
 
4716 
  def recv_getBilledOrdersForVendor(self, ):
4717 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4718 
    if mtype == TMessageType.EXCEPTION:
4719 
      x = TApplicationException()
4720 
      x.read(self._iprot)
4721 
      self._iprot.readMessageEnd()
4722 
      raise x
4723 
    result = getBilledOrdersForVendor_result()
4724 
    result.read(self._iprot)
4725 
    self._iprot.readMessageEnd()
4726 
    if result.success is not None:
4727 
      return result.success
4728 
    if result.ex is not None:
4729 
      raise result.ex
4730 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getBilledOrdersForVendor failed: unknown result");
4731 
 
4607 rajveer 4732 
  def getSlippedSippingDateOrders(self, ):
4733 
    self.send_getSlippedSippingDateOrders()
4734 
    return self.recv_getSlippedSippingDateOrders()
4735 
 
4736 
  def send_getSlippedSippingDateOrders(self, ):
4737 
    self._oprot.writeMessageBegin('getSlippedSippingDateOrders', TMessageType.CALL, self._seqid)
4738 
    args = getSlippedSippingDateOrders_args()
4739 
    args.write(self._oprot)
4740 
    self._oprot.writeMessageEnd()
4741 
    self._oprot.trans.flush()
4742 
 
4743 
  def recv_getSlippedSippingDateOrders(self, ):
4744 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4745 
    if mtype == TMessageType.EXCEPTION:
4746 
      x = TApplicationException()
4747 
      x.read(self._iprot)
4748 
      self._iprot.readMessageEnd()
4749 
      raise x
4750 
    result = getSlippedSippingDateOrders_result()
4751 
    result.read(self._iprot)
4752 
    self._iprot.readMessageEnd()
4753 
    if result.success is not None:
4754 
      return result.success
4755 
    if result.ex is not None:
4756 
      raise result.ex
4757 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getSlippedSippingDateOrders failed: unknown result");
4758 
 
4709 rajveer 4759 
  def getCancelledOrders(self, cancelDateFrom, cancelDateTo):
4760 
    """
4761 
    Parameters:
4762 
     - cancelDateFrom
4763 
     - cancelDateTo
4764 
    """
4765 
    self.send_getCancelledOrders(cancelDateFrom, cancelDateTo)
4766 
    return self.recv_getCancelledOrders()
4767 
 
4768 
  def send_getCancelledOrders(self, cancelDateFrom, cancelDateTo):
4769 
    self._oprot.writeMessageBegin('getCancelledOrders', TMessageType.CALL, self._seqid)
4770 
    args = getCancelledOrders_args()
4771 
    args.cancelDateFrom = cancelDateFrom
4772 
    args.cancelDateTo = cancelDateTo
4773 
    args.write(self._oprot)
4774 
    self._oprot.writeMessageEnd()
4775 
    self._oprot.trans.flush()
4776 
 
4777 
  def recv_getCancelledOrders(self, ):
4778 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4779 
    if mtype == TMessageType.EXCEPTION:
4780 
      x = TApplicationException()
4781 
      x.read(self._iprot)
4782 
      self._iprot.readMessageEnd()
4783 
      raise x
4784 
    result = getCancelledOrders_result()
4785 
    result.read(self._iprot)
4786 
    self._iprot.readMessageEnd()
4787 
    if result.success is not None:
4788 
      return result.success
4789 
    if result.ex is not None:
4790 
      raise result.ex
4791 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getCancelledOrders failed: unknown result");
4792 
 
4600 varun.gupt 4793 
  def saveBluedartSettlements(self, mapAWBAndAmount):
4794 
    """
4795 
    Parameters:
4796 
     - mapAWBAndAmount
4797 
    """
4798 
    self.send_saveBluedartSettlements(mapAWBAndAmount)
4799 
    self.recv_saveBluedartSettlements()
4800 
 
4801 
  def send_saveBluedartSettlements(self, mapAWBAndAmount):
4802 
    self._oprot.writeMessageBegin('saveBluedartSettlements', TMessageType.CALL, self._seqid)
4803 
    args = saveBluedartSettlements_args()
4804 
    args.mapAWBAndAmount = mapAWBAndAmount
4805 
    args.write(self._oprot)
4806 
    self._oprot.writeMessageEnd()
4807 
    self._oprot.trans.flush()
4808 
 
4809 
  def recv_saveBluedartSettlements(self, ):
4810 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4811 
    if mtype == TMessageType.EXCEPTION:
4812 
      x = TApplicationException()
4813 
      x.read(self._iprot)
4814 
      self._iprot.readMessageEnd()
4815 
      raise x
4816 
    result = saveBluedartSettlements_result()
4817 
    result.read(self._iprot)
4818 
    self._iprot.readMessageEnd()
4819 
    if result.ex is not None:
4820 
      raise result.ex
4821 
    return
4822 
 
4905 varun.gupt 4823 
  def savePaymentSettlements(self, settlementDate, paymentGatewayId, referenceId, serviceTax, otherCharges, netCollection):
4600 varun.gupt 4824 
    """
4825 
    Parameters:
4826 
     - settlementDate
4827 
     - paymentGatewayId
4905 varun.gupt 4828 
     - referenceId
4600 varun.gupt 4829 
     - serviceTax
4830 
     - otherCharges
4831 
     - netCollection
4832 
    """
4905 varun.gupt 4833 
    self.send_savePaymentSettlements(settlementDate, paymentGatewayId, referenceId, serviceTax, otherCharges, netCollection)
4600 varun.gupt 4834 
    self.recv_savePaymentSettlements()
4835 
 
4905 varun.gupt 4836 
  def send_savePaymentSettlements(self, settlementDate, paymentGatewayId, referenceId, serviceTax, otherCharges, netCollection):
4600 varun.gupt 4837 
    self._oprot.writeMessageBegin('savePaymentSettlements', TMessageType.CALL, self._seqid)
4838 
    args = savePaymentSettlements_args()
4839 
    args.settlementDate = settlementDate
4840 
    args.paymentGatewayId = paymentGatewayId
4905 varun.gupt 4841 
    args.referenceId = referenceId
4600 varun.gupt 4842 
    args.serviceTax = serviceTax
4843 
    args.otherCharges = otherCharges
4844 
    args.netCollection = netCollection
4845 
    args.write(self._oprot)
4846 
    self._oprot.writeMessageEnd()
4847 
    self._oprot.trans.flush()
4848 
 
4849 
  def recv_savePaymentSettlements(self, ):
4850 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4851 
    if mtype == TMessageType.EXCEPTION:
4852 
      x = TApplicationException()
4853 
      x.read(self._iprot)
4854 
      self._iprot.readMessageEnd()
4855 
      raise x
4856 
    result = savePaymentSettlements_result()
4857 
    result.read(self._iprot)
4858 
    self._iprot.readMessageEnd()
4859 
    if result.ex is not None:
4860 
      raise result.ex
4861 
    return
4862 
 
4863 
  def saveEBSSettlementSummary(self, settlementId, settlementDate, transactionDateFrom, transactionDateTo, amount):
4864 
    """
4865 
    Parameters:
4866 
     - settlementId
4867 
     - settlementDate
4868 
     - transactionDateFrom
4869 
     - transactionDateTo
4870 
     - amount
4871 
    """
4872 
    self.send_saveEBSSettlementSummary(settlementId, settlementDate, transactionDateFrom, transactionDateTo, amount)
4873 
    self.recv_saveEBSSettlementSummary()
4874 
 
4875 
  def send_saveEBSSettlementSummary(self, settlementId, settlementDate, transactionDateFrom, transactionDateTo, amount):
4876 
    self._oprot.writeMessageBegin('saveEBSSettlementSummary', TMessageType.CALL, self._seqid)
4877 
    args = saveEBSSettlementSummary_args()
4878 
    args.settlementId = settlementId
4879 
    args.settlementDate = settlementDate
4880 
    args.transactionDateFrom = transactionDateFrom
4881 
    args.transactionDateTo = transactionDateTo
4882 
    args.amount = amount
4883 
    args.write(self._oprot)
4884 
    self._oprot.writeMessageEnd()
4885 
    self._oprot.trans.flush()
4886 
 
4887 
  def recv_saveEBSSettlementSummary(self, ):
4888 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4889 
    if mtype == TMessageType.EXCEPTION:
4890 
      x = TApplicationException()
4891 
      x.read(self._iprot)
4892 
      self._iprot.readMessageEnd()
4893 
      raise x
4894 
    result = saveEBSSettlementSummary_result()
4895 
    result.read(self._iprot)
4896 
    self._iprot.readMessageEnd()
4897 
    if result.ex is not None:
4898 
      raise result.ex
4899 
    return
4900 
 
5386 phani.kuma 4901 
  def getSettlementForPrepaid(self, referenceId, isRefund):
4600 varun.gupt 4902 
    """
4903 
    Parameters:
5189 varun.gupt 4904 
     - referenceId
4905 
     - isRefund
4600 varun.gupt 4906 
    """
5386 phani.kuma 4907 
    self.send_getSettlementForPrepaid(referenceId, isRefund)
4908 
    return self.recv_getSettlementForPrepaid()
4600 varun.gupt 4909 
 
5386 phani.kuma 4910 
  def send_getSettlementForPrepaid(self, referenceId, isRefund):
4911 
    self._oprot.writeMessageBegin('getSettlementForPrepaid', TMessageType.CALL, self._seqid)
4912 
    args = getSettlementForPrepaid_args()
5189 varun.gupt 4913 
    args.referenceId = referenceId
4914 
    args.isRefund = isRefund
4600 varun.gupt 4915 
    args.write(self._oprot)
4916 
    self._oprot.writeMessageEnd()
4917 
    self._oprot.trans.flush()
4918 
 
5386 phani.kuma 4919 
  def recv_getSettlementForPrepaid(self, ):
4600 varun.gupt 4920 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4921 
    if mtype == TMessageType.EXCEPTION:
4922 
      x = TApplicationException()
4923 
      x.read(self._iprot)
4924 
      self._iprot.readMessageEnd()
4925 
      raise x
5386 phani.kuma 4926 
    result = getSettlementForPrepaid_result()
4600 varun.gupt 4927 
    result.read(self._iprot)
4928 
    self._iprot.readMessageEnd()
4929 
    if result.success is not None:
4930 
      return result.success
4931 
    if result.ex is not None:
4932 
      raise result.ex
5386 phani.kuma 4933 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getSettlementForPrepaid failed: unknown result");
4600 varun.gupt 4934 
 
5386 phani.kuma 4935 
  def getSettlementForCod(self, orderId, isRefund):
4936 
    """
4937 
    Parameters:
4938 
     - orderId
4939 
     - isRefund
4940 
    """
4941 
    self.send_getSettlementForCod(orderId, isRefund)
4942 
    return self.recv_getSettlementForCod()
4943 
 
4944 
  def send_getSettlementForCod(self, orderId, isRefund):
4945 
    self._oprot.writeMessageBegin('getSettlementForCod', TMessageType.CALL, self._seqid)
4946 
    args = getSettlementForCod_args()
4947 
    args.orderId = orderId
4948 
    args.isRefund = isRefund
4949 
    args.write(self._oprot)
4950 
    self._oprot.writeMessageEnd()
4951 
    self._oprot.trans.flush()
4952 
 
4953 
  def recv_getSettlementForCod(self, ):
4954 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4955 
    if mtype == TMessageType.EXCEPTION:
4956 
      x = TApplicationException()
4957 
      x.read(self._iprot)
4958 
      self._iprot.readMessageEnd()
4959 
      raise x
4960 
    result = getSettlementForCod_result()
4961 
    result.read(self._iprot)
4962 
    self._iprot.readMessageEnd()
4963 
    if result.success is not None:
4964 
      return result.success
4965 
    if result.ex is not None:
4966 
      raise result.ex
4967 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getSettlementForCod failed: unknown result");
4968 
 
4600 varun.gupt 4969 
  def getEBSSettlementSummaries(self, ):
4970 
    self.send_getEBSSettlementSummaries()
4971 
    return self.recv_getEBSSettlementSummaries()
4972 
 
4973 
  def send_getEBSSettlementSummaries(self, ):
4974 
    self._oprot.writeMessageBegin('getEBSSettlementSummaries', TMessageType.CALL, self._seqid)
4975 
    args = getEBSSettlementSummaries_args()
4976 
    args.write(self._oprot)
4977 
    self._oprot.writeMessageEnd()
4978 
    self._oprot.trans.flush()
4979 
 
4980 
  def recv_getEBSSettlementSummaries(self, ):
4981 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4982 
    if mtype == TMessageType.EXCEPTION:
4983 
      x = TApplicationException()
4984 
      x.read(self._iprot)
4985 
      self._iprot.readMessageEnd()
4986 
      raise x
4987 
    result = getEBSSettlementSummaries_result()
4988 
    result.read(self._iprot)
4989 
    self._iprot.readMessageEnd()
4990 
    if result.success is not None:
4991 
      return result.success
4992 
    if result.ex is not None:
4993 
      raise result.ex
4994 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getEBSSettlementSummaries failed: unknown result");
4995 
 
4996 
  def markEBSSettlementUploaded(self, settlementId):
4997 
    """
4998 
    Parameters:
4999 
     - settlementId
5000 
    """
5001 
    self.send_markEBSSettlementUploaded(settlementId)
5002 
    self.recv_markEBSSettlementUploaded()
5003 
 
5004 
  def send_markEBSSettlementUploaded(self, settlementId):
5005 
    self._oprot.writeMessageBegin('markEBSSettlementUploaded', TMessageType.CALL, self._seqid)
5006 
    args = markEBSSettlementUploaded_args()
5007 
    args.settlementId = settlementId
5008 
    args.write(self._oprot)
5009 
    self._oprot.writeMessageEnd()
5010 
    self._oprot.trans.flush()
5011 
 
5012 
  def recv_markEBSSettlementUploaded(self, ):
5013 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
5014 
    if mtype == TMessageType.EXCEPTION:
5015 
      x = TApplicationException()
5016 
      x.read(self._iprot)
5017 
      self._iprot.readMessageEnd()
5018 
      raise x
5019 
    result = markEBSSettlementUploaded_result()
5020 
    result.read(self._iprot)
5021 
    self._iprot.readMessageEnd()
5022 
    if result.ex is not None:
5023 
      raise result.ex
5024 
    return
5025 
 
5026 
  def getEBSSettlementDate(self, settlementId):
5027 
    """
5028 
    Parameters:
5029 
     - settlementId
5030 
    """
5031 
    self.send_getEBSSettlementDate(settlementId)
5032 
    return self.recv_getEBSSettlementDate()
5033 
 
5034 
  def send_getEBSSettlementDate(self, settlementId):
5035 
    self._oprot.writeMessageBegin('getEBSSettlementDate', TMessageType.CALL, self._seqid)
5036 
    args = getEBSSettlementDate_args()
5037 
    args.settlementId = settlementId
5038 
    args.write(self._oprot)
5039 
    self._oprot.writeMessageEnd()
5040 
    self._oprot.trans.flush()
5041 
 
5042 
  def recv_getEBSSettlementDate(self, ):
5043 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
5044 
    if mtype == TMessageType.EXCEPTION:
5045 
      x = TApplicationException()
5046 
      x.read(self._iprot)
5047 
      self._iprot.readMessageEnd()
5048 
      raise x
5049 
    result = getEBSSettlementDate_result()
5050 
    result.read(self._iprot)
5051 
    self._iprot.readMessageEnd()
5052 
    if result.success is not None:
5053 
      return result.success
5054 
    if result.ex is not None:
5055 
      raise result.ex
5056 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getEBSSettlementDate failed: unknown result");
5057 
 
4715 varun.gupt 5058 
  def getSettlementsByDate(self, settlementDateFrom, settlementDateTo, isRefund):
5059 
    """
5060 
    Parameters:
5061 
     - settlementDateFrom
5062 
     - settlementDateTo
5063 
     - isRefund
5064 
    """
5065 
    self.send_getSettlementsByDate(settlementDateFrom, settlementDateTo, isRefund)
5066 
    return self.recv_getSettlementsByDate()
4600 varun.gupt 5067 
 
4715 varun.gupt 5068 
  def send_getSettlementsByDate(self, settlementDateFrom, settlementDateTo, isRefund):
5069 
    self._oprot.writeMessageBegin('getSettlementsByDate', TMessageType.CALL, self._seqid)
5070 
    args = getSettlementsByDate_args()
5071 
    args.settlementDateFrom = settlementDateFrom
5072 
    args.settlementDateTo = settlementDateTo
5073 
    args.isRefund = isRefund
5074 
    args.write(self._oprot)
5075 
    self._oprot.writeMessageEnd()
5076 
    self._oprot.trans.flush()
5077 
 
5078 
  def recv_getSettlementsByDate(self, ):
5079 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
5080 
    if mtype == TMessageType.EXCEPTION:
5081 
      x = TApplicationException()
5082 
      x.read(self._iprot)
5083 
      self._iprot.readMessageEnd()
5084 
      raise x
5085 
    result = getSettlementsByDate_result()
5086 
    result.read(self._iprot)
5087 
    self._iprot.readMessageEnd()
5088 
    if result.success is not None:
5089 
      return result.success
5090 
    if result.ex is not None:
5091 
      raise result.ex
5092 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getSettlementsByDate failed: unknown result");
5093 
 
5094 
  def getReshippedOrderIds(self, orderIds):
5095 
    """
5096 
    Returns list of Order Ids, which belong to reshiped orders, shortlisted from a given list of Order Ids
5097 
 
5098 
    Parameters:
5099 
     - orderIds
5100 
    """
5101 
    self.send_getReshippedOrderIds(orderIds)
5102 
    return self.recv_getReshippedOrderIds()
5103 
 
5104 
  def send_getReshippedOrderIds(self, orderIds):
5105 
    self._oprot.writeMessageBegin('getReshippedOrderIds', TMessageType.CALL, self._seqid)
5106 
    args = getReshippedOrderIds_args()
5107 
    args.orderIds = orderIds
5108 
    args.write(self._oprot)
5109 
    self._oprot.writeMessageEnd()
5110 
    self._oprot.trans.flush()
5111 
 
5112 
  def recv_getReshippedOrderIds(self, ):
5113 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
5114 
    if mtype == TMessageType.EXCEPTION:
5115 
      x = TApplicationException()
5116 
      x.read(self._iprot)
5117 
      self._iprot.readMessageEnd()
5118 
      raise x
5119 
    result = getReshippedOrderIds_result()
5120 
    result.read(self._iprot)
5121 
    self._iprot.readMessageEnd()
5122 
    if result.success is not None:
5123 
      return result.success
5124 
    if result.ex is not None:
5125 
      raise result.ex
5126 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getReshippedOrderIds failed: unknown result");
5127 
 
5481 phani.kuma 5128 
  def getBilledOrders(self, vendorId, onlyVendorNotPaid, billingDateFrom, billingDateTo):
4875 varun.gupt 5129 
    """
5130 
    Parameters:
5131 
     - vendorId
5481 phani.kuma 5132 
     - onlyVendorNotPaid
5133 
     - billingDateFrom
5134 
     - billingDateTo
4875 varun.gupt 5135 
    """
5481 phani.kuma 5136 
    self.send_getBilledOrders(vendorId, onlyVendorNotPaid, billingDateFrom, billingDateTo)
5137 
    return self.recv_getBilledOrders()
4757 mandeep.dh 5138 
 
5481 phani.kuma 5139 
  def send_getBilledOrders(self, vendorId, onlyVendorNotPaid, billingDateFrom, billingDateTo):
5140 
    self._oprot.writeMessageBegin('getBilledOrders', TMessageType.CALL, self._seqid)
5141 
    args = getBilledOrders_args()
4875 varun.gupt 5142 
    args.vendorId = vendorId
5481 phani.kuma 5143 
    args.onlyVendorNotPaid = onlyVendorNotPaid
5144 
    args.billingDateFrom = billingDateFrom
5145 
    args.billingDateTo = billingDateTo
4875 varun.gupt 5146 
    args.write(self._oprot)
5147 
    self._oprot.writeMessageEnd()
5148 
    self._oprot.trans.flush()
5149 
 
5481 phani.kuma 5150 
  def recv_getBilledOrders(self, ):
4875 varun.gupt 5151 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
5152 
    if mtype == TMessageType.EXCEPTION:
5153 
      x = TApplicationException()
5154 
      x.read(self._iprot)
5155 
      self._iprot.readMessageEnd()
5156 
      raise x
5481 phani.kuma 5157 
    result = getBilledOrders_result()
4875 varun.gupt 5158 
    result.read(self._iprot)
5159 
    self._iprot.readMessageEnd()
5160 
    if result.success is not None:
5161 
      return result.success
5162 
    if result.ex is not None:
5163 
      raise result.ex
5481 phani.kuma 5164 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getBilledOrders failed: unknown result");
4875 varun.gupt 5165 
 
5031 varun.gupt 5166 
  def getStatusDistributionOfOrders(self, startDate, endDate):
5167 
    """
5168 
    Parameters:
5169 
     - startDate
5170 
     - endDate
5171 
    """
5172 
    self.send_getStatusDistributionOfOrders(startDate, endDate)
5173 
    return self.recv_getStatusDistributionOfOrders()
4875 varun.gupt 5174 
 
5031 varun.gupt 5175 
  def send_getStatusDistributionOfOrders(self, startDate, endDate):
5176 
    self._oprot.writeMessageBegin('getStatusDistributionOfOrders', TMessageType.CALL, self._seqid)
5177 
    args = getStatusDistributionOfOrders_args()
5178 
    args.startDate = startDate
5179 
    args.endDate = endDate
5180 
    args.write(self._oprot)
5181 
    self._oprot.writeMessageEnd()
5182 
    self._oprot.trans.flush()
5183 
 
5184 
  def recv_getStatusDistributionOfOrders(self, ):
5185 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
5186 
    if mtype == TMessageType.EXCEPTION:
5187 
      x = TApplicationException()
5188 
      x.read(self._iprot)
5189 
      self._iprot.readMessageEnd()
5190 
      raise x
5191 
    result = getStatusDistributionOfOrders_result()
5192 
    result.read(self._iprot)
5193 
    self._iprot.readMessageEnd()
5194 
    if result.success is not None:
5195 
      return result.success
5196 
    if result.ex is not None:
5197 
      raise result.ex
5198 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getStatusDistributionOfOrders failed: unknown result");
5199 
 
5067 varun.gupt 5200 
  def getOrderIdsForStatus(self, status, startDatetime, endDatetime):
5201 
    """
5202 
    Parameters:
5203 
     - status
5204 
     - startDatetime
5205 
     - endDatetime
5206 
    """
5207 
    self.send_getOrderIdsForStatus(status, startDatetime, endDatetime)
5208 
    return self.recv_getOrderIdsForStatus()
5031 varun.gupt 5209 
 
5067 varun.gupt 5210 
  def send_getOrderIdsForStatus(self, status, startDatetime, endDatetime):
5211 
    self._oprot.writeMessageBegin('getOrderIdsForStatus', TMessageType.CALL, self._seqid)
5212 
    args = getOrderIdsForStatus_args()
5213 
    args.status = status
5214 
    args.startDatetime = startDatetime
5215 
    args.endDatetime = endDatetime
5216 
    args.write(self._oprot)
5217 
    self._oprot.writeMessageEnd()
5218 
    self._oprot.trans.flush()
5219 
 
5220 
  def recv_getOrderIdsForStatus(self, ):
5221 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
5222 
    if mtype == TMessageType.EXCEPTION:
5223 
      x = TApplicationException()
5224 
      x.read(self._iprot)
5225 
      self._iprot.readMessageEnd()
5226 
      raise x
5227 
    result = getOrderIdsForStatus_result()
5228 
    result.read(self._iprot)
5229 
    self._iprot.readMessageEnd()
5230 
    if result.success is not None:
5231 
      return result.success
5232 
    if result.ex is not None:
5233 
      raise result.ex
5234 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getOrderIdsForStatus failed: unknown result");
5235 
 
5348 anupam.sin 5236 
  def updateCODAgent(self, agent, orderId):
5237 
    """
5238 
    Updates the agent who handled the COD verification call
5239 
 
5240 
    Parameters:
5241 
     - agent
5242 
     - orderId
5243 
    """
5244 
    self.send_updateCODAgent(agent, orderId)
5245 
    self.recv_updateCODAgent()
5246 
 
5247 
  def send_updateCODAgent(self, agent, orderId):
5248 
    self._oprot.writeMessageBegin('updateCODAgent', TMessageType.CALL, self._seqid)
5249 
    args = updateCODAgent_args()
5250 
    args.agent = agent
5251 
    args.orderId = orderId
5252 
    args.write(self._oprot)
5253 
    self._oprot.writeMessageEnd()
5254 
    self._oprot.trans.flush()
5255 
 
5256 
  def recv_updateCODAgent(self, ):
5257 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
5258 
    if mtype == TMessageType.EXCEPTION:
5259 
      x = TApplicationException()
5260 
      x.read(self._iprot)
5261 
      self._iprot.readMessageEnd()
5262 
      raise x
5263 
    result = updateCODAgent_result()
5264 
    result.read(self._iprot)
5265 
    self._iprot.readMessageEnd()
5266 
    if result.ex is not None:
5267 
      raise result.ex
5268 
    return
5269 
 
5099 varun.gupt 5270 
  def updateOrderAsPaidToVendor(self, orderId):
5271 
    """
5272 
    Parameters:
5273 
     - orderId
5274 
    """
5275 
    self.send_updateOrderAsPaidToVendor(orderId)
5276 
    self.recv_updateOrderAsPaidToVendor()
5067 varun.gupt 5277 
 
5099 varun.gupt 5278 
  def send_updateOrderAsPaidToVendor(self, orderId):
5279 
    self._oprot.writeMessageBegin('updateOrderAsPaidToVendor', TMessageType.CALL, self._seqid)
5280 
    args = updateOrderAsPaidToVendor_args()
5281 
    args.orderId = orderId
5282 
    args.write(self._oprot)
5283 
    self._oprot.writeMessageEnd()
5284 
    self._oprot.trans.flush()
5285 
 
5286 
  def recv_updateOrderAsPaidToVendor(self, ):
5287 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
5288 
    if mtype == TMessageType.EXCEPTION:
5289 
      x = TApplicationException()
5290 
      x.read(self._iprot)
5291 
      self._iprot.readMessageEnd()
5292 
      raise x
5293 
    result = updateOrderAsPaidToVendor_result()
5294 
    result.read(self._iprot)
5295 
    self._iprot.readMessageEnd()
5296 
    if result.ex is not None:
5297 
      raise result.ex
5298 
    return
5299 
 
5386 phani.kuma 5300 
  def updateOrderOnlyAsPaidToVendor(self, orderId):
5301 
    """
5302 
    Parameters:
5303 
     - orderId
5304 
    """
5305 
    self.send_updateOrderOnlyAsPaidToVendor(orderId)
5306 
    self.recv_updateOrderOnlyAsPaidToVendor()
5307 
 
5308 
  def send_updateOrderOnlyAsPaidToVendor(self, orderId):
5309 
    self._oprot.writeMessageBegin('updateOrderOnlyAsPaidToVendor', TMessageType.CALL, self._seqid)
5310 
    args = updateOrderOnlyAsPaidToVendor_args()
5311 
    args.orderId = orderId
5312 
    args.write(self._oprot)
5313 
    self._oprot.writeMessageEnd()
5314 
    self._oprot.trans.flush()
5315 
 
5316 
  def recv_updateOrderOnlyAsPaidToVendor(self, ):
5317 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
5318 
    if mtype == TMessageType.EXCEPTION:
5319 
      x = TApplicationException()
5320 
      x.read(self._iprot)
5321 
      self._iprot.readMessageEnd()
5322 
      raise x
5323 
    result = updateOrderOnlyAsPaidToVendor_result()
5324 
    result.read(self._iprot)
5325 
    self._iprot.readMessageEnd()
5326 
    if result.ex is not None:
5327 
      raise result.ex
5328 
    return
5329 
 
5208 varun.gupt 5330 
  def getRefundedOrdersMarkedPaid(self, ):
5331 
    self.send_getRefundedOrdersMarkedPaid()
5332 
    return self.recv_getRefundedOrdersMarkedPaid()
5099 varun.gupt 5333 
 
5208 varun.gupt 5334 
  def send_getRefundedOrdersMarkedPaid(self, ):
5335 
    self._oprot.writeMessageBegin('getRefundedOrdersMarkedPaid', TMessageType.CALL, self._seqid)
5336 
    args = getRefundedOrdersMarkedPaid_args()
5337 
    args.write(self._oprot)
5338 
    self._oprot.writeMessageEnd()
5339 
    self._oprot.trans.flush()
5340 
 
5341 
  def recv_getRefundedOrdersMarkedPaid(self, ):
5342 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
5343 
    if mtype == TMessageType.EXCEPTION:
5344 
      x = TApplicationException()
5345 
      x.read(self._iprot)
5346 
      self._iprot.readMessageEnd()
5347 
      raise x
5348 
    result = getRefundedOrdersMarkedPaid_result()
5349 
    result.read(self._iprot)
5350 
    self._iprot.readMessageEnd()
5351 
    if result.success is not None:
5352 
      return result.success
5353 
    if result.ex is not None:
5354 
      raise result.ex
5355 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getRefundedOrdersMarkedPaid failed: unknown result");
5356 
 
5447 anupam.sin 5357 
  def getAllVerificationAgents(self, minOrderId, maxOrderId):
5358 
    """
5359 
    gets all COD Verification Agents for all orderIds from a minId to maxId
5208 varun.gupt 5360 
 
5447 anupam.sin 5361 
 
5362 
    Parameters:
5363 
     - minOrderId
5364 
     - maxOrderId
5365 
    """
5366 
    self.send_getAllVerificationAgents(minOrderId, maxOrderId)
5367 
    return self.recv_getAllVerificationAgents()
5368 
 
5369 
  def send_getAllVerificationAgents(self, minOrderId, maxOrderId):
5370 
    self._oprot.writeMessageBegin('getAllVerificationAgents', TMessageType.CALL, self._seqid)
5371 
    args = getAllVerificationAgents_args()
5372 
    args.minOrderId = minOrderId
5373 
    args.maxOrderId = maxOrderId
5374 
    args.write(self._oprot)
5375 
    self._oprot.writeMessageEnd()
5376 
    self._oprot.trans.flush()
5377 
 
5378 
  def recv_getAllVerificationAgents(self, ):
5379 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
5380 
    if mtype == TMessageType.EXCEPTION:
5381 
      x = TApplicationException()
5382 
      x.read(self._iprot)
5383 
      self._iprot.readMessageEnd()
5384 
      raise x
5385 
    result = getAllVerificationAgents_result()
5386 
    result.read(self._iprot)
5387 
    self._iprot.readMessageEnd()
5388 
    if result.success is not None:
5389 
      return result.success
5390 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAllVerificationAgents failed: unknown result");
5391 
 
5527 anupam.sin 5392 
  def getAllAttributesForOrderId(self, orderId):
5393 
    """
5394 
    gets all attributes for a given orderId
5447 anupam.sin 5395 
 
5527 anupam.sin 5396 
    Parameters:
5397 
     - orderId
5398 
    """
5399 
    self.send_getAllAttributesForOrderId(orderId)
5400 
    return self.recv_getAllAttributesForOrderId()
5401 
 
5402 
  def send_getAllAttributesForOrderId(self, orderId):
5403 
    self._oprot.writeMessageBegin('getAllAttributesForOrderId', TMessageType.CALL, self._seqid)
5404 
    args = getAllAttributesForOrderId_args()
5405 
    args.orderId = orderId
5406 
    args.write(self._oprot)
5407 
    self._oprot.writeMessageEnd()
5408 
    self._oprot.trans.flush()
5409 
 
5410 
  def recv_getAllAttributesForOrderId(self, ):
5411 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
5412 
    if mtype == TMessageType.EXCEPTION:
5413 
      x = TApplicationException()
5414 
      x.read(self._iprot)
5415 
      self._iprot.readMessageEnd()
5416 
      raise x
5417 
    result = getAllAttributesForOrderId_result()
5418 
    result.read(self._iprot)
5419 
    self._iprot.readMessageEnd()
5420 
    if result.success is not None:
5421 
      return result.success
5422 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAllAttributesForOrderId failed: unknown result");
5423 
 
5676 rajveer 5424 
  def setOrderAttributes(self, orderId, attributes):
5425 
    """
5426 
    sets attributes for an order
5427 
 
5428 
    Parameters:
5429 
     - orderId
5430 
     - attributes
5431 
    """
5432 
    self.send_setOrderAttributes(orderId, attributes)
5433 
    self.recv_setOrderAttributes()
5434 
 
5435 
  def send_setOrderAttributes(self, orderId, attributes):
5436 
    self._oprot.writeMessageBegin('setOrderAttributes', TMessageType.CALL, self._seqid)
5437 
    args = setOrderAttributes_args()
5438 
    args.orderId = orderId
5439 
    args.attributes = attributes
5440 
    args.write(self._oprot)
5441 
    self._oprot.writeMessageEnd()
5442 
    self._oprot.trans.flush()
5443 
 
5444 
  def recv_setOrderAttributes(self, ):
5445 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
5446 
    if mtype == TMessageType.EXCEPTION:
5447 
      x = TApplicationException()
5448 
      x.read(self._iprot)
5449 
      self._iprot.readMessageEnd()
5450 
      raise x
5451 
    result = setOrderAttributes_result()
5452 
    result.read(self._iprot)
5453 
    self._iprot.readMessageEnd()
5454 
    return
5455 
 
5527 anupam.sin 5456 
  def setOrderAttributeForTransaction(self, transactionId, attribute):
5457 
    """
5458 
    sets attributes for all orders in a transaction
5459 
 
5460 
    Parameters:
5461 
     - transactionId
5462 
     - attribute
5463 
    """
5464 
    self.send_setOrderAttributeForTransaction(transactionId, attribute)
5465 
    self.recv_setOrderAttributeForTransaction()
5466 
 
5467 
  def send_setOrderAttributeForTransaction(self, transactionId, attribute):
5468 
    self._oprot.writeMessageBegin('setOrderAttributeForTransaction', TMessageType.CALL, self._seqid)
5469 
    args = setOrderAttributeForTransaction_args()
5470 
    args.transactionId = transactionId
5471 
    args.attribute = attribute
5472 
    args.write(self._oprot)
5473 
    self._oprot.writeMessageEnd()
5474 
    self._oprot.trans.flush()
5475 
 
5476 
  def recv_setOrderAttributeForTransaction(self, ):
5477 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
5478 
    if mtype == TMessageType.EXCEPTION:
5479 
      x = TApplicationException()
5480 
      x.read(self._iprot)
5481 
      self._iprot.readMessageEnd()
5482 
      raise x
5483 
    result = setOrderAttributeForTransaction_result()
5484 
    result.read(self._iprot)
5485 
    self._iprot.readMessageEnd()
5486 
    return
5487 
 
5553 rajveer 5488 
  def getReceivePendingOrders(self, storeId):
5489 
    """
5490 
    Parameters:
5491 
     - storeId
5492 
    """
5493 
    self.send_getReceivePendingOrders(storeId)
5494 
    return self.recv_getReceivePendingOrders()
5527 anupam.sin 5495 
 
5553 rajveer 5496 
  def send_getReceivePendingOrders(self, storeId):
5497 
    self._oprot.writeMessageBegin('getReceivePendingOrders', TMessageType.CALL, self._seqid)
5498 
    args = getReceivePendingOrders_args()
5499 
    args.storeId = storeId
5500 
    args.write(self._oprot)
5501 
    self._oprot.writeMessageEnd()
5502 
    self._oprot.trans.flush()
5503 
 
5504 
  def recv_getReceivePendingOrders(self, ):
5505 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
5506 
    if mtype == TMessageType.EXCEPTION:
5507 
      x = TApplicationException()
5508 
      x.read(self._iprot)
5509 
      self._iprot.readMessageEnd()
5510 
      raise x
5511 
    result = getReceivePendingOrders_result()
5512 
    result.read(self._iprot)
5513 
    self._iprot.readMessageEnd()
5514 
    if result.success is not None:
5515 
      return result.success
5516 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getReceivePendingOrders failed: unknown result");
5517 
 
5518 
  def getReceivedAtStoreOrders(self, storeId):
5519 
    """
5520 
    Parameters:
5521 
     - storeId
5522 
    """
5523 
    self.send_getReceivedAtStoreOrders(storeId)
5524 
    return self.recv_getReceivedAtStoreOrders()
5525 
 
5526 
  def send_getReceivedAtStoreOrders(self, storeId):
5527 
    self._oprot.writeMessageBegin('getReceivedAtStoreOrders', TMessageType.CALL, self._seqid)
5528 
    args = getReceivedAtStoreOrders_args()
5529 
    args.storeId = storeId
5530 
    args.write(self._oprot)
5531 
    self._oprot.writeMessageEnd()
5532 
    self._oprot.trans.flush()
5533 
 
5534 
  def recv_getReceivedAtStoreOrders(self, ):
5535 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
5536 
    if mtype == TMessageType.EXCEPTION:
5537 
      x = TApplicationException()
5538 
      x.read(self._iprot)
5539 
      self._iprot.readMessageEnd()
5540 
      raise x
5541 
    result = getReceivedAtStoreOrders_result()
5542 
    result.read(self._iprot)
5543 
    self._iprot.readMessageEnd()
5544 
    if result.success is not None:
5545 
      return result.success
5546 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getReceivedAtStoreOrders failed: unknown result");
5547 
 
5713 rajveer 5548 
  def getOrdersCollectionAtStore(self, storeId, fromDate, toDate, onlyCod):
5549 
    """
5550 
    Parameters:
5551 
     - storeId
5552 
     - fromDate
5553 
     - toDate
5554 
     - onlyCod
5555 
    """
5556 
    self.send_getOrdersCollectionAtStore(storeId, fromDate, toDate, onlyCod)
5557 
    return self.recv_getOrdersCollectionAtStore()
5558 
 
5559 
  def send_getOrdersCollectionAtStore(self, storeId, fromDate, toDate, onlyCod):
5560 
    self._oprot.writeMessageBegin('getOrdersCollectionAtStore', TMessageType.CALL, self._seqid)
5561 
    args = getOrdersCollectionAtStore_args()
5562 
    args.storeId = storeId
5563 
    args.fromDate = fromDate
5564 
    args.toDate = toDate
5565 
    args.onlyCod = onlyCod
5566 
    args.write(self._oprot)
5567 
    self._oprot.writeMessageEnd()
5568 
    self._oprot.trans.flush()
5569 
 
5570 
  def recv_getOrdersCollectionAtStore(self, ):
5571 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
5572 
    if mtype == TMessageType.EXCEPTION:
5573 
      x = TApplicationException()
5574 
      x.read(self._iprot)
5575 
      self._iprot.readMessageEnd()
5576 
      raise x
5577 
    result = getOrdersCollectionAtStore_result()
5578 
    result.read(self._iprot)
5579 
    self._iprot.readMessageEnd()
5580 
    if result.success is not None:
5581 
      return result.success
5582 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getOrdersCollectionAtStore failed: unknown result");
5583 
 
5833 rajveer 5584 
  def getOrderAttributeValue(self, orderId, attributeName):
5585 
    """
5586 
    Parameters:
5587 
     - orderId
5588 
     - attributeName
5589 
    """
5590 
    self.send_getOrderAttributeValue(orderId, attributeName)
5591 
    return self.recv_getOrderAttributeValue()
5592 
 
5593 
  def send_getOrderAttributeValue(self, orderId, attributeName):
5594 
    self._oprot.writeMessageBegin('getOrderAttributeValue', TMessageType.CALL, self._seqid)
5595 
    args = getOrderAttributeValue_args()
5596 
    args.orderId = orderId
5597 
    args.attributeName = attributeName
5598 
    args.write(self._oprot)
5599 
    self._oprot.writeMessageEnd()
5600 
    self._oprot.trans.flush()
5601 
 
5602 
  def recv_getOrderAttributeValue(self, ):
5603 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
5604 
    if mtype == TMessageType.EXCEPTION:
5605 
      x = TApplicationException()
5606 
      x.read(self._iprot)
5607 
      self._iprot.readMessageEnd()
5608 
      raise x
5609 
    result = getOrderAttributeValue_result()
5610 
    result.read(self._iprot)
5611 
    self._iprot.readMessageEnd()
5612 
    if result.success is not None:
5613 
      return result.success
5614 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getOrderAttributeValue failed: unknown result");
5615 
 
5593 mandeep.dh 5616 
  def acceptOrderForItem(self, itemId, quantity, fulfilmentWarehouseId, billingWarehouseId):
5617 
    """
5618 
    Accepts appropriate order for an item in a given billingWarehouse. Usually
5619 
    invoked while scanning IN of items.
5553 rajveer 5620 
 
5593 mandeep.dh 5621 
    Parameters:
5622 
     - itemId
5623 
     - quantity
5624 
     - fulfilmentWarehouseId
5625 
     - billingWarehouseId
5626 
    """
5627 
    self.send_acceptOrderForItem(itemId, quantity, fulfilmentWarehouseId, billingWarehouseId)
5628 
    self.recv_acceptOrderForItem()
5629 
 
5630 
  def send_acceptOrderForItem(self, itemId, quantity, fulfilmentWarehouseId, billingWarehouseId):
5631 
    self._oprot.writeMessageBegin('acceptOrderForItem', TMessageType.CALL, self._seqid)
5632 
    args = acceptOrderForItem_args()
5633 
    args.itemId = itemId
5634 
    args.quantity = quantity
5635 
    args.fulfilmentWarehouseId = fulfilmentWarehouseId
5636 
    args.billingWarehouseId = billingWarehouseId
5637 
    args.write(self._oprot)
5638 
    self._oprot.writeMessageEnd()
5639 
    self._oprot.trans.flush()
5640 
 
5641 
  def recv_acceptOrderForItem(self, ):
5642 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
5643 
    if mtype == TMessageType.EXCEPTION:
5644 
      x = TApplicationException()
5645 
      x.read(self._iprot)
5646 
      self._iprot.readMessageEnd()
5647 
      raise x
5648 
    result = acceptOrderForItem_result()
5649 
    result.read(self._iprot)
5650 
    self._iprot.readMessageEnd()
5651 
    return
5652 
 
5653 
 
3376 rajveer 5654 
class Processor(shop2020.thriftpy.generic.GenericService.Processor, Iface, TProcessor):
94 ashish 5655 
  def __init__(self, handler):
3376 rajveer 5656 
    shop2020.thriftpy.generic.GenericService.Processor.__init__(self, handler)
94 ashish 5657 
    self._processMap["createTransaction"] = Processor.process_createTransaction
5658 
    self._processMap["getTransaction"] = Processor.process_getTransaction
5659 
    self._processMap["getTransactionsForCustomer"] = Processor.process_getTransactionsForCustomer
132 ashish 5660 
    self._processMap["getTransactionsForShoppingCartId"] = Processor.process_getTransactionsForShoppingCartId
94 ashish 5661 
    self._processMap["getTransactionStatus"] = Processor.process_getTransactionStatus
5662 
    self._processMap["changeTransactionStatus"] = Processor.process_changeTransactionStatus
1398 varun.gupt 5663 
    self._processMap["enqueueTransactionInfoEmail"] = Processor.process_enqueueTransactionInfoEmail
483 rajveer 5664 
    self._processMap["getAllOrders"] = Processor.process_getAllOrders
4133 chandransh 5665 
    self._processMap["getOrdersInBatch"] = Processor.process_getOrdersInBatch
5666 
    self._processMap["getOrderCount"] = Processor.process_getOrderCount
999 varun.gupt 5667 
    self._processMap["getOrdersByBillingDate"] = Processor.process_getOrdersByBillingDate
3427 chandransh 5668 
    self._processMap["getOrdersByShippingDate"] = Processor.process_getOrdersByShippingDate
1382 varun.gupt 5669 
    self._processMap["getReturnableOrdersForCustomer"] = Processor.process_getReturnableOrdersForCustomer
5670 
    self._processMap["getCancellableOrdersForCustomer"] = Processor.process_getCancellableOrdersForCustomer
483 rajveer 5671 
    self._processMap["changeOrderStatus"] = Processor.process_changeOrderStatus
5672 
    self._processMap["getOrdersForTransaction"] = Processor.process_getOrdersForTransaction
5673 
    self._processMap["getOrdersForCustomer"] = Processor.process_getOrdersForCustomer
5674 
    self._processMap["createOrder"] = Processor.process_createOrder
5675 
    self._processMap["getOrder"] = Processor.process_getOrder
5676 
    self._processMap["getLineItemsForOrder"] = Processor.process_getLineItemsForOrder
4999 phani.kuma 5677 
    self._processMap["getOrderList"] = Processor.process_getOrderList
5386 phani.kuma 5678 
    self._processMap["getOrderListForVendor"] = Processor.process_getOrderListForVendor
1528 ankur.sing 5679 
    self._processMap["getOrderForCustomer"] = Processor.process_getOrderForCustomer
3064 chandransh 5680 
    self._processMap["getAlerts"] = Processor.process_getAlerts
4394 rajveer 5681 
    self._processMap["addAlert"] = Processor.process_addAlert
4444 rajveer 5682 
    self._processMap["markAlertsAsSeen"] = Processor.process_markAlertsAsSeen
3064 chandransh 5683 
    self._processMap["getValidOrderCount"] = Processor.process_getValidOrderCount
5684 
    self._processMap["getNoOfCustomersWithSuccessfulTransaction"] = Processor.process_getNoOfCustomersWithSuccessfulTransaction
5685 
    self._processMap["getValidOrdersAmountRange"] = Processor.process_getValidOrdersAmountRange
5686 
    self._processMap["getValidOrders"] = Processor.process_getValidOrders
1220 chandransh 5687 
    self._processMap["batchOrders"] = Processor.process_batchOrders
1208 chandransh 5688 
    self._processMap["markOrderAsOutOfStock"] = Processor.process_markOrderAsOutOfStock
3064 chandransh 5689 
    self._processMap["verifyOrder"] = Processor.process_verifyOrder
5690 
    self._processMap["acceptOrder"] = Processor.process_acceptOrder
5691 
    self._processMap["addBillingDetails"] = Processor.process_addBillingDetails
4579 rajveer 5692 
    self._processMap["addInvoiceNumber"] = Processor.process_addInvoiceNumber
4410 rajveer 5693 
    self._processMap["markOrdersAsShippedFromWarehouse"] = Processor.process_markOrdersAsShippedFromWarehouse
5676 rajveer 5694 
    self._processMap["markOrdersAsReturnedFromStore"] = Processor.process_markOrdersAsReturnedFromStore
1113 chandransh 5695 
    self._processMap["markOrdersAsPickedUp"] = Processor.process_markOrdersAsPickedUp
4910 phani.kuma 5696 
    self._processMap["getOrdersNotPickedUp"] = Processor.process_getOrdersNotPickedUp
1132 chandransh 5697 
    self._processMap["markOrdersAsDelivered"] = Processor.process_markOrdersAsDelivered
4910 phani.kuma 5698 
    self._processMap["markAsRTOrders"] = Processor.process_markAsRTOrders
5699 
    self._processMap["getRTOrders"] = Processor.process_getRTOrders
1246 chandransh 5700 
    self._processMap["updateNonDeliveryReason"] = Processor.process_updateNonDeliveryReason
4910 phani.kuma 5701 
    self._processMap["getNonDeliveredOrdersbyCourier"] = Processor.process_getNonDeliveredOrdersbyCourier
5702 
    self._processMap["markOrdersAsLocalConnected"] = Processor.process_markOrdersAsLocalConnected
5703 
    self._processMap["getOrdersNotLocalConnected"] = Processor.process_getOrdersNotLocalConnected
5704 
    self._processMap["markOrdersAsDestinationCityReached"] = Processor.process_markOrdersAsDestinationCityReached
5705 
    self._processMap["markOrdersAsFirstDeliveryAttempted"] = Processor.process_markOrdersAsFirstDeliveryAttempted
1408 ankur.sing 5706 
    self._processMap["getUndeliveredOrders"] = Processor.process_getUndeliveredOrders
4783 phani.kuma 5707 
    self._processMap["getUndeliveredOrdersExpectedDeliveryDateNotMet"] = Processor.process_getUndeliveredOrdersExpectedDeliveryDateNotMet
2536 chandransh 5708 
    self._processMap["toggleDOAFlag"] = Processor.process_toggleDOAFlag
4712 rajveer 5709 
    self._processMap["markOrderAsDelivered"] = Processor.process_markOrderAsDelivered
5553 rajveer 5710 
    self._processMap["markOrderAsReceivedAtStore"] = Processor.process_markOrderAsReceivedAtStore
4454 rajveer 5711 
    self._processMap["markOrderDoaRequestReceived"] = Processor.process_markOrderDoaRequestReceived
5712 
    self._processMap["markOrderDoaRequestAuthorized"] = Processor.process_markOrderDoaRequestAuthorized
4488 rajveer 5713 
    self._processMap["markOrderReturnRequestReceived"] = Processor.process_markOrderReturnRequestReceived
5714 
    self._processMap["markOrderReturnRequestAuthorized"] = Processor.process_markOrderReturnRequestAuthorized
2536 chandransh 5715 
    self._processMap["requestPickupNumber"] = Processor.process_requestPickupNumber
5716 
    self._processMap["authorizePickup"] = Processor.process_authorizePickup
2764 chandransh 5717 
    self._processMap["markDoasAsPickedUp"] = Processor.process_markDoasAsPickedUp
4910 phani.kuma 5718 
    self._processMap["getDoasNotPickedUp"] = Processor.process_getDoasNotPickedUp
4741 phani.kuma 5719 
    self._processMap["markReturnOrdersAsPickedUp"] = Processor.process_markReturnOrdersAsPickedUp
4910 phani.kuma 5720 
    self._processMap["getReturnOrdersNotPickedUp"] = Processor.process_getReturnOrdersNotPickedUp
2616 chandransh 5721 
    self._processMap["receiveReturn"] = Processor.process_receiveReturn
2591 chandransh 5722 
    self._processMap["validateDoa"] = Processor.process_validateDoa
4495 rajveer 5723 
    self._processMap["validateReturnProduct"] = Processor.process_validateReturnProduct
2616 chandransh 5724 
    self._processMap["reshipOrder"] = Processor.process_reshipOrder
5725 
    self._processMap["refundOrder"] = Processor.process_refundOrder
2690 chandransh 5726 
    self._processMap["getReturnOrders"] = Processor.process_getReturnOrders
5481 phani.kuma 5727 
    self._processMap["getAllReturnOrders"] = Processor.process_getAllReturnOrders
2700 chandransh 5728 
    self._processMap["getReturnOrder"] = Processor.process_getReturnOrder
2690 chandransh 5729 
    self._processMap["processReturn"] = Processor.process_processReturn
3451 chandransh 5730 
    self._processMap["updateWeight"] = Processor.process_updateWeight
3469 chandransh 5731 
    self._processMap["changeItem"] = Processor.process_changeItem
5732 
    self._processMap["shiftToWarehouse"] = Processor.process_shiftToWarehouse
3553 chandransh 5733 
    self._processMap["addDelayReason"] = Processor.process_addDelayReason
3956 chandransh 5734 
    self._processMap["reconcileCodCollection"] = Processor.process_reconcileCodCollection
4008 mandeep.dh 5735 
    self._processMap["getTransactionsRequiringExtraProcessing"] = Processor.process_getTransactionsRequiringExtraProcessing
5736 
    self._processMap["markTransactionAsProcessed"] = Processor.process_markTransactionAsProcessed
4018 chandransh 5737 
    self._processMap["getItemWiseRiskyOrdersCount"] = Processor.process_getItemWiseRiskyOrdersCount
4295 varun.gupt 5738 
    self._processMap["getOrdersForItemIds"] = Processor.process_getOrdersForItemIds
4247 rajveer 5739 
    self._processMap["markOrderCancellationRequestReceived"] = Processor.process_markOrderCancellationRequestReceived
5740 
    self._processMap["markOrderCancellationRequestConfirmed"] = Processor.process_markOrderCancellationRequestConfirmed
5741 
    self._processMap["markOrderCancellationRequestDenied"] = Processor.process_markOrderCancellationRequestDenied
4258 rajveer 5742 
    self._processMap["markTransactionAsPaymentFlagRemoved"] = Processor.process_markTransactionAsPaymentFlagRemoved
4259 anupam.sin 5743 
    self._processMap["refundTransaction"] = Processor.process_refundTransaction
4324 mandeep.dh 5744 
    self._processMap["updateShipmentAddress"] = Processor.process_updateShipmentAddress
4285 rajveer 5745 
    self._processMap["acceptOrdersForItemId"] = Processor.process_acceptOrdersForItemId
4303 rajveer 5746 
    self._processMap["markOrdersAsPORaised"] = Processor.process_markOrdersAsPORaised
5747 
    self._processMap["markOrdersAsReversalInitiated"] = Processor.process_markOrdersAsReversalInitiated
5748 
    self._processMap["markOrdersAsNotAvailabke"] = Processor.process_markOrdersAsNotAvailabke
4369 rajveer 5749 
    self._processMap["markOrdersAsTimeout"] = Processor.process_markOrdersAsTimeout
4662 rajveer 5750 
    self._processMap["markOrderAsLostInTransit"] = Processor.process_markOrderAsLostInTransit
4386 anupam.sin 5751 
    self._processMap["getOrderForAwb"] = Processor.process_getOrderForAwb
4506 phani.kuma 5752 
    self._processMap["getOrdersForProviderForStatus"] = Processor.process_getOrdersForProviderForStatus
4600 varun.gupt 5753 
    self._processMap["getBilledOrdersForVendor"] = Processor.process_getBilledOrdersForVendor
4607 rajveer 5754 
    self._processMap["getSlippedSippingDateOrders"] = Processor.process_getSlippedSippingDateOrders
4709 rajveer 5755 
    self._processMap["getCancelledOrders"] = Processor.process_getCancelledOrders
4600 varun.gupt 5756 
    self._processMap["saveBluedartSettlements"] = Processor.process_saveBluedartSettlements
5757 
    self._processMap["savePaymentSettlements"] = Processor.process_savePaymentSettlements
5758 
    self._processMap["saveEBSSettlementSummary"] = Processor.process_saveEBSSettlementSummary
5386 phani.kuma 5759 
    self._processMap["getSettlementForPrepaid"] = Processor.process_getSettlementForPrepaid
5760 
    self._processMap["getSettlementForCod"] = Processor.process_getSettlementForCod
4600 varun.gupt 5761 
    self._processMap["getEBSSettlementSummaries"] = Processor.process_getEBSSettlementSummaries
5762 
    self._processMap["markEBSSettlementUploaded"] = Processor.process_markEBSSettlementUploaded
5763 
    self._processMap["getEBSSettlementDate"] = Processor.process_getEBSSettlementDate
4715 varun.gupt 5764 
    self._processMap["getSettlementsByDate"] = Processor.process_getSettlementsByDate
5765 
    self._processMap["getReshippedOrderIds"] = Processor.process_getReshippedOrderIds
5481 phani.kuma 5766 
    self._processMap["getBilledOrders"] = Processor.process_getBilledOrders
5031 varun.gupt 5767 
    self._processMap["getStatusDistributionOfOrders"] = Processor.process_getStatusDistributionOfOrders
5067 varun.gupt 5768 
    self._processMap["getOrderIdsForStatus"] = Processor.process_getOrderIdsForStatus
5348 anupam.sin 5769 
    self._processMap["updateCODAgent"] = Processor.process_updateCODAgent
5099 varun.gupt 5770 
    self._processMap["updateOrderAsPaidToVendor"] = Processor.process_updateOrderAsPaidToVendor
5386 phani.kuma 5771 
    self._processMap["updateOrderOnlyAsPaidToVendor"] = Processor.process_updateOrderOnlyAsPaidToVendor
5208 varun.gupt 5772 
    self._processMap["getRefundedOrdersMarkedPaid"] = Processor.process_getRefundedOrdersMarkedPaid
5447 anupam.sin 5773 
    self._processMap["getAllVerificationAgents"] = Processor.process_getAllVerificationAgents
5527 anupam.sin 5774 
    self._processMap["getAllAttributesForOrderId"] = Processor.process_getAllAttributesForOrderId
5676 rajveer 5775 
    self._processMap["setOrderAttributes"] = Processor.process_setOrderAttributes
5527 anupam.sin 5776 
    self._processMap["setOrderAttributeForTransaction"] = Processor.process_setOrderAttributeForTransaction
5553 rajveer 5777 
    self._processMap["getReceivePendingOrders"] = Processor.process_getReceivePendingOrders
5778 
    self._processMap["getReceivedAtStoreOrders"] = Processor.process_getReceivedAtStoreOrders
5713 rajveer 5779 
    self._processMap["getOrdersCollectionAtStore"] = Processor.process_getOrdersCollectionAtStore
5833 rajveer 5780 
    self._processMap["getOrderAttributeValue"] = Processor.process_getOrderAttributeValue
5593 mandeep.dh 5781 
    self._processMap["acceptOrderForItem"] = Processor.process_acceptOrderForItem
94 ashish 5782 
 
5783 
  def process(self, iprot, oprot):
5784 
    (name, type, seqid) = iprot.readMessageBegin()
5785 
    if name not in self._processMap:
5786 
      iprot.skip(TType.STRUCT)
5787 
      iprot.readMessageEnd()
5788 
      x = TApplicationException(TApplicationException.UNKNOWN_METHOD, 'Unknown function %s' % (name))
5789 
      oprot.writeMessageBegin(name, TMessageType.EXCEPTION, seqid)
5790 
      x.write(oprot)
5791 
      oprot.writeMessageEnd()
5792 
      oprot.trans.flush()
5793 
      return
5794 
    else:
5795 
      self._processMap[name](self, seqid, iprot, oprot)
5796 
    return True
5797 
 
5798 
  def process_createTransaction(self, seqid, iprot, oprot):
5799 
    args = createTransaction_args()
5800 
    args.read(iprot)
5801 
    iprot.readMessageEnd()
5802 
    result = createTransaction_result()
5803 
    try:
132 ashish 5804 
      result.success = self._handler.createTransaction(args.transaction)
94 ashish 5805 
    except TransactionServiceException, ex:
5806 
      result.ex = ex
5807 
    oprot.writeMessageBegin("createTransaction", TMessageType.REPLY, seqid)
5808 
    result.write(oprot)
5809 
    oprot.writeMessageEnd()
5810 
    oprot.trans.flush()
5811 
 
5812 
  def process_getTransaction(self, seqid, iprot, oprot):
5813 
    args = getTransaction_args()
5814 
    args.read(iprot)
5815 
    iprot.readMessageEnd()
5816 
    result = getTransaction_result()
5817 
    try:
5818 
      result.success = self._handler.getTransaction(args.id)
5819 
    except TransactionServiceException, ex:
5820 
      result.ex = ex
5821 
    oprot.writeMessageBegin("getTransaction", TMessageType.REPLY, seqid)
5822 
    result.write(oprot)
5823 
    oprot.writeMessageEnd()
5824 
    oprot.trans.flush()
5825 
 
5826 
  def process_getTransactionsForCustomer(self, seqid, iprot, oprot):
5827 
    args = getTransactionsForCustomer_args()
5828 
    args.read(iprot)
5829 
    iprot.readMessageEnd()
5830 
    result = getTransactionsForCustomer_result()
5831 
    try:
5832 
      result.success = self._handler.getTransactionsForCustomer(args.customerId, args.from_date, args.to_date, args.status)
5833 
    except TransactionServiceException, ex:
5834 
      result.ex = ex
5835 
    oprot.writeMessageBegin("getTransactionsForCustomer", TMessageType.REPLY, seqid)
5836 
    result.write(oprot)
5837 
    oprot.writeMessageEnd()
5838 
    oprot.trans.flush()
5839 
 
132 ashish 5840 
  def process_getTransactionsForShoppingCartId(self, seqid, iprot, oprot):
5841 
    args = getTransactionsForShoppingCartId_args()
5842 
    args.read(iprot)
5843 
    iprot.readMessageEnd()
5844 
    result = getTransactionsForShoppingCartId_result()
5845 
    try:
5846 
      result.success = self._handler.getTransactionsForShoppingCartId(args.shoppingCartId)
5847 
    except TransactionServiceException, ex:
5848 
      result.ex = ex
5849 
    oprot.writeMessageBegin("getTransactionsForShoppingCartId", TMessageType.REPLY, seqid)
5850 
    result.write(oprot)
5851 
    oprot.writeMessageEnd()
5852 
    oprot.trans.flush()
5853 
 
94 ashish 5854 
  def process_getTransactionStatus(self, seqid, iprot, oprot):
5855 
    args = getTransactionStatus_args()
5856 
    args.read(iprot)
5857 
    iprot.readMessageEnd()
5858 
    result = getTransactionStatus_result()
5859 
    try:
5860 
      result.success = self._handler.getTransactionStatus(args.transactionId)
5861 
    except TransactionServiceException, ex:
5862 
      result.ex = ex
5863 
    oprot.writeMessageBegin("getTransactionStatus", TMessageType.REPLY, seqid)
5864 
    result.write(oprot)
5865 
    oprot.writeMessageEnd()
5866 
    oprot.trans.flush()
5867 
 
5868 
  def process_changeTransactionStatus(self, seqid, iprot, oprot):
5869 
    args = changeTransactionStatus_args()
5870 
    args.read(iprot)
5871 
    iprot.readMessageEnd()
5872 
    result = changeTransactionStatus_result()
5873 
    try:
5527 anupam.sin 5874 
      result.success = self._handler.changeTransactionStatus(args.transactionId, args.status, args.description, args.pickUp, args.orderType)
94 ashish 5875 
    except TransactionServiceException, ex:
5876 
      result.ex = ex
5877 
    oprot.writeMessageBegin("changeTransactionStatus", TMessageType.REPLY, seqid)
5878 
    result.write(oprot)
5879 
    oprot.writeMessageEnd()
5880 
    oprot.trans.flush()
5881 
 
1398 varun.gupt 5882 
  def process_enqueueTransactionInfoEmail(self, seqid, iprot, oprot):
5883 
    args = enqueueTransactionInfoEmail_args()
1382 varun.gupt 5884 
    args.read(iprot)
5885 
    iprot.readMessageEnd()
1398 varun.gupt 5886 
    result = enqueueTransactionInfoEmail_result()
1382 varun.gupt 5887 
    try:
1398 varun.gupt 5888 
      result.success = self._handler.enqueueTransactionInfoEmail(args.transactionId)
1382 varun.gupt 5889 
    except TransactionServiceException, ex:
5890 
      result.ex = ex
1398 varun.gupt 5891 
    oprot.writeMessageBegin("enqueueTransactionInfoEmail", TMessageType.REPLY, seqid)
1382 varun.gupt 5892 
    result.write(oprot)
5893 
    oprot.writeMessageEnd()
5894 
    oprot.trans.flush()
5895 
 
483 rajveer 5896 
  def process_getAllOrders(self, seqid, iprot, oprot):
5897 
    args = getAllOrders_args()
94 ashish 5898 
    args.read(iprot)
5899 
    iprot.readMessageEnd()
483 rajveer 5900 
    result = getAllOrders_result()
94 ashish 5901 
    try:
4801 anupam.sin 5902 
      result.success = self._handler.getAllOrders(args.statuses, args.from_date, args.to_date, args.warehouse_id)
94 ashish 5903 
    except TransactionServiceException, ex:
5904 
      result.ex = ex
483 rajveer 5905 
    oprot.writeMessageBegin("getAllOrders", TMessageType.REPLY, seqid)
94 ashish 5906 
    result.write(oprot)
5907 
    oprot.writeMessageEnd()
5908 
    oprot.trans.flush()
5909 
 
4133 chandransh 5910 
  def process_getOrdersInBatch(self, seqid, iprot, oprot):
5911 
    args = getOrdersInBatch_args()
5912 
    args.read(iprot)
5913 
    iprot.readMessageEnd()
5914 
    result = getOrdersInBatch_result()
5915 
    try:
5916 
      result.success = self._handler.getOrdersInBatch(args.statuses, args.offset, args.limit, args.warehouse_id)
5917 
    except TransactionServiceException, ex:
5918 
      result.ex = ex
5919 
    oprot.writeMessageBegin("getOrdersInBatch", TMessageType.REPLY, seqid)
5920 
    result.write(oprot)
5921 
    oprot.writeMessageEnd()
5922 
    oprot.trans.flush()
5923 
 
5924 
  def process_getOrderCount(self, seqid, iprot, oprot):
5925 
    args = getOrderCount_args()
5926 
    args.read(iprot)
5927 
    iprot.readMessageEnd()
5928 
    result = getOrderCount_result()
5929 
    try:
5930 
      result.success = self._handler.getOrderCount(args.statuses, args.warehouseId)
5931 
    except TransactionServiceException, ex:
5932 
      result.ex = ex
5933 
    oprot.writeMessageBegin("getOrderCount", TMessageType.REPLY, seqid)
5934 
    result.write(oprot)
5935 
    oprot.writeMessageEnd()
5936 
    oprot.trans.flush()
5937 
 
999 varun.gupt 5938 
  def process_getOrdersByBillingDate(self, seqid, iprot, oprot):
5939 
    args = getOrdersByBillingDate_args()
5940 
    args.read(iprot)
5941 
    iprot.readMessageEnd()
5942 
    result = getOrdersByBillingDate_result()
5943 
    try:
5944 
      result.success = self._handler.getOrdersByBillingDate(args.status, args.start_billing_date, args.end_billing_date, args.warehouse_id)
5945 
    except TransactionServiceException, ex:
5946 
      result.ex = ex
5947 
    oprot.writeMessageBegin("getOrdersByBillingDate", TMessageType.REPLY, seqid)
5948 
    result.write(oprot)
5949 
    oprot.writeMessageEnd()
5950 
    oprot.trans.flush()
5951 
 
3427 chandransh 5952 
  def process_getOrdersByShippingDate(self, seqid, iprot, oprot):
5953 
    args = getOrdersByShippingDate_args()
5954 
    args.read(iprot)
5955 
    iprot.readMessageEnd()
5956 
    result = getOrdersByShippingDate_result()
5957 
    try:
3451 chandransh 5958 
      result.success = self._handler.getOrdersByShippingDate(args.fromShippingDate, args.toShippingDate, args.providerId, args.warehouseId, args.cod)
3427 chandransh 5959 
    except TransactionServiceException, ex:
5960 
      result.ex = ex
5961 
    oprot.writeMessageBegin("getOrdersByShippingDate", TMessageType.REPLY, seqid)
5962 
    result.write(oprot)
5963 
    oprot.writeMessageEnd()
5964 
    oprot.trans.flush()
5965 
 
1382 varun.gupt 5966 
  def process_getReturnableOrdersForCustomer(self, seqid, iprot, oprot):
5967 
    args = getReturnableOrdersForCustomer_args()
5968 
    args.read(iprot)
5969 
    iprot.readMessageEnd()
5970 
    result = getReturnableOrdersForCustomer_result()
5971 
    try:
5972 
      result.success = self._handler.getReturnableOrdersForCustomer(args.customer_id, args.limit)
5973 
    except TransactionServiceException, ex:
5974 
      result.ex = ex
5975 
    oprot.writeMessageBegin("getReturnableOrdersForCustomer", TMessageType.REPLY, seqid)
5976 
    result.write(oprot)
5977 
    oprot.writeMessageEnd()
5978 
    oprot.trans.flush()
5979 
 
5980 
  def process_getCancellableOrdersForCustomer(self, seqid, iprot, oprot):
5981 
    args = getCancellableOrdersForCustomer_args()
5982 
    args.read(iprot)
5983 
    iprot.readMessageEnd()
5984 
    result = getCancellableOrdersForCustomer_result()
5985 
    try:
5986 
      result.success = self._handler.getCancellableOrdersForCustomer(args.customer_id, args.limit)
5987 
    except TransactionServiceException, ex:
5988 
      result.ex = ex
5989 
    oprot.writeMessageBegin("getCancellableOrdersForCustomer", TMessageType.REPLY, seqid)
5990 
    result.write(oprot)
5991 
    oprot.writeMessageEnd()
5992 
    oprot.trans.flush()
5993 
 
483 rajveer 5994 
  def process_changeOrderStatus(self, seqid, iprot, oprot):
5995 
    args = changeOrderStatus_args()
94 ashish 5996 
    args.read(iprot)
5997 
    iprot.readMessageEnd()
483 rajveer 5998 
    result = changeOrderStatus_result()
94 ashish 5999 
    try:
483 rajveer 6000 
      result.success = self._handler.changeOrderStatus(args.orderId, args.status, args.description)
94 ashish 6001 
    except TransactionServiceException, ex:
6002 
      result.ex = ex
483 rajveer 6003 
    oprot.writeMessageBegin("changeOrderStatus", TMessageType.REPLY, seqid)
94 ashish 6004 
    result.write(oprot)
6005 
    oprot.writeMessageEnd()
6006 
    oprot.trans.flush()
6007 
 
483 rajveer 6008 
  def process_getOrdersForTransaction(self, seqid, iprot, oprot):
6009 
    args = getOrdersForTransaction_args()
94 ashish 6010 
    args.read(iprot)
6011 
    iprot.readMessageEnd()
483 rajveer 6012 
    result = getOrdersForTransaction_result()
94 ashish 6013 
    try:
1528 ankur.sing 6014 
      result.success = self._handler.getOrdersForTransaction(args.transactionId, args.customerId)
94 ashish 6015 
    except TransactionServiceException, ex:
6016 
      result.ex = ex
483 rajveer 6017 
    oprot.writeMessageBegin("getOrdersForTransaction", TMessageType.REPLY, seqid)
94 ashish 6018 
    result.write(oprot)
6019 
    oprot.writeMessageEnd()
6020 
    oprot.trans.flush()
6021 
 
483 rajveer 6022 
  def process_getOrdersForCustomer(self, seqid, iprot, oprot):
6023 
    args = getOrdersForCustomer_args()
94 ashish 6024 
    args.read(iprot)
6025 
    iprot.readMessageEnd()
483 rajveer 6026 
    result = getOrdersForCustomer_result()
94 ashish 6027 
    try:
3014 chandransh 6028 
      result.success = self._handler.getOrdersForCustomer(args.customerId, args.from_date, args.to_date, args.statuses)
94 ashish 6029 
    except TransactionServiceException, ex:
6030 
      result.ex = ex
483 rajveer 6031 
    oprot.writeMessageBegin("getOrdersForCustomer", TMessageType.REPLY, seqid)
94 ashish 6032 
    result.write(oprot)
6033 
    oprot.writeMessageEnd()
6034 
    oprot.trans.flush()
6035 
 
483 rajveer 6036 
  def process_createOrder(self, seqid, iprot, oprot):
6037 
    args = createOrder_args()
94 ashish 6038 
    args.read(iprot)
6039 
    iprot.readMessageEnd()
483 rajveer 6040 
    result = createOrder_result()
94 ashish 6041 
    try:
483 rajveer 6042 
      result.success = self._handler.createOrder(args.order)
94 ashish 6043 
    except TransactionServiceException, ex:
6044 
      result.ex = ex
483 rajveer 6045 
    oprot.writeMessageBegin("createOrder", TMessageType.REPLY, seqid)
94 ashish 6046 
    result.write(oprot)
6047 
    oprot.writeMessageEnd()
6048 
    oprot.trans.flush()
6049 
 
483 rajveer 6050 
  def process_getOrder(self, seqid, iprot, oprot):
6051 
    args = getOrder_args()
94 ashish 6052 
    args.read(iprot)
6053 
    iprot.readMessageEnd()
483 rajveer 6054 
    result = getOrder_result()
94 ashish 6055 
    try:
483 rajveer 6056 
      result.success = self._handler.getOrder(args.id)
94 ashish 6057 
    except TransactionServiceException, ex:
6058 
      result.ex = ex
483 rajveer 6059 
    oprot.writeMessageBegin("getOrder", TMessageType.REPLY, seqid)
94 ashish 6060 
    result.write(oprot)
6061 
    oprot.writeMessageEnd()
6062 
    oprot.trans.flush()
6063 
 
483 rajveer 6064 
  def process_getLineItemsForOrder(self, seqid, iprot, oprot):
6065 
    args = getLineItemsForOrder_args()
94 ashish 6066 
    args.read(iprot)
6067 
    iprot.readMessageEnd()
483 rajveer 6068 
    result = getLineItemsForOrder_result()
94 ashish 6069 
    try:
483 rajveer 6070 
      result.success = self._handler.getLineItemsForOrder(args.orderId)
94 ashish 6071 
    except TransactionServiceException, ex:
6072 
      result.ex = ex
483 rajveer 6073 
    oprot.writeMessageBegin("getLineItemsForOrder", TMessageType.REPLY, seqid)
94 ashish 6074 
    result.write(oprot)
6075 
    oprot.writeMessageEnd()
6076 
    oprot.trans.flush()
6077 
 
4999 phani.kuma 6078 
  def process_getOrderList(self, seqid, iprot, oprot):
6079 
    args = getOrderList_args()
6080 
    args.read(iprot)
6081 
    iprot.readMessageEnd()
6082 
    result = getOrderList_result()
6083 
    result.success = self._handler.getOrderList(args.order_ids)
6084 
    oprot.writeMessageBegin("getOrderList", TMessageType.REPLY, seqid)
6085 
    result.write(oprot)
6086 
    oprot.writeMessageEnd()
6087 
    oprot.trans.flush()
6088 
 
5386 phani.kuma 6089 
  def process_getOrderListForVendor(self, seqid, iprot, oprot):
6090 
    args = getOrderListForVendor_args()
6091 
    args.read(iprot)
6092 
    iprot.readMessageEnd()
6093 
    result = getOrderListForVendor_result()
6094 
    result.success = self._handler.getOrderListForVendor(args.order_ids, args.vendorId)
6095 
    oprot.writeMessageBegin("getOrderListForVendor", TMessageType.REPLY, seqid)
6096 
    result.write(oprot)
6097 
    oprot.writeMessageEnd()
6098 
    oprot.trans.flush()
6099 
 
1528 ankur.sing 6100 
  def process_getOrderForCustomer(self, seqid, iprot, oprot):
6101 
    args = getOrderForCustomer_args()
6102 
    args.read(iprot)
6103 
    iprot.readMessageEnd()
6104 
    result = getOrderForCustomer_result()
6105 
    try:
6106 
      result.success = self._handler.getOrderForCustomer(args.orderId, args.customerId)
6107 
    except TransactionServiceException, ex:
6108 
      result.ex = ex
6109 
    oprot.writeMessageBegin("getOrderForCustomer", TMessageType.REPLY, seqid)
6110 
    result.write(oprot)
6111 
    oprot.writeMessageEnd()
6112 
    oprot.trans.flush()
6113 
 
3064 chandransh 6114 
  def process_getAlerts(self, seqid, iprot, oprot):
6115 
    args = getAlerts_args()
6116 
    args.read(iprot)
6117 
    iprot.readMessageEnd()
6118 
    result = getAlerts_result()
4444 rajveer 6119 
    result.success = self._handler.getAlerts(args.type, args.warehouseId, args.status, args.timestamp)
3064 chandransh 6120 
    oprot.writeMessageBegin("getAlerts", TMessageType.REPLY, seqid)
6121 
    result.write(oprot)
6122 
    oprot.writeMessageEnd()
6123 
    oprot.trans.flush()
6124 
 
4394 rajveer 6125 
  def process_addAlert(self, seqid, iprot, oprot):
6126 
    args = addAlert_args()
3064 chandransh 6127 
    args.read(iprot)
6128 
    iprot.readMessageEnd()
4394 rajveer 6129 
    result = addAlert_result()
4444 rajveer 6130 
    self._handler.addAlert(args.type, args.warehouseId, args.description)
4394 rajveer 6131 
    oprot.writeMessageBegin("addAlert", TMessageType.REPLY, seqid)
3064 chandransh 6132 
    result.write(oprot)
6133 
    oprot.writeMessageEnd()
6134 
    oprot.trans.flush()
6135 
 
4444 rajveer 6136 
  def process_markAlertsAsSeen(self, seqid, iprot, oprot):
6137 
    args = markAlertsAsSeen_args()
6138 
    args.read(iprot)
6139 
    iprot.readMessageEnd()
6140 
    result = markAlertsAsSeen_result()
6141 
    self._handler.markAlertsAsSeen(args.warehouseId)
6142 
    oprot.writeMessageBegin("markAlertsAsSeen", TMessageType.REPLY, seqid)
6143 
    result.write(oprot)
6144 
    oprot.writeMessageEnd()
6145 
    oprot.trans.flush()
6146 
 
3064 chandransh 6147 
  def process_getValidOrderCount(self, seqid, iprot, oprot):
6148 
    args = getValidOrderCount_args()
6149 
    args.read(iprot)
6150 
    iprot.readMessageEnd()
6151 
    result = getValidOrderCount_result()
6152 
    result.success = self._handler.getValidOrderCount()
6153 
    oprot.writeMessageBegin("getValidOrderCount", TMessageType.REPLY, seqid)
6154 
    result.write(oprot)
6155 
    oprot.writeMessageEnd()
6156 
    oprot.trans.flush()
6157 
 
6158 
  def process_getNoOfCustomersWithSuccessfulTransaction(self, seqid, iprot, oprot):
6159 
    args = getNoOfCustomersWithSuccessfulTransaction_args()
6160 
    args.read(iprot)
6161 
    iprot.readMessageEnd()
6162 
    result = getNoOfCustomersWithSuccessfulTransaction_result()
6163 
    result.success = self._handler.getNoOfCustomersWithSuccessfulTransaction()
6164 
    oprot.writeMessageBegin("getNoOfCustomersWithSuccessfulTransaction", TMessageType.REPLY, seqid)
6165 
    result.write(oprot)
6166 
    oprot.writeMessageEnd()
6167 
    oprot.trans.flush()
6168 
 
6169 
  def process_getValidOrdersAmountRange(self, seqid, iprot, oprot):
6170 
    args = getValidOrdersAmountRange_args()
6171 
    args.read(iprot)
6172 
    iprot.readMessageEnd()
6173 
    result = getValidOrdersAmountRange_result()
6174 
    result.success = self._handler.getValidOrdersAmountRange()
6175 
    oprot.writeMessageBegin("getValidOrdersAmountRange", TMessageType.REPLY, seqid)
6176 
    result.write(oprot)
6177 
    oprot.writeMessageEnd()
6178 
    oprot.trans.flush()
6179 
 
6180 
  def process_getValidOrders(self, seqid, iprot, oprot):
6181 
    args = getValidOrders_args()
6182 
    args.read(iprot)
6183 
    iprot.readMessageEnd()
6184 
    result = getValidOrders_result()
5874 rajveer 6185 
    result.success = self._handler.getValidOrders(args.limit, args.onlyStore)
3064 chandransh 6186 
    oprot.writeMessageBegin("getValidOrders", TMessageType.REPLY, seqid)
6187 
    result.write(oprot)
6188 
    oprot.writeMessageEnd()
6189 
    oprot.trans.flush()
6190 
 
1220 chandransh 6191 
  def process_batchOrders(self, seqid, iprot, oprot):
6192 
    args = batchOrders_args()
6193 
    args.read(iprot)
6194 
    iprot.readMessageEnd()
6195 
    result = batchOrders_result()
6196 
    try:
6197 
      result.success = self._handler.batchOrders(args.warehouseId)
6198 
    except TransactionServiceException, ex:
6199 
      result.ex = ex
6200 
    oprot.writeMessageBegin("batchOrders", TMessageType.REPLY, seqid)
6201 
    result.write(oprot)
6202 
    oprot.writeMessageEnd()
6203 
    oprot.trans.flush()
6204 
 
1208 chandransh 6205 
  def process_markOrderAsOutOfStock(self, seqid, iprot, oprot):
6206 
    args = markOrderAsOutOfStock_args()
6207 
    args.read(iprot)
6208 
    iprot.readMessageEnd()
6209 
    result = markOrderAsOutOfStock_result()
6210 
    try:
6211 
      result.success = self._handler.markOrderAsOutOfStock(args.orderId)
6212 
    except TransactionServiceException, ex:
6213 
      result.ex = ex
6214 
    oprot.writeMessageBegin("markOrderAsOutOfStock", TMessageType.REPLY, seqid)
6215 
    result.write(oprot)
6216 
    oprot.writeMessageEnd()
6217 
    oprot.trans.flush()
6218 
 
3064 chandransh 6219 
  def process_verifyOrder(self, seqid, iprot, oprot):
6220 
    args = verifyOrder_args()
759 chandransh 6221 
    args.read(iprot)
6222 
    iprot.readMessageEnd()
3064 chandransh 6223 
    result = verifyOrder_result()
759 chandransh 6224 
    try:
3064 chandransh 6225 
      result.success = self._handler.verifyOrder(args.orderId)
759 chandransh 6226 
    except TransactionServiceException, ex:
6227 
      result.ex = ex
3064 chandransh 6228 
    oprot.writeMessageBegin("verifyOrder", TMessageType.REPLY, seqid)
759 chandransh 6229 
    result.write(oprot)
6230 
    oprot.writeMessageEnd()
6231 
    oprot.trans.flush()
6232 
 
3064 chandransh 6233 
  def process_acceptOrder(self, seqid, iprot, oprot):
6234 
    args = acceptOrder_args()
1113 chandransh 6235 
    args.read(iprot)
6236 
    iprot.readMessageEnd()
3064 chandransh 6237 
    result = acceptOrder_result()
1113 chandransh 6238 
    try:
3064 chandransh 6239 
      result.success = self._handler.acceptOrder(args.orderId)
1113 chandransh 6240 
    except TransactionServiceException, ex:
6241 
      result.ex = ex
3064 chandransh 6242 
    oprot.writeMessageBegin("acceptOrder", TMessageType.REPLY, seqid)
1113 chandransh 6243 
    result.write(oprot)
6244 
    oprot.writeMessageEnd()
6245 
    oprot.trans.flush()
6246 
 
3064 chandransh 6247 
  def process_addBillingDetails(self, seqid, iprot, oprot):
6248 
    args = addBillingDetails_args()
1135 chandransh 6249 
    args.read(iprot)
6250 
    iprot.readMessageEnd()
3064 chandransh 6251 
    result = addBillingDetails_result()
1135 chandransh 6252 
    try:
5110 mandeep.dh 6253 
      result.success = self._handler.addBillingDetails(args.orderId, args.invoice_number, args.serialNumber, args.itemNumber, args.billed_by, args.jacketNumber, args.billingType, args.fulfilmentWarehouseId, args.authorize)
1135 chandransh 6254 
    except TransactionServiceException, ex:
6255 
      result.ex = ex
3064 chandransh 6256 
    oprot.writeMessageBegin("addBillingDetails", TMessageType.REPLY, seqid)
1135 chandransh 6257 
    result.write(oprot)
6258 
    oprot.writeMessageEnd()
6259 
    oprot.trans.flush()
6260 
 
4579 rajveer 6261 
  def process_addInvoiceNumber(self, seqid, iprot, oprot):
6262 
    args = addInvoiceNumber_args()
6263 
    args.read(iprot)
6264 
    iprot.readMessageEnd()
6265 
    result = addInvoiceNumber_result()
6266 
    try:
4763 rajveer 6267 
      self._handler.addInvoiceNumber(args.orderId, args.invoiceNumber, args.color)
4579 rajveer 6268 
    except TransactionServiceException, ex:
6269 
      result.ex = ex
6270 
    oprot.writeMessageBegin("addInvoiceNumber", TMessageType.REPLY, seqid)
6271 
    result.write(oprot)
6272 
    oprot.writeMessageEnd()
6273 
    oprot.trans.flush()
6274 
 
4410 rajveer 6275 
  def process_markOrdersAsShippedFromWarehouse(self, seqid, iprot, oprot):
6276 
    args = markOrdersAsShippedFromWarehouse_args()
6277 
    args.read(iprot)
6278 
    iprot.readMessageEnd()
6279 
    result = markOrdersAsShippedFromWarehouse_result()
6280 
    try:
4789 rajveer 6281 
      result.success = self._handler.markOrdersAsShippedFromWarehouse(args.warehouseId, args.providerId, args.cod, args.orderIds)
4410 rajveer 6282 
    except TransactionServiceException, ex:
6283 
      result.ex = ex
6284 
    oprot.writeMessageBegin("markOrdersAsShippedFromWarehouse", TMessageType.REPLY, seqid)
6285 
    result.write(oprot)
6286 
    oprot.writeMessageEnd()
6287 
    oprot.trans.flush()
6288 
 
5676 rajveer 6289 
  def process_markOrdersAsReturnedFromStore(self, seqid, iprot, oprot):
6290 
    args = markOrdersAsReturnedFromStore_args()
6291 
    args.read(iprot)
6292 
    iprot.readMessageEnd()
6293 
    result = markOrdersAsReturnedFromStore_result()
6294 
    try:
5713 rajveer 6295 
      result.success = self._handler.markOrdersAsReturnedFromStore(args.providerId, args.orderIds, args.awbs)
5676 rajveer 6296 
    except TransactionServiceException, ex:
6297 
      result.ex = ex
6298 
    oprot.writeMessageBegin("markOrdersAsReturnedFromStore", TMessageType.REPLY, seqid)
6299 
    result.write(oprot)
6300 
    oprot.writeMessageEnd()
6301 
    oprot.trans.flush()
6302 
 
3064 chandransh 6303 
  def process_markOrdersAsPickedUp(self, seqid, iprot, oprot):
6304 
    args = markOrdersAsPickedUp_args()
304 ashish 6305 
    args.read(iprot)
6306 
    iprot.readMessageEnd()
3064 chandransh 6307 
    result = markOrdersAsPickedUp_result()
6308 
    try:
4910 phani.kuma 6309 
      self._handler.markOrdersAsPickedUp(args.providerId, args.pickupDetails)
3064 chandransh 6310 
    except TransactionServiceException, ex:
6311 
      result.ex = ex
6312 
    oprot.writeMessageBegin("markOrdersAsPickedUp", TMessageType.REPLY, seqid)
304 ashish 6313 
    result.write(oprot)
6314 
    oprot.writeMessageEnd()
6315 
    oprot.trans.flush()
94 ashish 6316 
 
4910 phani.kuma 6317 
  def process_getOrdersNotPickedUp(self, seqid, iprot, oprot):
6318 
    args = getOrdersNotPickedUp_args()
6319 
    args.read(iprot)
6320 
    iprot.readMessageEnd()
6321 
    result = getOrdersNotPickedUp_result()
6322 
    result.success = self._handler.getOrdersNotPickedUp(args.providerId)
6323 
    oprot.writeMessageBegin("getOrdersNotPickedUp", TMessageType.REPLY, seqid)
6324 
    result.write(oprot)
6325 
    oprot.writeMessageEnd()
6326 
    oprot.trans.flush()
6327 
 
3064 chandransh 6328 
  def process_markOrdersAsDelivered(self, seqid, iprot, oprot):
6329 
    args = markOrdersAsDelivered_args()
304 ashish 6330 
    args.read(iprot)
6331 
    iprot.readMessageEnd()
3064 chandransh 6332 
    result = markOrdersAsDelivered_result()
6333 
    try:
6334 
      self._handler.markOrdersAsDelivered(args.providerId, args.deliveredOrders)
6335 
    except TransactionServiceException, ex:
6336 
      result.ex = ex
6337 
    oprot.writeMessageBegin("markOrdersAsDelivered", TMessageType.REPLY, seqid)
304 ashish 6338 
    result.write(oprot)
6339 
    oprot.writeMessageEnd()
6340 
    oprot.trans.flush()
6341 
 
4910 phani.kuma 6342 
  def process_markAsRTOrders(self, seqid, iprot, oprot):
6343 
    args = markAsRTOrders_args()
1596 ankur.sing 6344 
    args.read(iprot)
6345 
    iprot.readMessageEnd()
4910 phani.kuma 6346 
    result = markAsRTOrders_result()
3064 chandransh 6347 
    try:
4910 phani.kuma 6348 
      self._handler.markAsRTOrders(args.providerId, args.returnedOrders)
3064 chandransh 6349 
    except TransactionServiceException, ex:
6350 
      result.ex = ex
4910 phani.kuma 6351 
    oprot.writeMessageBegin("markAsRTOrders", TMessageType.REPLY, seqid)
1596 ankur.sing 6352 
    result.write(oprot)
6353 
    oprot.writeMessageEnd()
6354 
    oprot.trans.flush()
304 ashish 6355 
 
4910 phani.kuma 6356 
  def process_getRTOrders(self, seqid, iprot, oprot):
6357 
    args = getRTOrders_args()
6358 
    args.read(iprot)
6359 
    iprot.readMessageEnd()
6360 
    result = getRTOrders_result()
6361 
    result.success = self._handler.getRTOrders(args.providerId)
6362 
    oprot.writeMessageBegin("getRTOrders", TMessageType.REPLY, seqid)
6363 
    result.write(oprot)
6364 
    oprot.writeMessageEnd()
6365 
    oprot.trans.flush()
6366 
 
3064 chandransh 6367 
  def process_updateNonDeliveryReason(self, seqid, iprot, oprot):
6368 
    args = updateNonDeliveryReason_args()
1627 ankur.sing 6369 
    args.read(iprot)
6370 
    iprot.readMessageEnd()
3064 chandransh 6371 
    result = updateNonDeliveryReason_result()
6372 
    try:
4910 phani.kuma 6373 
      self._handler.updateNonDeliveryReason(args.providerId, args.undeliveredOrders)
3064 chandransh 6374 
    except TransactionServiceException, ex:
6375 
      result.ex = ex
6376 
    oprot.writeMessageBegin("updateNonDeliveryReason", TMessageType.REPLY, seqid)
1627 ankur.sing 6377 
    result.write(oprot)
6378 
    oprot.writeMessageEnd()
6379 
    oprot.trans.flush()
1596 ankur.sing 6380 
 
4910 phani.kuma 6381 
  def process_getNonDeliveredOrdersbyCourier(self, seqid, iprot, oprot):
6382 
    args = getNonDeliveredOrdersbyCourier_args()
6383 
    args.read(iprot)
6384 
    iprot.readMessageEnd()
6385 
    result = getNonDeliveredOrdersbyCourier_result()
6386 
    result.success = self._handler.getNonDeliveredOrdersbyCourier(args.providerId)
6387 
    oprot.writeMessageBegin("getNonDeliveredOrdersbyCourier", TMessageType.REPLY, seqid)
6388 
    result.write(oprot)
6389 
    oprot.writeMessageEnd()
6390 
    oprot.trans.flush()
6391 
 
6392 
  def process_markOrdersAsLocalConnected(self, seqid, iprot, oprot):
6393 
    args = markOrdersAsLocalConnected_args()
6394 
    args.read(iprot)
6395 
    iprot.readMessageEnd()
6396 
    result = markOrdersAsLocalConnected_result()
6397 
    try:
6398 
      self._handler.markOrdersAsLocalConnected(args.providerId, args.local_connected_orders)
6399 
    except TransactionServiceException, ex:
6400 
      result.ex = ex
6401 
    oprot.writeMessageBegin("markOrdersAsLocalConnected", TMessageType.REPLY, seqid)
6402 
    result.write(oprot)
6403 
    oprot.writeMessageEnd()
6404 
    oprot.trans.flush()
6405 
 
6406 
  def process_getOrdersNotLocalConnected(self, seqid, iprot, oprot):
6407 
    args = getOrdersNotLocalConnected_args()
6408 
    args.read(iprot)
6409 
    iprot.readMessageEnd()
6410 
    result = getOrdersNotLocalConnected_result()
6411 
    result.success = self._handler.getOrdersNotLocalConnected(args.providerId)
6412 
    oprot.writeMessageBegin("getOrdersNotLocalConnected", TMessageType.REPLY, seqid)
6413 
    result.write(oprot)
6414 
    oprot.writeMessageEnd()
6415 
    oprot.trans.flush()
6416 
 
6417 
  def process_markOrdersAsDestinationCityReached(self, seqid, iprot, oprot):
6418 
    args = markOrdersAsDestinationCityReached_args()
6419 
    args.read(iprot)
6420 
    iprot.readMessageEnd()
6421 
    result = markOrdersAsDestinationCityReached_result()
6422 
    try:
6423 
      self._handler.markOrdersAsDestinationCityReached(args.providerId, args.destination_city_reached_orders)
6424 
    except TransactionServiceException, ex:
6425 
      result.ex = ex
6426 
    oprot.writeMessageBegin("markOrdersAsDestinationCityReached", TMessageType.REPLY, seqid)
6427 
    result.write(oprot)
6428 
    oprot.writeMessageEnd()
6429 
    oprot.trans.flush()
6430 
 
6431 
  def process_markOrdersAsFirstDeliveryAttempted(self, seqid, iprot, oprot):
6432 
    args = markOrdersAsFirstDeliveryAttempted_args()
6433 
    args.read(iprot)
6434 
    iprot.readMessageEnd()
6435 
    result = markOrdersAsFirstDeliveryAttempted_result()
6436 
    try:
6437 
      self._handler.markOrdersAsFirstDeliveryAttempted(args.providerId, args.first_atdl_orders)
6438 
    except TransactionServiceException, ex:
6439 
      result.ex = ex
6440 
    oprot.writeMessageBegin("markOrdersAsFirstDeliveryAttempted", TMessageType.REPLY, seqid)
6441 
    result.write(oprot)
6442 
    oprot.writeMessageEnd()
6443 
    oprot.trans.flush()
6444 
 
3064 chandransh 6445 
  def process_getUndeliveredOrders(self, seqid, iprot, oprot):
6446 
    args = getUndeliveredOrders_args()
1627 ankur.sing 6447 
    args.read(iprot)
6448 
    iprot.readMessageEnd()
3064 chandransh 6449 
    result = getUndeliveredOrders_result()
6450 
    result.success = self._handler.getUndeliveredOrders(args.providerId, args.warehouseId)
6451 
    oprot.writeMessageBegin("getUndeliveredOrders", TMessageType.REPLY, seqid)
1627 ankur.sing 6452 
    result.write(oprot)
6453 
    oprot.writeMessageEnd()
6454 
    oprot.trans.flush()
6455 
 
4783 phani.kuma 6456 
  def process_getUndeliveredOrdersExpectedDeliveryDateNotMet(self, seqid, iprot, oprot):
6457 
    args = getUndeliveredOrdersExpectedDeliveryDateNotMet_args()
6458 
    args.read(iprot)
6459 
    iprot.readMessageEnd()
6460 
    result = getUndeliveredOrdersExpectedDeliveryDateNotMet_result()
6461 
    result.success = self._handler.getUndeliveredOrdersExpectedDeliveryDateNotMet()
6462 
    oprot.writeMessageBegin("getUndeliveredOrdersExpectedDeliveryDateNotMet", TMessageType.REPLY, seqid)
6463 
    result.write(oprot)
6464 
    oprot.writeMessageEnd()
6465 
    oprot.trans.flush()
6466 
 
2536 chandransh 6467 
  def process_toggleDOAFlag(self, seqid, iprot, oprot):
6468 
    args = toggleDOAFlag_args()
6469 
    args.read(iprot)
6470 
    iprot.readMessageEnd()
6471 
    result = toggleDOAFlag_result()
6472 
    try:
6473 
      result.success = self._handler.toggleDOAFlag(args.orderId)
6474 
    except TransactionServiceException, ex:
6475 
      result.ex = ex
6476 
    oprot.writeMessageBegin("toggleDOAFlag", TMessageType.REPLY, seqid)
6477 
    result.write(oprot)
6478 
    oprot.writeMessageEnd()
6479 
    oprot.trans.flush()
1886 ankur.sing 6480 
 
4712 rajveer 6481 
  def process_markOrderAsDelivered(self, seqid, iprot, oprot):
6482 
    args = markOrderAsDelivered_args()
6483 
    args.read(iprot)
6484 
    iprot.readMessageEnd()
6485 
    result = markOrderAsDelivered_result()
6486 
    try:
6487 
      self._handler.markOrderAsDelivered(args.orderId, args.deliveryTimestamp, args.receiver)
6488 
    except TransactionServiceException, ex:
6489 
      result.ex = ex
6490 
    oprot.writeMessageBegin("markOrderAsDelivered", TMessageType.REPLY, seqid)
6491 
    result.write(oprot)
6492 
    oprot.writeMessageEnd()
6493 
    oprot.trans.flush()
6494 
 
5553 rajveer 6495 
  def process_markOrderAsReceivedAtStore(self, seqid, iprot, oprot):
6496 
    args = markOrderAsReceivedAtStore_args()
6497 
    args.read(iprot)
6498 
    iprot.readMessageEnd()
6499 
    result = markOrderAsReceivedAtStore_result()
6500 
    try:
6501 
      self._handler.markOrderAsReceivedAtStore(args.orderId, args.deliveryTimestamp)
6502 
    except TransactionServiceException, ex:
6503 
      result.ex = ex
6504 
    oprot.writeMessageBegin("markOrderAsReceivedAtStore", TMessageType.REPLY, seqid)
6505 
    result.write(oprot)
6506 
    oprot.writeMessageEnd()
6507 
    oprot.trans.flush()
6508 
 
4454 rajveer 6509 
  def process_markOrderDoaRequestReceived(self, seqid, iprot, oprot):
6510 
    args = markOrderDoaRequestReceived_args()
6511 
    args.read(iprot)
6512 
    iprot.readMessageEnd()
6513 
    result = markOrderDoaRequestReceived_result()
6514 
    try:
6515 
      result.success = self._handler.markOrderDoaRequestReceived(args.orderId)
6516 
    except TransactionServiceException, ex:
6517 
      result.ex = ex
6518 
    oprot.writeMessageBegin("markOrderDoaRequestReceived", TMessageType.REPLY, seqid)
6519 
    result.write(oprot)
6520 
    oprot.writeMessageEnd()
6521 
    oprot.trans.flush()
6522 
 
6523 
  def process_markOrderDoaRequestAuthorized(self, seqid, iprot, oprot):
6524 
    args = markOrderDoaRequestAuthorized_args()
6525 
    args.read(iprot)
6526 
    iprot.readMessageEnd()
6527 
    result = markOrderDoaRequestAuthorized_result()
6528 
    try:
6529 
      result.success = self._handler.markOrderDoaRequestAuthorized(args.orderId, args.isAuthorized)
6530 
    except TransactionServiceException, ex:
6531 
      result.ex = ex
6532 
    oprot.writeMessageBegin("markOrderDoaRequestAuthorized", TMessageType.REPLY, seqid)
6533 
    result.write(oprot)
6534 
    oprot.writeMessageEnd()
6535 
    oprot.trans.flush()
6536 
 
4488 rajveer 6537 
  def process_markOrderReturnRequestReceived(self, seqid, iprot, oprot):
6538 
    args = markOrderReturnRequestReceived_args()
6539 
    args.read(iprot)
6540 
    iprot.readMessageEnd()
6541 
    result = markOrderReturnRequestReceived_result()
6542 
    try:
6543 
      result.success = self._handler.markOrderReturnRequestReceived(args.orderId)
6544 
    except TransactionServiceException, ex:
6545 
      result.ex = ex
6546 
    oprot.writeMessageBegin("markOrderReturnRequestReceived", TMessageType.REPLY, seqid)
6547 
    result.write(oprot)
6548 
    oprot.writeMessageEnd()
6549 
    oprot.trans.flush()
6550 
 
6551 
  def process_markOrderReturnRequestAuthorized(self, seqid, iprot, oprot):
6552 
    args = markOrderReturnRequestAuthorized_args()
6553 
    args.read(iprot)
6554 
    iprot.readMessageEnd()
6555 
    result = markOrderReturnRequestAuthorized_result()
6556 
    try:
6557 
      result.success = self._handler.markOrderReturnRequestAuthorized(args.orderId, args.isAuthorized)
6558 
    except TransactionServiceException, ex:
6559 
      result.ex = ex
6560 
    oprot.writeMessageBegin("markOrderReturnRequestAuthorized", TMessageType.REPLY, seqid)
6561 
    result.write(oprot)
6562 
    oprot.writeMessageEnd()
6563 
    oprot.trans.flush()
6564 
 
2536 chandransh 6565 
  def process_requestPickupNumber(self, seqid, iprot, oprot):
6566 
    args = requestPickupNumber_args()
6567 
    args.read(iprot)
6568 
    iprot.readMessageEnd()
6569 
    result = requestPickupNumber_result()
6570 
    try:
4579 rajveer 6571 
      result.success = self._handler.requestPickupNumber(args.orderId, args.providerId)
2536 chandransh 6572 
    except TransactionServiceException, ex:
6573 
      result.ex = ex
6574 
    oprot.writeMessageBegin("requestPickupNumber", TMessageType.REPLY, seqid)
6575 
    result.write(oprot)
6576 
    oprot.writeMessageEnd()
6577 
    oprot.trans.flush()
6578 
 
6579 
  def process_authorizePickup(self, seqid, iprot, oprot):
6580 
    args = authorizePickup_args()
6581 
    args.read(iprot)
6582 
    iprot.readMessageEnd()
6583 
    result = authorizePickup_result()
6584 
    try:
4602 rajveer 6585 
      result.success = self._handler.authorizePickup(args.orderId, args.pickupNumber, args.providerId)
2536 chandransh 6586 
    except TransactionServiceException, ex:
6587 
      result.ex = ex
6588 
    oprot.writeMessageBegin("authorizePickup", TMessageType.REPLY, seqid)
6589 
    result.write(oprot)
6590 
    oprot.writeMessageEnd()
6591 
    oprot.trans.flush()
6592 
 
2764 chandransh 6593 
  def process_markDoasAsPickedUp(self, seqid, iprot, oprot):
6594 
    args = markDoasAsPickedUp_args()
6595 
    args.read(iprot)
6596 
    iprot.readMessageEnd()
6597 
    result = markDoasAsPickedUp_result()
4910 phani.kuma 6598 
    self._handler.markDoasAsPickedUp(args.providerId, args.pickupDetails)
2764 chandransh 6599 
    oprot.writeMessageBegin("markDoasAsPickedUp", TMessageType.REPLY, seqid)
6600 
    result.write(oprot)
6601 
    oprot.writeMessageEnd()
6602 
    oprot.trans.flush()
6603 
 
4910 phani.kuma 6604 
  def process_getDoasNotPickedUp(self, seqid, iprot, oprot):
6605 
    args = getDoasNotPickedUp_args()
6606 
    args.read(iprot)
6607 
    iprot.readMessageEnd()
6608 
    result = getDoasNotPickedUp_result()
6609 
    result.success = self._handler.getDoasNotPickedUp(args.providerId)
6610 
    oprot.writeMessageBegin("getDoasNotPickedUp", TMessageType.REPLY, seqid)
6611 
    result.write(oprot)
6612 
    oprot.writeMessageEnd()
6613 
    oprot.trans.flush()
6614 
 
4741 phani.kuma 6615 
  def process_markReturnOrdersAsPickedUp(self, seqid, iprot, oprot):
6616 
    args = markReturnOrdersAsPickedUp_args()
6617 
    args.read(iprot)
6618 
    iprot.readMessageEnd()
6619 
    result = markReturnOrdersAsPickedUp_result()
4910 phani.kuma 6620 
    self._handler.markReturnOrdersAsPickedUp(args.providerId, args.pickupDetails)
4741 phani.kuma 6621 
    oprot.writeMessageBegin("markReturnOrdersAsPickedUp", TMessageType.REPLY, seqid)
6622 
    result.write(oprot)
6623 
    oprot.writeMessageEnd()
6624 
    oprot.trans.flush()
6625 
 
4910 phani.kuma 6626 
  def process_getReturnOrdersNotPickedUp(self, seqid, iprot, oprot):
6627 
    args = getReturnOrdersNotPickedUp_args()
6628 
    args.read(iprot)
6629 
    iprot.readMessageEnd()
6630 
    result = getReturnOrdersNotPickedUp_result()
6631 
    result.success = self._handler.getReturnOrdersNotPickedUp(args.providerId)
6632 
    oprot.writeMessageBegin("getReturnOrdersNotPickedUp", TMessageType.REPLY, seqid)
6633 
    result.write(oprot)
6634 
    oprot.writeMessageEnd()
6635 
    oprot.trans.flush()
6636 
 
2616 chandransh 6637 
  def process_receiveReturn(self, seqid, iprot, oprot):
6638 
    args = receiveReturn_args()
2591 chandransh 6639 
    args.read(iprot)
6640 
    iprot.readMessageEnd()
2616 chandransh 6641 
    result = receiveReturn_result()
2591 chandransh 6642 
    try:
4479 rajveer 6643 
      result.success = self._handler.receiveReturn(args.orderId, args.receiveCondition)
2591 chandransh 6644 
    except TransactionServiceException, ex:
6645 
      result.ex = ex
2616 chandransh 6646 
    oprot.writeMessageBegin("receiveReturn", TMessageType.REPLY, seqid)
2591 chandransh 6647 
    result.write(oprot)
6648 
    oprot.writeMessageEnd()
6649 
    oprot.trans.flush()
2536 chandransh 6650 
 
2591 chandransh 6651 
  def process_validateDoa(self, seqid, iprot, oprot):
6652 
    args = validateDoa_args()
6653 
    args.read(iprot)
6654 
    iprot.readMessageEnd()
6655 
    result = validateDoa_result()
6656 
    try:
6657 
      result.success = self._handler.validateDoa(args.orderId, args.isValid)
6658 
    except TransactionServiceException, ex:
6659 
      result.ex = ex
6660 
    oprot.writeMessageBegin("validateDoa", TMessageType.REPLY, seqid)
6661 
    result.write(oprot)
6662 
    oprot.writeMessageEnd()
6663 
    oprot.trans.flush()
6664 
 
4495 rajveer 6665 
  def process_validateReturnProduct(self, seqid, iprot, oprot):
6666 
    args = validateReturnProduct_args()
6667 
    args.read(iprot)
6668 
    iprot.readMessageEnd()
6669 
    result = validateReturnProduct_result()
6670 
    try:
6671 
      result.success = self._handler.validateReturnProduct(args.orderId, args.isUsable)
6672 
    except TransactionServiceException, ex:
6673 
      result.ex = ex
6674 
    oprot.writeMessageBegin("validateReturnProduct", TMessageType.REPLY, seqid)
6675 
    result.write(oprot)
6676 
    oprot.writeMessageEnd()
6677 
    oprot.trans.flush()
6678 
 
2616 chandransh 6679 
  def process_reshipOrder(self, seqid, iprot, oprot):
6680 
    args = reshipOrder_args()
6681 
    args.read(iprot)
6682 
    iprot.readMessageEnd()
6683 
    result = reshipOrder_result()
6684 
    try:
6685 
      result.success = self._handler.reshipOrder(args.orderId)
6686 
    except TransactionServiceException, ex:
6687 
      result.ex = ex
6688 
    oprot.writeMessageBegin("reshipOrder", TMessageType.REPLY, seqid)
6689 
    result.write(oprot)
6690 
    oprot.writeMessageEnd()
6691 
    oprot.trans.flush()
2591 chandransh 6692 
 
2616 chandransh 6693 
  def process_refundOrder(self, seqid, iprot, oprot):
6694 
    args = refundOrder_args()
6695 
    args.read(iprot)
6696 
    iprot.readMessageEnd()
6697 
    result = refundOrder_result()
6698 
    try:
3226 chandransh 6699 
      result.success = self._handler.refundOrder(args.orderId, args.refundedBy, args.reason)
2616 chandransh 6700 
    except TransactionServiceException, ex:
6701 
      result.ex = ex
6702 
    oprot.writeMessageBegin("refundOrder", TMessageType.REPLY, seqid)
6703 
    result.write(oprot)
6704 
    oprot.writeMessageEnd()
6705 
    oprot.trans.flush()
6706 
 
2690 chandransh 6707 
  def process_getReturnOrders(self, seqid, iprot, oprot):
6708 
    args = getReturnOrders_args()
6709 
    args.read(iprot)
6710 
    iprot.readMessageEnd()
6711 
    result = getReturnOrders_result()
6712 
    result.success = self._handler.getReturnOrders(args.warehouseId, args.fromDate, args.toDate)
6713 
    oprot.writeMessageBegin("getReturnOrders", TMessageType.REPLY, seqid)
6714 
    result.write(oprot)
6715 
    oprot.writeMessageEnd()
6716 
    oprot.trans.flush()
2616 chandransh 6717 
 
5481 phani.kuma 6718 
  def process_getAllReturnOrders(self, seqid, iprot, oprot):
6719 
    args = getAllReturnOrders_args()
6720 
    args.read(iprot)
6721 
    iprot.readMessageEnd()
6722 
    result = getAllReturnOrders_result()
6723 
    result.success = self._handler.getAllReturnOrders(args.onlyNotProcessed, args.fromDate, args.toDate)
6724 
    oprot.writeMessageBegin("getAllReturnOrders", TMessageType.REPLY, seqid)
6725 
    result.write(oprot)
6726 
    oprot.writeMessageEnd()
6727 
    oprot.trans.flush()
6728 
 
2700 chandransh 6729 
  def process_getReturnOrder(self, seqid, iprot, oprot):
6730 
    args = getReturnOrder_args()
6731 
    args.read(iprot)
6732 
    iprot.readMessageEnd()
6733 
    result = getReturnOrder_result()
6734 
    try:
6735 
      result.success = self._handler.getReturnOrder(args.id)
6736 
    except TransactionServiceException, ex:
6737 
      result.ex = ex
6738 
    oprot.writeMessageBegin("getReturnOrder", TMessageType.REPLY, seqid)
6739 
    result.write(oprot)
6740 
    oprot.writeMessageEnd()
6741 
    oprot.trans.flush()
6742 
 
2690 chandransh 6743 
  def process_processReturn(self, seqid, iprot, oprot):
6744 
    args = processReturn_args()
6745 
    args.read(iprot)
6746 
    iprot.readMessageEnd()
6747 
    result = processReturn_result()
6748 
    try:
6749 
      self._handler.processReturn(args.returnOrderId)
6750 
    except TransactionServiceException, ex:
6751 
      result.ex = ex
6752 
    oprot.writeMessageBegin("processReturn", TMessageType.REPLY, seqid)
6753 
    result.write(oprot)
6754 
    oprot.writeMessageEnd()
6755 
    oprot.trans.flush()
6756 
 
3451 chandransh 6757 
  def process_updateWeight(self, seqid, iprot, oprot):
6758 
    args = updateWeight_args()
6759 
    args.read(iprot)
6760 
    iprot.readMessageEnd()
6761 
    result = updateWeight_result()
6762 
    try:
6763 
      result.success = self._handler.updateWeight(args.orderId, args.weight)
6764 
    except TransactionServiceException, ex:
6765 
      result.ex = ex
6766 
    oprot.writeMessageBegin("updateWeight", TMessageType.REPLY, seqid)
6767 
    result.write(oprot)
6768 
    oprot.writeMessageEnd()
6769 
    oprot.trans.flush()
2819 chandransh 6770 
 
3469 chandransh 6771 
  def process_changeItem(self, seqid, iprot, oprot):
6772 
    args = changeItem_args()
6773 
    args.read(iprot)
6774 
    iprot.readMessageEnd()
6775 
    result = changeItem_result()
6776 
    try:
6777 
      result.success = self._handler.changeItem(args.orderId, args.itemId)
6778 
    except TransactionServiceException, ex:
6779 
      result.ex = ex
6780 
    oprot.writeMessageBegin("changeItem", TMessageType.REPLY, seqid)
6781 
    result.write(oprot)
6782 
    oprot.writeMessageEnd()
6783 
    oprot.trans.flush()
3451 chandransh 6784 
 
3469 chandransh 6785 
  def process_shiftToWarehouse(self, seqid, iprot, oprot):
6786 
    args = shiftToWarehouse_args()
6787 
    args.read(iprot)
6788 
    iprot.readMessageEnd()
6789 
    result = shiftToWarehouse_result()
6790 
    try:
6791 
      result.success = self._handler.shiftToWarehouse(args.orderId, args.warehouseId)
6792 
    except TransactionServiceException, ex:
6793 
      result.ex = ex
6794 
    oprot.writeMessageBegin("shiftToWarehouse", TMessageType.REPLY, seqid)
6795 
    result.write(oprot)
6796 
    oprot.writeMessageEnd()
6797 
    oprot.trans.flush()
6798 
 
3553 chandransh 6799 
  def process_addDelayReason(self, seqid, iprot, oprot):
6800 
    args = addDelayReason_args()
6801 
    args.read(iprot)
6802 
    iprot.readMessageEnd()
6803 
    result = addDelayReason_result()
6804 
    try:
4647 rajveer 6805 
      result.success = self._handler.addDelayReason(args.orderId, args.delayReason, args.furtherDelay, args.delayReasonText)
3553 chandransh 6806 
    except TransactionServiceException, ex:
6807 
      result.ex = ex
6808 
    oprot.writeMessageBegin("addDelayReason", TMessageType.REPLY, seqid)
6809 
    result.write(oprot)
6810 
    oprot.writeMessageEnd()
6811 
    oprot.trans.flush()
3469 chandransh 6812 
 
3956 chandransh 6813 
  def process_reconcileCodCollection(self, seqid, iprot, oprot):
6814 
    args = reconcileCodCollection_args()
6815 
    args.read(iprot)
6816 
    iprot.readMessageEnd()
6817 
    result = reconcileCodCollection_result()
6818 
    try:
6819 
      result.success = self._handler.reconcileCodCollection(args.collectedAmountMap, args.xferBy, args.xferTxnId, args.xferDate)
6820 
    except TransactionServiceException, ex:
6821 
      result.ex = ex
6822 
    oprot.writeMessageBegin("reconcileCodCollection", TMessageType.REPLY, seqid)
6823 
    result.write(oprot)
6824 
    oprot.writeMessageEnd()
6825 
    oprot.trans.flush()
3553 chandransh 6826 
 
4008 mandeep.dh 6827 
  def process_getTransactionsRequiringExtraProcessing(self, seqid, iprot, oprot):
6828 
    args = getTransactionsRequiringExtraProcessing_args()
6829 
    args.read(iprot)
6830 
    iprot.readMessageEnd()
6831 
    result = getTransactionsRequiringExtraProcessing_result()
6832 
    result.success = self._handler.getTransactionsRequiringExtraProcessing(args.category)
6833 
    oprot.writeMessageBegin("getTransactionsRequiringExtraProcessing", TMessageType.REPLY, seqid)
6834 
    result.write(oprot)
6835 
    oprot.writeMessageEnd()
6836 
    oprot.trans.flush()
3956 chandransh 6837 
 
4008 mandeep.dh 6838 
  def process_markTransactionAsProcessed(self, seqid, iprot, oprot):
6839 
    args = markTransactionAsProcessed_args()
6840 
    args.read(iprot)
6841 
    iprot.readMessageEnd()
6842 
    result = markTransactionAsProcessed_result()
6843 
    self._handler.markTransactionAsProcessed(args.transactionId, args.category)
6844 
    oprot.writeMessageBegin("markTransactionAsProcessed", TMessageType.REPLY, seqid)
6845 
    result.write(oprot)
6846 
    oprot.writeMessageEnd()
6847 
    oprot.trans.flush()
6848 
 
4018 chandransh 6849 
  def process_getItemWiseRiskyOrdersCount(self, seqid, iprot, oprot):
6850 
    args = getItemWiseRiskyOrdersCount_args()
6851 
    args.read(iprot)
6852 
    iprot.readMessageEnd()
6853 
    result = getItemWiseRiskyOrdersCount_result()
6854 
    result.success = self._handler.getItemWiseRiskyOrdersCount()
6855 
    oprot.writeMessageBegin("getItemWiseRiskyOrdersCount", TMessageType.REPLY, seqid)
6856 
    result.write(oprot)
6857 
    oprot.writeMessageEnd()
6858 
    oprot.trans.flush()
4008 mandeep.dh 6859 
 
4295 varun.gupt 6860 
  def process_getOrdersForItemIds(self, seqid, iprot, oprot):
6861 
    args = getOrdersForItemIds_args()
6862 
    args.read(iprot)
6863 
    iprot.readMessageEnd()
6864 
    result = getOrdersForItemIds_result()
6865 
    result.success = self._handler.getOrdersForItemIds(args.itemIds)
6866 
    oprot.writeMessageBegin("getOrdersForItemIds", TMessageType.REPLY, seqid)
6867 
    result.write(oprot)
6868 
    oprot.writeMessageEnd()
6869 
    oprot.trans.flush()
6870 
 
4247 rajveer 6871 
  def process_markOrderCancellationRequestReceived(self, seqid, iprot, oprot):
6872 
    args = markOrderCancellationRequestReceived_args()
6873 
    args.read(iprot)
6874 
    iprot.readMessageEnd()
6875 
    result = markOrderCancellationRequestReceived_result()
6876 
    try:
6877 
      self._handler.markOrderCancellationRequestReceived(args.orderId)
6878 
    except TransactionServiceException, ex:
6879 
      result.ex = ex
6880 
    oprot.writeMessageBegin("markOrderCancellationRequestReceived", TMessageType.REPLY, seqid)
6881 
    result.write(oprot)
6882 
    oprot.writeMessageEnd()
6883 
    oprot.trans.flush()
4018 chandransh 6884 
 
4247 rajveer 6885 
  def process_markOrderCancellationRequestConfirmed(self, seqid, iprot, oprot):
6886 
    args = markOrderCancellationRequestConfirmed_args()
6887 
    args.read(iprot)
6888 
    iprot.readMessageEnd()
6889 
    result = markOrderCancellationRequestConfirmed_result()
6890 
    try:
6891 
      self._handler.markOrderCancellationRequestConfirmed(args.orderId)
6892 
    except TransactionServiceException, ex:
6893 
      result.ex = ex
6894 
    oprot.writeMessageBegin("markOrderCancellationRequestConfirmed", TMessageType.REPLY, seqid)
6895 
    result.write(oprot)
6896 
    oprot.writeMessageEnd()
6897 
    oprot.trans.flush()
6898 
 
6899 
  def process_markOrderCancellationRequestDenied(self, seqid, iprot, oprot):
6900 
    args = markOrderCancellationRequestDenied_args()
6901 
    args.read(iprot)
6902 
    iprot.readMessageEnd()
6903 
    result = markOrderCancellationRequestDenied_result()
6904 
    try:
6905 
      self._handler.markOrderCancellationRequestDenied(args.orderId)
6906 
    except TransactionServiceException, ex:
6907 
      result.ex = ex
6908 
    oprot.writeMessageBegin("markOrderCancellationRequestDenied", TMessageType.REPLY, seqid)
6909 
    result.write(oprot)
6910 
    oprot.writeMessageEnd()
6911 
    oprot.trans.flush()
6912 
 
4258 rajveer 6913 
  def process_markTransactionAsPaymentFlagRemoved(self, seqid, iprot, oprot):
6914 
    args = markTransactionAsPaymentFlagRemoved_args()
4247 rajveer 6915 
    args.read(iprot)
6916 
    iprot.readMessageEnd()
4258 rajveer 6917 
    result = markTransactionAsPaymentFlagRemoved_result()
4247 rajveer 6918 
    try:
4258 rajveer 6919 
      self._handler.markTransactionAsPaymentFlagRemoved(args.transactionId)
4247 rajveer 6920 
    except TransactionServiceException, ex:
6921 
      result.ex = ex
4258 rajveer 6922 
    oprot.writeMessageBegin("markTransactionAsPaymentFlagRemoved", TMessageType.REPLY, seqid)
4247 rajveer 6923 
    result.write(oprot)
6924 
    oprot.writeMessageEnd()
6925 
    oprot.trans.flush()
6926 
 
4259 anupam.sin 6927 
  def process_refundTransaction(self, seqid, iprot, oprot):
6928 
    args = refundTransaction_args()
6929 
    args.read(iprot)
6930 
    iprot.readMessageEnd()
6931 
    result = refundTransaction_result()
6932 
    try:
6933 
      self._handler.refundTransaction(args.transactionId, args.refundedBy, args.reason)
6934 
    except TransactionServiceException, ex:
6935 
      result.ex = ex
6936 
    oprot.writeMessageBegin("refundTransaction", TMessageType.REPLY, seqid)
6937 
    result.write(oprot)
6938 
    oprot.writeMessageEnd()
6939 
    oprot.trans.flush()
4247 rajveer 6940 
 
4324 mandeep.dh 6941 
  def process_updateShipmentAddress(self, seqid, iprot, oprot):
6942 
    args = updateShipmentAddress_args()
6943 
    args.read(iprot)
6944 
    iprot.readMessageEnd()
6945 
    result = updateShipmentAddress_result()
6946 
    try:
6947 
      self._handler.updateShipmentAddress(args.orderId, args.addressId)
6948 
    except TransactionServiceException, ex:
6949 
      result.ex = ex
6950 
    oprot.writeMessageBegin("updateShipmentAddress", TMessageType.REPLY, seqid)
6951 
    result.write(oprot)
6952 
    oprot.writeMessageEnd()
6953 
    oprot.trans.flush()
6954 
 
4285 rajveer 6955 
  def process_acceptOrdersForItemId(self, seqid, iprot, oprot):
6956 
    args = acceptOrdersForItemId_args()
6957 
    args.read(iprot)
6958 
    iprot.readMessageEnd()
6959 
    result = acceptOrdersForItemId_result()
6960 
    try:
6961 
      result.success = self._handler.acceptOrdersForItemId(args.itemId, args.inventory)
6962 
    except TransactionServiceException, ex:
6963 
      result.ex = ex
6964 
    oprot.writeMessageBegin("acceptOrdersForItemId", TMessageType.REPLY, seqid)
6965 
    result.write(oprot)
6966 
    oprot.writeMessageEnd()
6967 
    oprot.trans.flush()
4259 anupam.sin 6968 
 
4303 rajveer 6969 
  def process_markOrdersAsPORaised(self, seqid, iprot, oprot):
6970 
    args = markOrdersAsPORaised_args()
6971 
    args.read(iprot)
6972 
    iprot.readMessageEnd()
6973 
    result = markOrdersAsPORaised_result()
6974 
    try:
4369 rajveer 6975 
      self._handler.markOrdersAsPORaised(args.vendorId, args.itemId, args.quantity, args.estimate, args.isReminder)
4303 rajveer 6976 
    except TransactionServiceException, ex:
6977 
      result.ex = ex
6978 
    oprot.writeMessageBegin("markOrdersAsPORaised", TMessageType.REPLY, seqid)
6979 
    result.write(oprot)
6980 
    oprot.writeMessageEnd()
6981 
    oprot.trans.flush()
4285 rajveer 6982 
 
4303 rajveer 6983 
  def process_markOrdersAsReversalInitiated(self, seqid, iprot, oprot):
6984 
    args = markOrdersAsReversalInitiated_args()
6985 
    args.read(iprot)
6986 
    iprot.readMessageEnd()
6987 
    result = markOrdersAsReversalInitiated_result()
6988 
    try:
4369 rajveer 6989 
      self._handler.markOrdersAsReversalInitiated(args.vendorId, args.itemId, args.quantity, args.estimate, args.isReminder)
4303 rajveer 6990 
    except TransactionServiceException, ex:
6991 
      result.ex = ex
6992 
    oprot.writeMessageBegin("markOrdersAsReversalInitiated", TMessageType.REPLY, seqid)
6993 
    result.write(oprot)
6994 
    oprot.writeMessageEnd()
6995 
    oprot.trans.flush()
6996 
 
6997 
  def process_markOrdersAsNotAvailabke(self, seqid, iprot, oprot):
6998 
    args = markOrdersAsNotAvailabke_args()
6999 
    args.read(iprot)
7000 
    iprot.readMessageEnd()
7001 
    result = markOrdersAsNotAvailabke_result()
7002 
    try:
4369 rajveer 7003 
      self._handler.markOrdersAsNotAvailabke(args.vendorId, args.itemId, args.quantity, args.estimate, args.isReminder)
4303 rajveer 7004 
    except TransactionServiceException, ex:
7005 
      result.ex = ex
7006 
    oprot.writeMessageBegin("markOrdersAsNotAvailabke", TMessageType.REPLY, seqid)
7007 
    result.write(oprot)
7008 
    oprot.writeMessageEnd()
7009 
    oprot.trans.flush()
7010 
 
4369 rajveer 7011 
  def process_markOrdersAsTimeout(self, seqid, iprot, oprot):
7012 
    args = markOrdersAsTimeout_args()
7013 
    args.read(iprot)
7014 
    iprot.readMessageEnd()
7015 
    result = markOrdersAsTimeout_result()
7016 
    try:
7017 
      result.success = self._handler.markOrdersAsTimeout(args.vendorId)
7018 
    except TransactionServiceException, ex:
7019 
      result.ex = ex
7020 
    oprot.writeMessageBegin("markOrdersAsTimeout", TMessageType.REPLY, seqid)
7021 
    result.write(oprot)
7022 
    oprot.writeMessageEnd()
7023 
    oprot.trans.flush()
4303 rajveer 7024 
 
4662 rajveer 7025 
  def process_markOrderAsLostInTransit(self, seqid, iprot, oprot):
7026 
    args = markOrderAsLostInTransit_args()
7027 
    args.read(iprot)
7028 
    iprot.readMessageEnd()
7029 
    result = markOrderAsLostInTransit_result()
7030 
    try:
7031 
      result.success = self._handler.markOrderAsLostInTransit(args.orderId)
7032 
    except TransactionServiceException, ex:
7033 
      result.ex = ex
7034 
    oprot.writeMessageBegin("markOrderAsLostInTransit", TMessageType.REPLY, seqid)
7035 
    result.write(oprot)
7036 
    oprot.writeMessageEnd()
7037 
    oprot.trans.flush()
7038 
 
4386 anupam.sin 7039 
  def process_getOrderForAwb(self, seqid, iprot, oprot):
7040 
    args = getOrderForAwb_args()
7041 
    args.read(iprot)
7042 
    iprot.readMessageEnd()
7043 
    result = getOrderForAwb_result()
7044 
    try:
7045 
      result.success = self._handler.getOrderForAwb(args.awb)
7046 
    except TransactionServiceException, ex:
7047 
      result.ex = ex
7048 
    oprot.writeMessageBegin("getOrderForAwb", TMessageType.REPLY, seqid)
7049 
    result.write(oprot)
7050 
    oprot.writeMessageEnd()
7051 
    oprot.trans.flush()
4369 rajveer 7052 
 
4506 phani.kuma 7053 
  def process_getOrdersForProviderForStatus(self, seqid, iprot, oprot):
7054 
    args = getOrdersForProviderForStatus_args()
7055 
    args.read(iprot)
7056 
    iprot.readMessageEnd()
7057 
    result = getOrdersForProviderForStatus_result()
7058 
    try:
4910 phani.kuma 7059 
      result.success = self._handler.getOrdersForProviderForStatus(args.logistics_provider_id, args.order_status_list)
4506 phani.kuma 7060 
    except TransactionServiceException, ex:
7061 
      result.ex = ex
7062 
    oprot.writeMessageBegin("getOrdersForProviderForStatus", TMessageType.REPLY, seqid)
7063 
    result.write(oprot)
7064 
    oprot.writeMessageEnd()
7065 
    oprot.trans.flush()
4386 anupam.sin 7066 
 
4600 varun.gupt 7067 
  def process_getBilledOrdersForVendor(self, seqid, iprot, oprot):
7068 
    args = getBilledOrdersForVendor_args()
7069 
    args.read(iprot)
7070 
    iprot.readMessageEnd()
7071 
    result = getBilledOrdersForVendor_result()
7072 
    try:
7073 
      result.success = self._handler.getBilledOrdersForVendor(args.vendorId, args.billingDateFrom, args.billingDateTo)
7074 
    except TransactionServiceException, ex:
7075 
      result.ex = ex
7076 
    oprot.writeMessageBegin("getBilledOrdersForVendor", TMessageType.REPLY, seqid)
7077 
    result.write(oprot)
7078 
    oprot.writeMessageEnd()
7079 
    oprot.trans.flush()
4506 phani.kuma 7080 
 
4607 rajveer 7081 
  def process_getSlippedSippingDateOrders(self, seqid, iprot, oprot):
7082 
    args = getSlippedSippingDateOrders_args()
7083 
    args.read(iprot)
7084 
    iprot.readMessageEnd()
7085 
    result = getSlippedSippingDateOrders_result()
7086 
    try:
7087 
      result.success = self._handler.getSlippedSippingDateOrders()
7088 
    except TransactionServiceException, ex:
7089 
      result.ex = ex
7090 
    oprot.writeMessageBegin("getSlippedSippingDateOrders", TMessageType.REPLY, seqid)
7091 
    result.write(oprot)
7092 
    oprot.writeMessageEnd()
7093 
    oprot.trans.flush()
7094 
 
4709 rajveer 7095 
  def process_getCancelledOrders(self, seqid, iprot, oprot):
7096 
    args = getCancelledOrders_args()
7097 
    args.read(iprot)
7098 
    iprot.readMessageEnd()
7099 
    result = getCancelledOrders_result()
7100 
    try:
7101 
      result.success = self._handler.getCancelledOrders(args.cancelDateFrom, args.cancelDateTo)
7102 
    except TransactionServiceException, ex:
7103 
      result.ex = ex
7104 
    oprot.writeMessageBegin("getCancelledOrders", TMessageType.REPLY, seqid)
7105 
    result.write(oprot)
7106 
    oprot.writeMessageEnd()
7107 
    oprot.trans.flush()
7108 
 
4600 varun.gupt 7109 
  def process_saveBluedartSettlements(self, seqid, iprot, oprot):
7110 
    args = saveBluedartSettlements_args()
7111 
    args.read(iprot)
7112 
    iprot.readMessageEnd()
7113 
    result = saveBluedartSettlements_result()
7114 
    try:
7115 
      self._handler.saveBluedartSettlements(args.mapAWBAndAmount)
7116 
    except TransactionServiceException, ex:
7117 
      result.ex = ex
7118 
    oprot.writeMessageBegin("saveBluedartSettlements", TMessageType.REPLY, seqid)
7119 
    result.write(oprot)
7120 
    oprot.writeMessageEnd()
7121 
    oprot.trans.flush()
7122 
 
7123 
  def process_savePaymentSettlements(self, seqid, iprot, oprot):
7124 
    args = savePaymentSettlements_args()
7125 
    args.read(iprot)
7126 
    iprot.readMessageEnd()
7127 
    result = savePaymentSettlements_result()
7128 
    try:
4905 varun.gupt 7129 
      self._handler.savePaymentSettlements(args.settlementDate, args.paymentGatewayId, args.referenceId, args.serviceTax, args.otherCharges, args.netCollection)
4600 varun.gupt 7130 
    except TransactionServiceException, ex:
7131 
      result.ex = ex
7132 
    oprot.writeMessageBegin("savePaymentSettlements", TMessageType.REPLY, seqid)
7133 
    result.write(oprot)
7134 
    oprot.writeMessageEnd()
7135 
    oprot.trans.flush()
7136 
 
7137 
  def process_saveEBSSettlementSummary(self, seqid, iprot, oprot):
7138 
    args = saveEBSSettlementSummary_args()
7139 
    args.read(iprot)
7140 
    iprot.readMessageEnd()
7141 
    result = saveEBSSettlementSummary_result()
7142 
    try:
7143 
      self._handler.saveEBSSettlementSummary(args.settlementId, args.settlementDate, args.transactionDateFrom, args.transactionDateTo, args.amount)
7144 
    except TransactionServiceException, ex:
7145 
      result.ex = ex
7146 
    oprot.writeMessageBegin("saveEBSSettlementSummary", TMessageType.REPLY, seqid)
7147 
    result.write(oprot)
7148 
    oprot.writeMessageEnd()
7149 
    oprot.trans.flush()
7150 
 
5386 phani.kuma 7151 
  def process_getSettlementForPrepaid(self, seqid, iprot, oprot):
7152 
    args = getSettlementForPrepaid_args()
4600 varun.gupt 7153 
    args.read(iprot)
7154 
    iprot.readMessageEnd()
5386 phani.kuma 7155 
    result = getSettlementForPrepaid_result()
4600 varun.gupt 7156 
    try:
5386 phani.kuma 7157 
      result.success = self._handler.getSettlementForPrepaid(args.referenceId, args.isRefund)
4600 varun.gupt 7158 
    except TransactionServiceException, ex:
7159 
      result.ex = ex
5386 phani.kuma 7160 
    oprot.writeMessageBegin("getSettlementForPrepaid", TMessageType.REPLY, seqid)
4600 varun.gupt 7161 
    result.write(oprot)
7162 
    oprot.writeMessageEnd()
7163 
    oprot.trans.flush()
7164 
 
5386 phani.kuma 7165 
  def process_getSettlementForCod(self, seqid, iprot, oprot):
7166 
    args = getSettlementForCod_args()
7167 
    args.read(iprot)
7168 
    iprot.readMessageEnd()
7169 
    result = getSettlementForCod_result()
7170 
    try:
7171 
      result.success = self._handler.getSettlementForCod(args.orderId, args.isRefund)
7172 
    except TransactionServiceException, ex:
7173 
      result.ex = ex
7174 
    oprot.writeMessageBegin("getSettlementForCod", TMessageType.REPLY, seqid)
7175 
    result.write(oprot)
7176 
    oprot.writeMessageEnd()
7177 
    oprot.trans.flush()
7178 
 
4600 varun.gupt 7179 
  def process_getEBSSettlementSummaries(self, seqid, iprot, oprot):
7180 
    args = getEBSSettlementSummaries_args()
7181 
    args.read(iprot)
7182 
    iprot.readMessageEnd()
7183 
    result = getEBSSettlementSummaries_result()
7184 
    try:
7185 
      result.success = self._handler.getEBSSettlementSummaries()
7186 
    except TransactionServiceException, ex:
7187 
      result.ex = ex
7188 
    oprot.writeMessageBegin("getEBSSettlementSummaries", TMessageType.REPLY, seqid)
7189 
    result.write(oprot)
7190 
    oprot.writeMessageEnd()
7191 
    oprot.trans.flush()
7192 
 
7193 
  def process_markEBSSettlementUploaded(self, seqid, iprot, oprot):
7194 
    args = markEBSSettlementUploaded_args()
7195 
    args.read(iprot)
7196 
    iprot.readMessageEnd()
7197 
    result = markEBSSettlementUploaded_result()
7198 
    try:
7199 
      self._handler.markEBSSettlementUploaded(args.settlementId)
7200 
    except TransactionServiceException, ex:
7201 
      result.ex = ex
7202 
    oprot.writeMessageBegin("markEBSSettlementUploaded", TMessageType.REPLY, seqid)
7203 
    result.write(oprot)
7204 
    oprot.writeMessageEnd()
7205 
    oprot.trans.flush()
7206 
 
7207 
  def process_getEBSSettlementDate(self, seqid, iprot, oprot):
7208 
    args = getEBSSettlementDate_args()
7209 
    args.read(iprot)
7210 
    iprot.readMessageEnd()
7211 
    result = getEBSSettlementDate_result()
7212 
    try:
7213 
      result.success = self._handler.getEBSSettlementDate(args.settlementId)
7214 
    except TransactionServiceException, ex:
7215 
      result.ex = ex
7216 
    oprot.writeMessageBegin("getEBSSettlementDate", TMessageType.REPLY, seqid)
7217 
    result.write(oprot)
7218 
    oprot.writeMessageEnd()
7219 
    oprot.trans.flush()
7220 
 
4715 varun.gupt 7221 
  def process_getSettlementsByDate(self, seqid, iprot, oprot):
7222 
    args = getSettlementsByDate_args()
7223 
    args.read(iprot)
7224 
    iprot.readMessageEnd()
7225 
    result = getSettlementsByDate_result()
7226 
    try:
7227 
      result.success = self._handler.getSettlementsByDate(args.settlementDateFrom, args.settlementDateTo, args.isRefund)
7228 
    except TransactionServiceException, ex:
7229 
      result.ex = ex
7230 
    oprot.writeMessageBegin("getSettlementsByDate", TMessageType.REPLY, seqid)
7231 
    result.write(oprot)
7232 
    oprot.writeMessageEnd()
7233 
    oprot.trans.flush()
4600 varun.gupt 7234 
 
4715 varun.gupt 7235 
  def process_getReshippedOrderIds(self, seqid, iprot, oprot):
7236 
    args = getReshippedOrderIds_args()
7237 
    args.read(iprot)
7238 
    iprot.readMessageEnd()
7239 
    result = getReshippedOrderIds_result()
7240 
    try:
7241 
      result.success = self._handler.getReshippedOrderIds(args.orderIds)
7242 
    except TransactionServiceException, ex:
7243 
      result.ex = ex
7244 
    oprot.writeMessageBegin("getReshippedOrderIds", TMessageType.REPLY, seqid)
7245 
    result.write(oprot)
7246 
    oprot.writeMessageEnd()
7247 
    oprot.trans.flush()
7248 
 
5481 phani.kuma 7249 
  def process_getBilledOrders(self, seqid, iprot, oprot):
7250 
    args = getBilledOrders_args()
4875 varun.gupt 7251 
    args.read(iprot)
7252 
    iprot.readMessageEnd()
5481 phani.kuma 7253 
    result = getBilledOrders_result()
4875 varun.gupt 7254 
    try:
5481 phani.kuma 7255 
      result.success = self._handler.getBilledOrders(args.vendorId, args.onlyVendorNotPaid, args.billingDateFrom, args.billingDateTo)
4875 varun.gupt 7256 
    except TransactionServiceException, ex:
7257 
      result.ex = ex
5481 phani.kuma 7258 
    oprot.writeMessageBegin("getBilledOrders", TMessageType.REPLY, seqid)
4875 varun.gupt 7259 
    result.write(oprot)
7260 
    oprot.writeMessageEnd()
7261 
    oprot.trans.flush()
4757 mandeep.dh 7262 
 
5031 varun.gupt 7263 
  def process_getStatusDistributionOfOrders(self, seqid, iprot, oprot):
7264 
    args = getStatusDistributionOfOrders_args()
7265 
    args.read(iprot)
7266 
    iprot.readMessageEnd()
7267 
    result = getStatusDistributionOfOrders_result()
7268 
    try:
7269 
      result.success = self._handler.getStatusDistributionOfOrders(args.startDate, args.endDate)
7270 
    except TransactionServiceException, ex:
7271 
      result.ex = ex
7272 
    oprot.writeMessageBegin("getStatusDistributionOfOrders", TMessageType.REPLY, seqid)
7273 
    result.write(oprot)
7274 
    oprot.writeMessageEnd()
7275 
    oprot.trans.flush()
4875 varun.gupt 7276 
 
5067 varun.gupt 7277 
  def process_getOrderIdsForStatus(self, seqid, iprot, oprot):
7278 
    args = getOrderIdsForStatus_args()
7279 
    args.read(iprot)
7280 
    iprot.readMessageEnd()
7281 
    result = getOrderIdsForStatus_result()
7282 
    try:
7283 
      result.success = self._handler.getOrderIdsForStatus(args.status, args.startDatetime, args.endDatetime)
7284 
    except TransactionServiceException, ex:
7285 
      result.ex = ex
7286 
    oprot.writeMessageBegin("getOrderIdsForStatus", TMessageType.REPLY, seqid)
7287 
    result.write(oprot)
7288 
    oprot.writeMessageEnd()
7289 
    oprot.trans.flush()
5031 varun.gupt 7290 
 
5348 anupam.sin 7291 
  def process_updateCODAgent(self, seqid, iprot, oprot):
7292 
    args = updateCODAgent_args()
7293 
    args.read(iprot)
7294 
    iprot.readMessageEnd()
7295 
    result = updateCODAgent_result()
7296 
    try:
7297 
      self._handler.updateCODAgent(args.agent, args.orderId)
7298 
    except TransactionServiceException, ex:
7299 
      result.ex = ex
7300 
    oprot.writeMessageBegin("updateCODAgent", TMessageType.REPLY, seqid)
7301 
    result.write(oprot)
7302 
    oprot.writeMessageEnd()
7303 
    oprot.trans.flush()
7304 
 
5099 varun.gupt 7305 
  def process_updateOrderAsPaidToVendor(self, seqid, iprot, oprot):
7306 
    args = updateOrderAsPaidToVendor_args()
7307 
    args.read(iprot)
7308 
    iprot.readMessageEnd()
7309 
    result = updateOrderAsPaidToVendor_result()
7310 
    try:
7311 
      self._handler.updateOrderAsPaidToVendor(args.orderId)
7312 
    except TransactionServiceException, ex:
7313 
      result.ex = ex
7314 
    oprot.writeMessageBegin("updateOrderAsPaidToVendor", TMessageType.REPLY, seqid)
7315 
    result.write(oprot)
7316 
    oprot.writeMessageEnd()
7317 
    oprot.trans.flush()
5067 varun.gupt 7318 
 
5386 phani.kuma 7319 
  def process_updateOrderOnlyAsPaidToVendor(self, seqid, iprot, oprot):
7320 
    args = updateOrderOnlyAsPaidToVendor_args()
7321 
    args.read(iprot)
7322 
    iprot.readMessageEnd()
7323 
    result = updateOrderOnlyAsPaidToVendor_result()
7324 
    try:
7325 
      self._handler.updateOrderOnlyAsPaidToVendor(args.orderId)
7326 
    except TransactionServiceException, ex:
7327 
      result.ex = ex
7328 
    oprot.writeMessageBegin("updateOrderOnlyAsPaidToVendor", TMessageType.REPLY, seqid)
7329 
    result.write(oprot)
7330 
    oprot.writeMessageEnd()
7331 
    oprot.trans.flush()
7332 
 
5208 varun.gupt 7333 
  def process_getRefundedOrdersMarkedPaid(self, seqid, iprot, oprot):
7334 
    args = getRefundedOrdersMarkedPaid_args()
7335 
    args.read(iprot)
7336 
    iprot.readMessageEnd()
7337 
    result = getRefundedOrdersMarkedPaid_result()
7338 
    try:
7339 
      result.success = self._handler.getRefundedOrdersMarkedPaid()
7340 
    except TransactionServiceException, ex:
7341 
      result.ex = ex
7342 
    oprot.writeMessageBegin("getRefundedOrdersMarkedPaid", TMessageType.REPLY, seqid)
7343 
    result.write(oprot)
7344 
    oprot.writeMessageEnd()
7345 
    oprot.trans.flush()
5099 varun.gupt 7346 
 
5447 anupam.sin 7347 
  def process_getAllVerificationAgents(self, seqid, iprot, oprot):
7348 
    args = getAllVerificationAgents_args()
7349 
    args.read(iprot)
7350 
    iprot.readMessageEnd()
7351 
    result = getAllVerificationAgents_result()
7352 
    result.success = self._handler.getAllVerificationAgents(args.minOrderId, args.maxOrderId)
7353 
    oprot.writeMessageBegin("getAllVerificationAgents", TMessageType.REPLY, seqid)
7354 
    result.write(oprot)
7355 
    oprot.writeMessageEnd()
7356 
    oprot.trans.flush()
5208 varun.gupt 7357 
 
5527 anupam.sin 7358 
  def process_getAllAttributesForOrderId(self, seqid, iprot, oprot):
7359 
    args = getAllAttributesForOrderId_args()
7360 
    args.read(iprot)
7361 
    iprot.readMessageEnd()
7362 
    result = getAllAttributesForOrderId_result()
7363 
    result.success = self._handler.getAllAttributesForOrderId(args.orderId)
7364 
    oprot.writeMessageBegin("getAllAttributesForOrderId", TMessageType.REPLY, seqid)
7365 
    result.write(oprot)
7366 
    oprot.writeMessageEnd()
7367 
    oprot.trans.flush()
5447 anupam.sin 7368 
 
5676 rajveer 7369 
  def process_setOrderAttributes(self, seqid, iprot, oprot):
7370 
    args = setOrderAttributes_args()
7371 
    args.read(iprot)
7372 
    iprot.readMessageEnd()
7373 
    result = setOrderAttributes_result()
7374 
    self._handler.setOrderAttributes(args.orderId, args.attributes)
7375 
    oprot.writeMessageBegin("setOrderAttributes", TMessageType.REPLY, seqid)
7376 
    result.write(oprot)
7377 
    oprot.writeMessageEnd()
7378 
    oprot.trans.flush()
7379 
 
5527 anupam.sin 7380 
  def process_setOrderAttributeForTransaction(self, seqid, iprot, oprot):
7381 
    args = setOrderAttributeForTransaction_args()
7382 
    args.read(iprot)
7383 
    iprot.readMessageEnd()
7384 
    result = setOrderAttributeForTransaction_result()
7385 
    self._handler.setOrderAttributeForTransaction(args.transactionId, args.attribute)
7386 
    oprot.writeMessageBegin("setOrderAttributeForTransaction", TMessageType.REPLY, seqid)
7387 
    result.write(oprot)
7388 
    oprot.writeMessageEnd()
7389 
    oprot.trans.flush()
7390 
 
5553 rajveer 7391 
  def process_getReceivePendingOrders(self, seqid, iprot, oprot):
7392 
    args = getReceivePendingOrders_args()
7393 
    args.read(iprot)
7394 
    iprot.readMessageEnd()
7395 
    result = getReceivePendingOrders_result()
7396 
    result.success = self._handler.getReceivePendingOrders(args.storeId)
7397 
    oprot.writeMessageBegin("getReceivePendingOrders", TMessageType.REPLY, seqid)
7398 
    result.write(oprot)
7399 
    oprot.writeMessageEnd()
7400 
    oprot.trans.flush()
5527 anupam.sin 7401 
 
5553 rajveer 7402 
  def process_getReceivedAtStoreOrders(self, seqid, iprot, oprot):
7403 
    args = getReceivedAtStoreOrders_args()
7404 
    args.read(iprot)
7405 
    iprot.readMessageEnd()
7406 
    result = getReceivedAtStoreOrders_result()
7407 
    result.success = self._handler.getReceivedAtStoreOrders(args.storeId)
7408 
    oprot.writeMessageBegin("getReceivedAtStoreOrders", TMessageType.REPLY, seqid)
7409 
    result.write(oprot)
7410 
    oprot.writeMessageEnd()
7411 
    oprot.trans.flush()
7412 
 
5713 rajveer 7413 
  def process_getOrdersCollectionAtStore(self, seqid, iprot, oprot):
7414 
    args = getOrdersCollectionAtStore_args()
7415 
    args.read(iprot)
7416 
    iprot.readMessageEnd()
7417 
    result = getOrdersCollectionAtStore_result()
7418 
    result.success = self._handler.getOrdersCollectionAtStore(args.storeId, args.fromDate, args.toDate, args.onlyCod)
7419 
    oprot.writeMessageBegin("getOrdersCollectionAtStore", TMessageType.REPLY, seqid)
7420 
    result.write(oprot)
7421 
    oprot.writeMessageEnd()
7422 
    oprot.trans.flush()
7423 
 
5833 rajveer 7424 
  def process_getOrderAttributeValue(self, seqid, iprot, oprot):
7425 
    args = getOrderAttributeValue_args()
7426 
    args.read(iprot)
7427 
    iprot.readMessageEnd()
7428 
    result = getOrderAttributeValue_result()
7429 
    result.success = self._handler.getOrderAttributeValue(args.orderId, args.attributeName)
7430 
    oprot.writeMessageBegin("getOrderAttributeValue", TMessageType.REPLY, seqid)
7431 
    result.write(oprot)
7432 
    oprot.writeMessageEnd()
7433 
    oprot.trans.flush()
7434 
 
5593 mandeep.dh 7435 
  def process_acceptOrderForItem(self, seqid, iprot, oprot):
7436 
    args = acceptOrderForItem_args()
7437 
    args.read(iprot)
7438 
    iprot.readMessageEnd()
7439 
    result = acceptOrderForItem_result()
7440 
    self._handler.acceptOrderForItem(args.itemId, args.quantity, args.fulfilmentWarehouseId, args.billingWarehouseId)
7441 
    oprot.writeMessageBegin("acceptOrderForItem", TMessageType.REPLY, seqid)
7442 
    result.write(oprot)
7443 
    oprot.writeMessageEnd()
7444 
    oprot.trans.flush()
5553 rajveer 7445 
 
5593 mandeep.dh 7446 
 
94 ashish 7447 
# HELPER FUNCTIONS AND STRUCTURES
7448 
 
7449 
class createTransaction_args:
7450 
  """
7451 
  Attributes:
7452 
   - transaction
7453 
  """
7454 
 
7455 
  thrift_spec = (
7456 
    None, # 0
7457 
    (1, TType.STRUCT, 'transaction', (Transaction, Transaction.thrift_spec), None, ), # 1
7458 
  )
7459 
 
7460 
  def __init__(self, transaction=None,):
7461 
    self.transaction = transaction
7462 
 
7463 
  def read(self, iprot):
7464 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
7465 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
7466 
      return
7467 
    iprot.readStructBegin()
7468 
    while True:
7469 
      (fname, ftype, fid) = iprot.readFieldBegin()
7470 
      if ftype == TType.STOP:
7471 
        break
7472 
      if fid == 1:
7473 
        if ftype == TType.STRUCT:
7474 
          self.transaction = Transaction()
7475 
          self.transaction.read(iprot)
7476 
        else:
7477 
          iprot.skip(ftype)
7478 
      else:
7479 
        iprot.skip(ftype)
7480 
      iprot.readFieldEnd()
7481 
    iprot.readStructEnd()
7482 
 
7483 
  def write(self, oprot):
7484 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
7485 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
7486 
      return
7487 
    oprot.writeStructBegin('createTransaction_args')
3431 rajveer 7488 
    if self.transaction is not None:
94 ashish 7489 
      oprot.writeFieldBegin('transaction', TType.STRUCT, 1)
7490 
      self.transaction.write(oprot)
7491 
      oprot.writeFieldEnd()
7492 
    oprot.writeFieldStop()
7493 
    oprot.writeStructEnd()
7494 
 
3431 rajveer 7495 
  def validate(self):
7496 
    return
7497 
 
7498 
 
94 ashish 7499 
  def __repr__(self):
7500 
    L = ['%s=%r' % (key, value)
7501 
      for key, value in self.__dict__.iteritems()]
7502 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
7503 
 
7504 
  def __eq__(self, other):
7505 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
7506 
 
7507 
  def __ne__(self, other):
7508 
    return not (self == other)
7509 
 
7510 
class createTransaction_result:
7511 
  """
7512 
  Attributes:
132 ashish 7513 
   - success
94 ashish 7514 
   - ex
7515 
  """
7516 
 
7517 
  thrift_spec = (
132 ashish 7518 
    (0, TType.I64, 'success', None, None, ), # 0
94 ashish 7519 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
7520 
  )
7521 
 
132 ashish 7522 
  def __init__(self, success=None, ex=None,):
7523 
    self.success = success
94 ashish 7524 
    self.ex = ex
7525 
 
7526 
  def read(self, iprot):
7527 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
7528 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
7529 
      return
7530 
    iprot.readStructBegin()
7531 
    while True:
7532 
      (fname, ftype, fid) = iprot.readFieldBegin()
7533 
      if ftype == TType.STOP:
7534 
        break
132 ashish 7535 
      if fid == 0:
7536 
        if ftype == TType.I64:
7537 
          self.success = iprot.readI64();
7538 
        else:
7539 
          iprot.skip(ftype)
7540 
      elif fid == 1:
94 ashish 7541 
        if ftype == TType.STRUCT:
7542 
          self.ex = TransactionServiceException()
7543 
          self.ex.read(iprot)
7544 
        else:
7545 
          iprot.skip(ftype)
7546 
      else:
7547 
        iprot.skip(ftype)
7548 
      iprot.readFieldEnd()
7549 
    iprot.readStructEnd()
7550 
 
7551 
  def write(self, oprot):
7552 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
7553 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
7554 
      return
7555 
    oprot.writeStructBegin('createTransaction_result')
3431 rajveer 7556 
    if self.success is not None:
132 ashish 7557 
      oprot.writeFieldBegin('success', TType.I64, 0)
7558 
      oprot.writeI64(self.success)
7559 
      oprot.writeFieldEnd()
3431 rajveer 7560 
    if self.ex is not None:
94 ashish 7561 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
7562 
      self.ex.write(oprot)
7563 
      oprot.writeFieldEnd()
7564 
    oprot.writeFieldStop()
7565 
    oprot.writeStructEnd()
7566 
 
3431 rajveer 7567 
  def validate(self):
7568 
    return
7569 
 
7570 
 
94 ashish 7571 
  def __repr__(self):
7572 
    L = ['%s=%r' % (key, value)
7573 
      for key, value in self.__dict__.iteritems()]
7574 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
7575 
 
7576 
  def __eq__(self, other):
7577 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
7578 
 
7579 
  def __ne__(self, other):
7580 
    return not (self == other)
7581 
 
7582 
class getTransaction_args:
7583 
  """
7584 
  Attributes:
7585 
   - id
7586 
  """
7587 
 
7588 
  thrift_spec = (
7589 
    None, # 0
7590 
    (1, TType.I64, 'id', None, None, ), # 1
7591 
  )
7592 
 
7593 
  def __init__(self, id=None,):
7594 
    self.id = id
7595 
 
7596 
  def read(self, iprot):
7597 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
7598 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
7599 
      return
7600 
    iprot.readStructBegin()
7601 
    while True:
7602 
      (fname, ftype, fid) = iprot.readFieldBegin()
7603 
      if ftype == TType.STOP:
7604 
        break
7605 
      if fid == 1:
7606 
        if ftype == TType.I64:
7607 
          self.id = iprot.readI64();
7608 
        else:
7609 
          iprot.skip(ftype)
7610 
      else:
7611 
        iprot.skip(ftype)
7612 
      iprot.readFieldEnd()
7613 
    iprot.readStructEnd()
7614 
 
7615 
  def write(self, oprot):
7616 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
7617 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
7618 
      return
7619 
    oprot.writeStructBegin('getTransaction_args')
3431 rajveer 7620 
    if self.id is not None:
94 ashish 7621 
      oprot.writeFieldBegin('id', TType.I64, 1)
7622 
      oprot.writeI64(self.id)
7623 
      oprot.writeFieldEnd()
7624 
    oprot.writeFieldStop()
7625 
    oprot.writeStructEnd()
7626 
 
3431 rajveer 7627 
  def validate(self):
7628 
    return
7629 
 
7630 
 
94 ashish 7631 
  def __repr__(self):
7632 
    L = ['%s=%r' % (key, value)
7633 
      for key, value in self.__dict__.iteritems()]
7634 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
7635 
 
7636 
  def __eq__(self, other):
7637 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
7638 
 
7639 
  def __ne__(self, other):
7640 
    return not (self == other)
7641 
 
7642 
class getTransaction_result:
7643 
  """
7644 
  Attributes:
7645 
   - success
7646 
   - ex
7647 
  """
7648 
 
7649 
  thrift_spec = (
7650 
    (0, TType.STRUCT, 'success', (Transaction, Transaction.thrift_spec), None, ), # 0
7651 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
7652 
  )
7653 
 
7654 
  def __init__(self, success=None, ex=None,):
7655 
    self.success = success
7656 
    self.ex = ex
7657 
 
7658 
  def read(self, iprot):
7659 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
7660 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
7661 
      return
7662 
    iprot.readStructBegin()
7663 
    while True:
7664 
      (fname, ftype, fid) = iprot.readFieldBegin()
7665 
      if ftype == TType.STOP:
7666 
        break
7667 
      if fid == 0:
7668 
        if ftype == TType.STRUCT:
7669 
          self.success = Transaction()
7670 
          self.success.read(iprot)
7671 
        else:
7672 
          iprot.skip(ftype)
7673 
      elif fid == 1:
7674 
        if ftype == TType.STRUCT:
7675 
          self.ex = TransactionServiceException()
7676 
          self.ex.read(iprot)
7677 
        else:
7678 
          iprot.skip(ftype)
7679 
      else:
7680 
        iprot.skip(ftype)
7681 
      iprot.readFieldEnd()
7682 
    iprot.readStructEnd()
7683 
 
7684 
  def write(self, oprot):
7685 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
7686 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
7687 
      return
7688 
    oprot.writeStructBegin('getTransaction_result')
3431 rajveer 7689 
    if self.success is not None:
94 ashish 7690 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
7691 
      self.success.write(oprot)
7692 
      oprot.writeFieldEnd()
3431 rajveer 7693 
    if self.ex is not None:
94 ashish 7694 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
7695 
      self.ex.write(oprot)
7696 
      oprot.writeFieldEnd()
7697 
    oprot.writeFieldStop()
7698 
    oprot.writeStructEnd()
7699 
 
3431 rajveer 7700 
  def validate(self):
7701 
    return
7702 
 
7703 
 
94 ashish 7704 
  def __repr__(self):
7705 
    L = ['%s=%r' % (key, value)
7706 
      for key, value in self.__dict__.iteritems()]
7707 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
7708 
 
7709 
  def __eq__(self, other):
7710 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
7711 
 
7712 
  def __ne__(self, other):
7713 
    return not (self == other)
7714 
 
7715 
class getTransactionsForCustomer_args:
7716 
  """
7717 
  Attributes:
7718 
   - customerId
7719 
   - from_date
7720 
   - to_date
7721 
   - status
7722 
  """
7723 
 
7724 
  thrift_spec = (
7725 
    None, # 0
7726 
    (1, TType.I64, 'customerId', None, None, ), # 1
7727 
    (2, TType.I64, 'from_date', None, None, ), # 2
7728 
    (3, TType.I64, 'to_date', None, None, ), # 3
7729 
    (4, TType.I32, 'status', None, None, ), # 4
7730 
  )
7731 
 
7732 
  def __init__(self, customerId=None, from_date=None, to_date=None, status=None,):
7733 
    self.customerId = customerId
7734 
    self.from_date = from_date
7735 
    self.to_date = to_date
7736 
    self.status = status
7737 
 
7738 
  def read(self, iprot):
7739 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
7740 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
7741 
      return
7742 
    iprot.readStructBegin()
7743 
    while True:
7744 
      (fname, ftype, fid) = iprot.readFieldBegin()
7745 
      if ftype == TType.STOP:
7746 
        break
7747 
      if fid == 1:
7748 
        if ftype == TType.I64:
7749 
          self.customerId = iprot.readI64();
7750 
        else:
7751 
          iprot.skip(ftype)
7752 
      elif fid == 2:
7753 
        if ftype == TType.I64:
7754 
          self.from_date = iprot.readI64();
7755 
        else:
7756 
          iprot.skip(ftype)
7757 
      elif fid == 3:
7758 
        if ftype == TType.I64:
7759 
          self.to_date = iprot.readI64();
7760 
        else:
7761 
          iprot.skip(ftype)
7762 
      elif fid == 4:
7763 
        if ftype == TType.I32:
7764 
          self.status = iprot.readI32();
7765 
        else:
7766 
          iprot.skip(ftype)
7767 
      else:
7768 
        iprot.skip(ftype)
7769 
      iprot.readFieldEnd()
7770 
    iprot.readStructEnd()
7771 
 
7772 
  def write(self, oprot):
7773 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
7774 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
7775 
      return
7776 
    oprot.writeStructBegin('getTransactionsForCustomer_args')
3431 rajveer 7777 
    if self.customerId is not None:
94 ashish 7778 
      oprot.writeFieldBegin('customerId', TType.I64, 1)
7779 
      oprot.writeI64(self.customerId)
7780 
      oprot.writeFieldEnd()
3431 rajveer 7781 
    if self.from_date is not None:
94 ashish 7782 
      oprot.writeFieldBegin('from_date', TType.I64, 2)
7783 
      oprot.writeI64(self.from_date)
7784 
      oprot.writeFieldEnd()
3431 rajveer 7785 
    if self.to_date is not None:
94 ashish 7786 
      oprot.writeFieldBegin('to_date', TType.I64, 3)
7787 
      oprot.writeI64(self.to_date)
7788 
      oprot.writeFieldEnd()
3431 rajveer 7789 
    if self.status is not None:
94 ashish 7790 
      oprot.writeFieldBegin('status', TType.I32, 4)
7791 
      oprot.writeI32(self.status)
7792 
      oprot.writeFieldEnd()
7793 
    oprot.writeFieldStop()
7794 
    oprot.writeStructEnd()
7795 
 
3431 rajveer 7796 
  def validate(self):
7797 
    return
7798 
 
7799 
 
94 ashish 7800 
  def __repr__(self):
7801 
    L = ['%s=%r' % (key, value)
7802 
      for key, value in self.__dict__.iteritems()]
7803 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
7804 
 
7805 
  def __eq__(self, other):
7806 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
7807 
 
7808 
  def __ne__(self, other):
7809 
    return not (self == other)
7810 
 
7811 
class getTransactionsForCustomer_result:
7812 
  """
7813 
  Attributes:
7814 
   - success
7815 
   - ex
7816 
  """
7817 
 
7818 
  thrift_spec = (
7819 
    (0, TType.LIST, 'success', (TType.STRUCT,(Transaction, Transaction.thrift_spec)), None, ), # 0
7820 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
7821 
  )
7822 
 
7823 
  def __init__(self, success=None, ex=None,):
7824 
    self.success = success
7825 
    self.ex = ex
7826 
 
7827 
  def read(self, iprot):
7828 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
7829 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
7830 
      return
7831 
    iprot.readStructBegin()
7832 
    while True:
7833 
      (fname, ftype, fid) = iprot.readFieldBegin()
7834 
      if ftype == TType.STOP:
7835 
        break
7836 
      if fid == 0:
7837 
        if ftype == TType.LIST:
7838 
          self.success = []
5031 varun.gupt 7839 
          (_etype66, _size63) = iprot.readListBegin()
7840 
          for _i67 in xrange(_size63):
7841 
            _elem68 = Transaction()
7842 
            _elem68.read(iprot)
7843 
            self.success.append(_elem68)
94 ashish 7844 
          iprot.readListEnd()
7845 
        else:
7846 
          iprot.skip(ftype)
7847 
      elif fid == 1:
7848 
        if ftype == TType.STRUCT:
7849 
          self.ex = TransactionServiceException()
7850 
          self.ex.read(iprot)
7851 
        else:
7852 
          iprot.skip(ftype)
7853 
      else:
7854 
        iprot.skip(ftype)
7855 
      iprot.readFieldEnd()
7856 
    iprot.readStructEnd()
7857 
 
7858 
  def write(self, oprot):
7859 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
7860 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
7861 
      return
7862 
    oprot.writeStructBegin('getTransactionsForCustomer_result')
3431 rajveer 7863 
    if self.success is not None:
94 ashish 7864 
      oprot.writeFieldBegin('success', TType.LIST, 0)
7865 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
5031 varun.gupt 7866 
      for iter69 in self.success:
7867 
        iter69.write(oprot)
94 ashish 7868 
      oprot.writeListEnd()
7869 
      oprot.writeFieldEnd()
3431 rajveer 7870 
    if self.ex is not None:
94 ashish 7871 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
7872 
      self.ex.write(oprot)
7873 
      oprot.writeFieldEnd()
7874 
    oprot.writeFieldStop()
7875 
    oprot.writeStructEnd()
7876 
 
3431 rajveer 7877 
  def validate(self):
7878 
    return
7879 
 
7880 
 
94 ashish 7881 
  def __repr__(self):
7882 
    L = ['%s=%r' % (key, value)
7883 
      for key, value in self.__dict__.iteritems()]
7884 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
7885 
 
7886 
  def __eq__(self, other):
7887 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
7888 
 
7889 
  def __ne__(self, other):
7890 
    return not (self == other)
7891 
 
132 ashish 7892 
class getTransactionsForShoppingCartId_args:
7893 
  """
7894 
  Attributes:
7895 
   - shoppingCartId
7896 
  """
7897 
 
7898 
  thrift_spec = (
7899 
    None, # 0
7900 
    (1, TType.I64, 'shoppingCartId', None, None, ), # 1
7901 
  )
7902 
 
7903 
  def __init__(self, shoppingCartId=None,):
7904 
    self.shoppingCartId = shoppingCartId
7905 
 
7906 
  def read(self, iprot):
7907 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
7908 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
7909 
      return
7910 
    iprot.readStructBegin()
7911 
    while True:
7912 
      (fname, ftype, fid) = iprot.readFieldBegin()
7913 
      if ftype == TType.STOP:
7914 
        break
7915 
      if fid == 1:
7916 
        if ftype == TType.I64:
7917 
          self.shoppingCartId = iprot.readI64();
7918 
        else:
7919 
          iprot.skip(ftype)
7920 
      else:
7921 
        iprot.skip(ftype)
7922 
      iprot.readFieldEnd()
7923 
    iprot.readStructEnd()
7924 
 
7925 
  def write(self, oprot):
7926 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
7927 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
7928 
      return
7929 
    oprot.writeStructBegin('getTransactionsForShoppingCartId_args')
3431 rajveer 7930 
    if self.shoppingCartId is not None:
132 ashish 7931 
      oprot.writeFieldBegin('shoppingCartId', TType.I64, 1)
7932 
      oprot.writeI64(self.shoppingCartId)
7933 
      oprot.writeFieldEnd()
7934 
    oprot.writeFieldStop()
7935 
    oprot.writeStructEnd()
7936 
 
3431 rajveer 7937 
  def validate(self):
7938 
    return
7939 
 
7940 
 
132 ashish 7941 
  def __repr__(self):
7942 
    L = ['%s=%r' % (key, value)
7943 
      for key, value in self.__dict__.iteritems()]
7944 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
7945 
 
7946 
  def __eq__(self, other):
7947 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
7948 
 
7949 
  def __ne__(self, other):
7950 
    return not (self == other)
7951 
 
7952 
class getTransactionsForShoppingCartId_result:
7953 
  """
7954 
  Attributes:
7955 
   - success
7956 
   - ex
7957 
  """
7958 
 
7959 
  thrift_spec = (
7960 
    (0, TType.LIST, 'success', (TType.STRUCT,(Transaction, Transaction.thrift_spec)), None, ), # 0
7961 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
7962 
  )
7963 
 
7964 
  def __init__(self, success=None, ex=None,):
7965 
    self.success = success
7966 
    self.ex = ex
7967 
 
7968 
  def read(self, iprot):
7969 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
7970 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
7971 
      return
7972 
    iprot.readStructBegin()
7973 
    while True:
7974 
      (fname, ftype, fid) = iprot.readFieldBegin()
7975 
      if ftype == TType.STOP:
7976 
        break
7977 
      if fid == 0:
7978 
        if ftype == TType.LIST:
7979 
          self.success = []
5031 varun.gupt 7980 
          (_etype73, _size70) = iprot.readListBegin()
7981 
          for _i74 in xrange(_size70):
7982 
            _elem75 = Transaction()
7983 
            _elem75.read(iprot)
7984 
            self.success.append(_elem75)
132 ashish 7985 
          iprot.readListEnd()
7986 
        else:
7987 
          iprot.skip(ftype)
7988 
      elif fid == 1:
7989 
        if ftype == TType.STRUCT:
7990 
          self.ex = TransactionServiceException()
7991 
          self.ex.read(iprot)
7992 
        else:
7993 
          iprot.skip(ftype)
7994 
      else:
7995 
        iprot.skip(ftype)
7996 
      iprot.readFieldEnd()
7997 
    iprot.readStructEnd()
7998 
 
7999 
  def write(self, oprot):
8000 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8001 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8002 
      return
8003 
    oprot.writeStructBegin('getTransactionsForShoppingCartId_result')
3431 rajveer 8004 
    if self.success is not None:
132 ashish 8005 
      oprot.writeFieldBegin('success', TType.LIST, 0)
8006 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
5031 varun.gupt 8007 
      for iter76 in self.success:
8008 
        iter76.write(oprot)
132 ashish 8009 
      oprot.writeListEnd()
8010 
      oprot.writeFieldEnd()
3431 rajveer 8011 
    if self.ex is not None:
132 ashish 8012 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
8013 
      self.ex.write(oprot)
8014 
      oprot.writeFieldEnd()
8015 
    oprot.writeFieldStop()
8016 
    oprot.writeStructEnd()
8017 
 
3431 rajveer 8018 
  def validate(self):
8019 
    return
8020 
 
8021 
 
132 ashish 8022 
  def __repr__(self):
8023 
    L = ['%s=%r' % (key, value)
8024 
      for key, value in self.__dict__.iteritems()]
8025 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8026 
 
8027 
  def __eq__(self, other):
8028 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8029 
 
8030 
  def __ne__(self, other):
8031 
    return not (self == other)
8032 
 
94 ashish 8033 
class getTransactionStatus_args:
8034 
  """
8035 
  Attributes:
8036 
   - transactionId
8037 
  """
8038 
 
8039 
  thrift_spec = (
8040 
    None, # 0
8041 
    (1, TType.I64, 'transactionId', None, None, ), # 1
8042 
  )
8043 
 
8044 
  def __init__(self, transactionId=None,):
8045 
    self.transactionId = transactionId
8046 
 
8047 
  def read(self, iprot):
8048 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8049 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8050 
      return
8051 
    iprot.readStructBegin()
8052 
    while True:
8053 
      (fname, ftype, fid) = iprot.readFieldBegin()
8054 
      if ftype == TType.STOP:
8055 
        break
8056 
      if fid == 1:
8057 
        if ftype == TType.I64:
8058 
          self.transactionId = iprot.readI64();
8059 
        else:
8060 
          iprot.skip(ftype)
8061 
      else:
8062 
        iprot.skip(ftype)
8063 
      iprot.readFieldEnd()
8064 
    iprot.readStructEnd()
8065 
 
8066 
  def write(self, oprot):
8067 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8068 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8069 
      return
8070 
    oprot.writeStructBegin('getTransactionStatus_args')
3431 rajveer 8071 
    if self.transactionId is not None:
94 ashish 8072 
      oprot.writeFieldBegin('transactionId', TType.I64, 1)
8073 
      oprot.writeI64(self.transactionId)
8074 
      oprot.writeFieldEnd()
8075 
    oprot.writeFieldStop()
8076 
    oprot.writeStructEnd()
8077 
 
3431 rajveer 8078 
  def validate(self):
8079 
    return
8080 
 
8081 
 
94 ashish 8082 
  def __repr__(self):
8083 
    L = ['%s=%r' % (key, value)
8084 
      for key, value in self.__dict__.iteritems()]
8085 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8086 
 
8087 
  def __eq__(self, other):
8088 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8089 
 
8090 
  def __ne__(self, other):
8091 
    return not (self == other)
8092 
 
8093 
class getTransactionStatus_result:
8094 
  """
8095 
  Attributes:
8096 
   - success
8097 
   - ex
8098 
  """
8099 
 
8100 
  thrift_spec = (
8101 
    (0, TType.I32, 'success', None, None, ), # 0
8102 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
8103 
  )
8104 
 
8105 
  def __init__(self, success=None, ex=None,):
8106 
    self.success = success
8107 
    self.ex = ex
8108 
 
8109 
  def read(self, iprot):
8110 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8111 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8112 
      return
8113 
    iprot.readStructBegin()
8114 
    while True:
8115 
      (fname, ftype, fid) = iprot.readFieldBegin()
8116 
      if ftype == TType.STOP:
8117 
        break
8118 
      if fid == 0:
8119 
        if ftype == TType.I32:
8120 
          self.success = iprot.readI32();
8121 
        else:
8122 
          iprot.skip(ftype)
8123 
      elif fid == 1:
8124 
        if ftype == TType.STRUCT:
8125 
          self.ex = TransactionServiceException()
8126 
          self.ex.read(iprot)
8127 
        else:
8128 
          iprot.skip(ftype)
8129 
      else:
8130 
        iprot.skip(ftype)
8131 
      iprot.readFieldEnd()
8132 
    iprot.readStructEnd()
8133 
 
8134 
  def write(self, oprot):
8135 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8136 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8137 
      return
8138 
    oprot.writeStructBegin('getTransactionStatus_result')
3431 rajveer 8139 
    if self.success is not None:
94 ashish 8140 
      oprot.writeFieldBegin('success', TType.I32, 0)
8141 
      oprot.writeI32(self.success)
8142 
      oprot.writeFieldEnd()
3431 rajveer 8143 
    if self.ex is not None:
94 ashish 8144 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
8145 
      self.ex.write(oprot)
8146 
      oprot.writeFieldEnd()
8147 
    oprot.writeFieldStop()
8148 
    oprot.writeStructEnd()
8149 
 
3431 rajveer 8150 
  def validate(self):
8151 
    return
8152 
 
8153 
 
94 ashish 8154 
  def __repr__(self):
8155 
    L = ['%s=%r' % (key, value)
8156 
      for key, value in self.__dict__.iteritems()]
8157 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8158 
 
8159 
  def __eq__(self, other):
8160 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8161 
 
8162 
  def __ne__(self, other):
8163 
    return not (self == other)
8164 
 
8165 
class changeTransactionStatus_args:
8166 
  """
8167 
  Attributes:
8168 
   - transactionId
8169 
   - status
8170 
   - description
5527 anupam.sin 8171 
   - pickUp
8172 
   - orderType
94 ashish 8173 
  """
8174 
 
8175 
  thrift_spec = (
8176 
    None, # 0
8177 
    (1, TType.I64, 'transactionId', None, None, ), # 1
8178 
    (2, TType.I32, 'status', None, None, ), # 2
8179 
    (3, TType.STRING, 'description', None, None, ), # 3
5527 anupam.sin 8180 
    (4, TType.I64, 'pickUp', None, None, ), # 4
8181 
    (5, TType.I32, 'orderType', None, None, ), # 5
94 ashish 8182 
  )
8183 
 
5527 anupam.sin 8184 
  def __init__(self, transactionId=None, status=None, description=None, pickUp=None, orderType=None,):
94 ashish 8185 
    self.transactionId = transactionId
8186 
    self.status = status
8187 
    self.description = description
5527 anupam.sin 8188 
    self.pickUp = pickUp
8189 
    self.orderType = orderType
94 ashish 8190 
 
8191 
  def read(self, iprot):
8192 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8193 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8194 
      return
8195 
    iprot.readStructBegin()
8196 
    while True:
8197 
      (fname, ftype, fid) = iprot.readFieldBegin()
8198 
      if ftype == TType.STOP:
8199 
        break
8200 
      if fid == 1:
8201 
        if ftype == TType.I64:
8202 
          self.transactionId = iprot.readI64();
8203 
        else:
8204 
          iprot.skip(ftype)
8205 
      elif fid == 2:
8206 
        if ftype == TType.I32:
8207 
          self.status = iprot.readI32();
8208 
        else:
8209 
          iprot.skip(ftype)
8210 
      elif fid == 3:
8211 
        if ftype == TType.STRING:
8212 
          self.description = iprot.readString();
8213 
        else:
8214 
          iprot.skip(ftype)
5387 rajveer 8215 
      elif fid == 4:
5527 anupam.sin 8216 
        if ftype == TType.I64:
8217 
          self.pickUp = iprot.readI64();
5387 rajveer 8218 
        else:
8219 
          iprot.skip(ftype)
5527 anupam.sin 8220 
      elif fid == 5:
8221 
        if ftype == TType.I32:
8222 
          self.orderType = iprot.readI32();
8223 
        else:
8224 
          iprot.skip(ftype)
94 ashish 8225 
      else:
8226 
        iprot.skip(ftype)
8227 
      iprot.readFieldEnd()
8228 
    iprot.readStructEnd()
8229 
 
8230 
  def write(self, oprot):
8231 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8232 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8233 
      return
8234 
    oprot.writeStructBegin('changeTransactionStatus_args')
3431 rajveer 8235 
    if self.transactionId is not None:
94 ashish 8236 
      oprot.writeFieldBegin('transactionId', TType.I64, 1)
8237 
      oprot.writeI64(self.transactionId)
8238 
      oprot.writeFieldEnd()
3431 rajveer 8239 
    if self.status is not None:
94 ashish 8240 
      oprot.writeFieldBegin('status', TType.I32, 2)
8241 
      oprot.writeI32(self.status)
8242 
      oprot.writeFieldEnd()
3431 rajveer 8243 
    if self.description is not None:
94 ashish 8244 
      oprot.writeFieldBegin('description', TType.STRING, 3)
8245 
      oprot.writeString(self.description)
8246 
      oprot.writeFieldEnd()
5527 anupam.sin 8247 
    if self.pickUp is not None:
8248 
      oprot.writeFieldBegin('pickUp', TType.I64, 4)
8249 
      oprot.writeI64(self.pickUp)
5387 rajveer 8250 
      oprot.writeFieldEnd()
5527 anupam.sin 8251 
    if self.orderType is not None:
8252 
      oprot.writeFieldBegin('orderType', TType.I32, 5)
8253 
      oprot.writeI32(self.orderType)
8254 
      oprot.writeFieldEnd()
94 ashish 8255 
    oprot.writeFieldStop()
8256 
    oprot.writeStructEnd()
8257 
 
3431 rajveer 8258 
  def validate(self):
8259 
    return
8260 
 
8261 
 
94 ashish 8262 
  def __repr__(self):
8263 
    L = ['%s=%r' % (key, value)
8264 
      for key, value in self.__dict__.iteritems()]
8265 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8266 
 
8267 
  def __eq__(self, other):
8268 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8269 
 
8270 
  def __ne__(self, other):
8271 
    return not (self == other)
8272 
 
8273 
class changeTransactionStatus_result:
8274 
  """
8275 
  Attributes:
8276 
   - success
8277 
   - ex
8278 
  """
8279 
 
8280 
  thrift_spec = (
8281 
    (0, TType.BOOL, 'success', None, None, ), # 0
8282 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
8283 
  )
8284 
 
8285 
  def __init__(self, success=None, ex=None,):
8286 
    self.success = success
8287 
    self.ex = ex
8288 
 
8289 
  def read(self, iprot):
8290 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8291 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8292 
      return
8293 
    iprot.readStructBegin()
8294 
    while True:
8295 
      (fname, ftype, fid) = iprot.readFieldBegin()
8296 
      if ftype == TType.STOP:
8297 
        break
8298 
      if fid == 0:
8299 
        if ftype == TType.BOOL:
8300 
          self.success = iprot.readBool();
8301 
        else:
8302 
          iprot.skip(ftype)
8303 
      elif fid == 1:
8304 
        if ftype == TType.STRUCT:
8305 
          self.ex = TransactionServiceException()
8306 
          self.ex.read(iprot)
8307 
        else:
8308 
          iprot.skip(ftype)
8309 
      else:
8310 
        iprot.skip(ftype)
8311 
      iprot.readFieldEnd()
8312 
    iprot.readStructEnd()
8313 
 
8314 
  def write(self, oprot):
8315 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8316 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8317 
      return
8318 
    oprot.writeStructBegin('changeTransactionStatus_result')
3431 rajveer 8319 
    if self.success is not None:
94 ashish 8320 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
8321 
      oprot.writeBool(self.success)
8322 
      oprot.writeFieldEnd()
3431 rajveer 8323 
    if self.ex is not None:
94 ashish 8324 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
8325 
      self.ex.write(oprot)
8326 
      oprot.writeFieldEnd()
8327 
    oprot.writeFieldStop()
8328 
    oprot.writeStructEnd()
8329 
 
3431 rajveer 8330 
  def validate(self):
8331 
    return
8332 
 
8333 
 
94 ashish 8334 
  def __repr__(self):
8335 
    L = ['%s=%r' % (key, value)
8336 
      for key, value in self.__dict__.iteritems()]
8337 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8338 
 
8339 
  def __eq__(self, other):
8340 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8341 
 
8342 
  def __ne__(self, other):
8343 
    return not (self == other)
8344 
 
1398 varun.gupt 8345 
class enqueueTransactionInfoEmail_args:
1382 varun.gupt 8346 
  """
8347 
  Attributes:
8348 
   - transactionId
8349 
  """
8350 
 
8351 
  thrift_spec = (
8352 
    None, # 0
8353 
    (1, TType.I64, 'transactionId', None, None, ), # 1
8354 
  )
8355 
 
8356 
  def __init__(self, transactionId=None,):
8357 
    self.transactionId = transactionId
8358 
 
8359 
  def read(self, iprot):
8360 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8361 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8362 
      return
8363 
    iprot.readStructBegin()
8364 
    while True:
8365 
      (fname, ftype, fid) = iprot.readFieldBegin()
8366 
      if ftype == TType.STOP:
8367 
        break
8368 
      if fid == 1:
8369 
        if ftype == TType.I64:
8370 
          self.transactionId = iprot.readI64();
8371 
        else:
8372 
          iprot.skip(ftype)
8373 
      else:
8374 
        iprot.skip(ftype)
8375 
      iprot.readFieldEnd()
8376 
    iprot.readStructEnd()
8377 
 
8378 
  def write(self, oprot):
8379 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8380 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8381 
      return
1398 varun.gupt 8382 
    oprot.writeStructBegin('enqueueTransactionInfoEmail_args')
3431 rajveer 8383 
    if self.transactionId is not None:
1382 varun.gupt 8384 
      oprot.writeFieldBegin('transactionId', TType.I64, 1)
8385 
      oprot.writeI64(self.transactionId)
8386 
      oprot.writeFieldEnd()
8387 
    oprot.writeFieldStop()
8388 
    oprot.writeStructEnd()
8389 
 
3431 rajveer 8390 
  def validate(self):
8391 
    return
8392 
 
8393 
 
1382 varun.gupt 8394 
  def __repr__(self):
8395 
    L = ['%s=%r' % (key, value)
8396 
      for key, value in self.__dict__.iteritems()]
8397 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8398 
 
8399 
  def __eq__(self, other):
8400 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8401 
 
8402 
  def __ne__(self, other):
8403 
    return not (self == other)
8404 
 
1398 varun.gupt 8405 
class enqueueTransactionInfoEmail_result:
1382 varun.gupt 8406 
  """
8407 
  Attributes:
8408 
   - success
8409 
   - ex
8410 
  """
8411 
 
8412 
  thrift_spec = (
8413 
    (0, TType.BOOL, 'success', None, None, ), # 0
8414 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
8415 
  )
8416 
 
8417 
  def __init__(self, success=None, ex=None,):
8418 
    self.success = success
8419 
    self.ex = ex
8420 
 
8421 
  def read(self, iprot):
8422 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8423 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8424 
      return
8425 
    iprot.readStructBegin()
8426 
    while True:
8427 
      (fname, ftype, fid) = iprot.readFieldBegin()
8428 
      if ftype == TType.STOP:
8429 
        break
8430 
      if fid == 0:
8431 
        if ftype == TType.BOOL:
8432 
          self.success = iprot.readBool();
8433 
        else:
8434 
          iprot.skip(ftype)
8435 
      elif fid == 1:
8436 
        if ftype == TType.STRUCT:
8437 
          self.ex = TransactionServiceException()
8438 
          self.ex.read(iprot)
8439 
        else:
8440 
          iprot.skip(ftype)
8441 
      else:
8442 
        iprot.skip(ftype)
8443 
      iprot.readFieldEnd()
8444 
    iprot.readStructEnd()
8445 
 
8446 
  def write(self, oprot):
8447 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8448 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8449 
      return
1398 varun.gupt 8450 
    oprot.writeStructBegin('enqueueTransactionInfoEmail_result')
3431 rajveer 8451 
    if self.success is not None:
1382 varun.gupt 8452 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
8453 
      oprot.writeBool(self.success)
8454 
      oprot.writeFieldEnd()
3431 rajveer 8455 
    if self.ex is not None:
1382 varun.gupt 8456 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
8457 
      self.ex.write(oprot)
8458 
      oprot.writeFieldEnd()
8459 
    oprot.writeFieldStop()
8460 
    oprot.writeStructEnd()
8461 
 
3431 rajveer 8462 
  def validate(self):
8463 
    return
8464 
 
8465 
 
1382 varun.gupt 8466 
  def __repr__(self):
8467 
    L = ['%s=%r' % (key, value)
8468 
      for key, value in self.__dict__.iteritems()]
8469 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8470 
 
8471 
  def __eq__(self, other):
8472 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8473 
 
8474 
  def __ne__(self, other):
8475 
    return not (self == other)
8476 
 
483 rajveer 8477 
class getAllOrders_args:
94 ashish 8478 
  """
8479 
  Attributes:
4801 anupam.sin 8480 
   - statuses
483 rajveer 8481 
   - from_date
8482 
   - to_date
8483 
   - warehouse_id
94 ashish 8484 
  """
8485 
 
8486 
  thrift_spec = (
8487 
    None, # 0
4801 anupam.sin 8488 
    (1, TType.LIST, 'statuses', (TType.I32,None), None, ), # 1
483 rajveer 8489 
    (2, TType.I64, 'from_date', None, None, ), # 2
8490 
    (3, TType.I64, 'to_date', None, None, ), # 3
8491 
    (4, TType.I64, 'warehouse_id', None, None, ), # 4
94 ashish 8492 
  )
8493 
 
4801 anupam.sin 8494 
  def __init__(self, statuses=None, from_date=None, to_date=None, warehouse_id=None,):
8495 
    self.statuses = statuses
483 rajveer 8496 
    self.from_date = from_date
8497 
    self.to_date = to_date
8498 
    self.warehouse_id = warehouse_id
94 ashish 8499 
 
8500 
  def read(self, iprot):
8501 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8502 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8503 
      return
8504 
    iprot.readStructBegin()
8505 
    while True:
8506 
      (fname, ftype, fid) = iprot.readFieldBegin()
8507 
      if ftype == TType.STOP:
8508 
        break
8509 
      if fid == 1:
4801 anupam.sin 8510 
        if ftype == TType.LIST:
8511 
          self.statuses = []
5031 varun.gupt 8512 
          (_etype80, _size77) = iprot.readListBegin()
8513 
          for _i81 in xrange(_size77):
8514 
            _elem82 = iprot.readI32();
8515 
            self.statuses.append(_elem82)
4801 anupam.sin 8516 
          iprot.readListEnd()
94 ashish 8517 
        else:
8518 
          iprot.skip(ftype)
483 rajveer 8519 
      elif fid == 2:
8520 
        if ftype == TType.I64:
8521 
          self.from_date = iprot.readI64();
94 ashish 8522 
        else:
8523 
          iprot.skip(ftype)
483 rajveer 8524 
      elif fid == 3:
8525 
        if ftype == TType.I64:
8526 
          self.to_date = iprot.readI64();
94 ashish 8527 
        else:
8528 
          iprot.skip(ftype)
483 rajveer 8529 
      elif fid == 4:
94 ashish 8530 
        if ftype == TType.I64:
483 rajveer 8531 
          self.warehouse_id = iprot.readI64();
94 ashish 8532 
        else:
8533 
          iprot.skip(ftype)
8534 
      else:
8535 
        iprot.skip(ftype)
8536 
      iprot.readFieldEnd()
8537 
    iprot.readStructEnd()
8538 
 
8539 
  def write(self, oprot):
8540 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8541 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8542 
      return
483 rajveer 8543 
    oprot.writeStructBegin('getAllOrders_args')
4801 anupam.sin 8544 
    if self.statuses is not None:
8545 
      oprot.writeFieldBegin('statuses', TType.LIST, 1)
8546 
      oprot.writeListBegin(TType.I32, len(self.statuses))
5031 varun.gupt 8547 
      for iter83 in self.statuses:
8548 
        oprot.writeI32(iter83)
4801 anupam.sin 8549 
      oprot.writeListEnd()
94 ashish 8550 
      oprot.writeFieldEnd()
3431 rajveer 8551 
    if self.from_date is not None:
483 rajveer 8552 
      oprot.writeFieldBegin('from_date', TType.I64, 2)
8553 
      oprot.writeI64(self.from_date)
94 ashish 8554 
      oprot.writeFieldEnd()
3431 rajveer 8555 
    if self.to_date is not None:
483 rajveer 8556 
      oprot.writeFieldBegin('to_date', TType.I64, 3)
8557 
      oprot.writeI64(self.to_date)
94 ashish 8558 
      oprot.writeFieldEnd()
3431 rajveer 8559 
    if self.warehouse_id is not None:
483 rajveer 8560 
      oprot.writeFieldBegin('warehouse_id', TType.I64, 4)
8561 
      oprot.writeI64(self.warehouse_id)
94 ashish 8562 
      oprot.writeFieldEnd()
8563 
    oprot.writeFieldStop()
8564 
    oprot.writeStructEnd()
8565 
 
3431 rajveer 8566 
  def validate(self):
8567 
    return
8568 
 
8569 
 
94 ashish 8570 
  def __repr__(self):
8571 
    L = ['%s=%r' % (key, value)
8572 
      for key, value in self.__dict__.iteritems()]
8573 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8574 
 
8575 
  def __eq__(self, other):
8576 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8577 
 
8578 
  def __ne__(self, other):
8579 
    return not (self == other)
8580 
 
483 rajveer 8581 
class getAllOrders_result:
94 ashish 8582 
  """
8583 
  Attributes:
8584 
   - success
8585 
   - ex
8586 
  """
8587 
 
8588 
  thrift_spec = (
483 rajveer 8589 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
94 ashish 8590 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
8591 
  )
8592 
 
8593 
  def __init__(self, success=None, ex=None,):
8594 
    self.success = success
8595 
    self.ex = ex
8596 
 
8597 
  def read(self, iprot):
8598 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8599 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8600 
      return
8601 
    iprot.readStructBegin()
8602 
    while True:
8603 
      (fname, ftype, fid) = iprot.readFieldBegin()
8604 
      if ftype == TType.STOP:
8605 
        break
8606 
      if fid == 0:
483 rajveer 8607 
        if ftype == TType.LIST:
8608 
          self.success = []
5031 varun.gupt 8609 
          (_etype87, _size84) = iprot.readListBegin()
8610 
          for _i88 in xrange(_size84):
8611 
            _elem89 = Order()
8612 
            _elem89.read(iprot)
8613 
            self.success.append(_elem89)
483 rajveer 8614 
          iprot.readListEnd()
94 ashish 8615 
        else:
8616 
          iprot.skip(ftype)
8617 
      elif fid == 1:
8618 
        if ftype == TType.STRUCT:
8619 
          self.ex = TransactionServiceException()
8620 
          self.ex.read(iprot)
8621 
        else:
8622 
          iprot.skip(ftype)
8623 
      else:
8624 
        iprot.skip(ftype)
8625 
      iprot.readFieldEnd()
8626 
    iprot.readStructEnd()
8627 
 
8628 
  def write(self, oprot):
8629 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8630 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8631 
      return
483 rajveer 8632 
    oprot.writeStructBegin('getAllOrders_result')
3431 rajveer 8633 
    if self.success is not None:
483 rajveer 8634 
      oprot.writeFieldBegin('success', TType.LIST, 0)
8635 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
5031 varun.gupt 8636 
      for iter90 in self.success:
8637 
        iter90.write(oprot)
483 rajveer 8638 
      oprot.writeListEnd()
94 ashish 8639 
      oprot.writeFieldEnd()
3431 rajveer 8640 
    if self.ex is not None:
94 ashish 8641 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
8642 
      self.ex.write(oprot)
8643 
      oprot.writeFieldEnd()
8644 
    oprot.writeFieldStop()
8645 
    oprot.writeStructEnd()
8646 
 
3431 rajveer 8647 
  def validate(self):
8648 
    return
8649 
 
8650 
 
94 ashish 8651 
  def __repr__(self):
8652 
    L = ['%s=%r' % (key, value)
8653 
      for key, value in self.__dict__.iteritems()]
8654 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8655 
 
8656 
  def __eq__(self, other):
8657 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8658 
 
8659 
  def __ne__(self, other):
8660 
    return not (self == other)
8661 
 
4133 chandransh 8662 
class getOrdersInBatch_args:
8663 
  """
8664 
  Attributes:
8665 
   - statuses
8666 
   - offset
8667 
   - limit
8668 
   - warehouse_id
8669 
  """
8670 
 
8671 
  thrift_spec = (
8672 
    None, # 0
8673 
    (1, TType.LIST, 'statuses', (TType.I32,None), None, ), # 1
8674 
    (2, TType.I64, 'offset', None, None, ), # 2
8675 
    (3, TType.I64, 'limit', None, None, ), # 3
8676 
    (4, TType.I64, 'warehouse_id', None, None, ), # 4
8677 
  )
8678 
 
8679 
  def __init__(self, statuses=None, offset=None, limit=None, warehouse_id=None,):
8680 
    self.statuses = statuses
8681 
    self.offset = offset
8682 
    self.limit = limit
8683 
    self.warehouse_id = warehouse_id
8684 
 
8685 
  def read(self, iprot):
8686 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8687 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8688 
      return
8689 
    iprot.readStructBegin()
8690 
    while True:
8691 
      (fname, ftype, fid) = iprot.readFieldBegin()
8692 
      if ftype == TType.STOP:
8693 
        break
8694 
      if fid == 1:
8695 
        if ftype == TType.LIST:
8696 
          self.statuses = []
5031 varun.gupt 8697 
          (_etype94, _size91) = iprot.readListBegin()
8698 
          for _i95 in xrange(_size91):
8699 
            _elem96 = iprot.readI32();
8700 
            self.statuses.append(_elem96)
4133 chandransh 8701 
          iprot.readListEnd()
8702 
        else:
8703 
          iprot.skip(ftype)
8704 
      elif fid == 2:
8705 
        if ftype == TType.I64:
8706 
          self.offset = iprot.readI64();
8707 
        else:
8708 
          iprot.skip(ftype)
8709 
      elif fid == 3:
8710 
        if ftype == TType.I64:
8711 
          self.limit = iprot.readI64();
8712 
        else:
8713 
          iprot.skip(ftype)
8714 
      elif fid == 4:
8715 
        if ftype == TType.I64:
8716 
          self.warehouse_id = iprot.readI64();
8717 
        else:
8718 
          iprot.skip(ftype)
8719 
      else:
8720 
        iprot.skip(ftype)
8721 
      iprot.readFieldEnd()
8722 
    iprot.readStructEnd()
8723 
 
8724 
  def write(self, oprot):
8725 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8726 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8727 
      return
8728 
    oprot.writeStructBegin('getOrdersInBatch_args')
8729 
    if self.statuses is not None:
8730 
      oprot.writeFieldBegin('statuses', TType.LIST, 1)
8731 
      oprot.writeListBegin(TType.I32, len(self.statuses))
5031 varun.gupt 8732 
      for iter97 in self.statuses:
8733 
        oprot.writeI32(iter97)
4133 chandransh 8734 
      oprot.writeListEnd()
8735 
      oprot.writeFieldEnd()
8736 
    if self.offset is not None:
8737 
      oprot.writeFieldBegin('offset', TType.I64, 2)
8738 
      oprot.writeI64(self.offset)
8739 
      oprot.writeFieldEnd()
8740 
    if self.limit is not None:
8741 
      oprot.writeFieldBegin('limit', TType.I64, 3)
8742 
      oprot.writeI64(self.limit)
8743 
      oprot.writeFieldEnd()
8744 
    if self.warehouse_id is not None:
8745 
      oprot.writeFieldBegin('warehouse_id', TType.I64, 4)
8746 
      oprot.writeI64(self.warehouse_id)
8747 
      oprot.writeFieldEnd()
8748 
    oprot.writeFieldStop()
8749 
    oprot.writeStructEnd()
8750 
 
8751 
  def validate(self):
8752 
    return
8753 
 
8754 
 
8755 
  def __repr__(self):
8756 
    L = ['%s=%r' % (key, value)
8757 
      for key, value in self.__dict__.iteritems()]
8758 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8759 
 
8760 
  def __eq__(self, other):
8761 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8762 
 
8763 
  def __ne__(self, other):
8764 
    return not (self == other)
8765 
 
8766 
class getOrdersInBatch_result:
8767 
  """
8768 
  Attributes:
8769 
   - success
8770 
   - ex
8771 
  """
8772 
 
8773 
  thrift_spec = (
8774 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
8775 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
8776 
  )
8777 
 
8778 
  def __init__(self, success=None, ex=None,):
8779 
    self.success = success
8780 
    self.ex = ex
8781 
 
8782 
  def read(self, iprot):
8783 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8784 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8785 
      return
8786 
    iprot.readStructBegin()
8787 
    while True:
8788 
      (fname, ftype, fid) = iprot.readFieldBegin()
8789 
      if ftype == TType.STOP:
8790 
        break
8791 
      if fid == 0:
8792 
        if ftype == TType.LIST:
8793 
          self.success = []
5031 varun.gupt 8794 
          (_etype101, _size98) = iprot.readListBegin()
8795 
          for _i102 in xrange(_size98):
8796 
            _elem103 = Order()
8797 
            _elem103.read(iprot)
8798 
            self.success.append(_elem103)
4133 chandransh 8799 
          iprot.readListEnd()
8800 
        else:
8801 
          iprot.skip(ftype)
8802 
      elif fid == 1:
8803 
        if ftype == TType.STRUCT:
8804 
          self.ex = TransactionServiceException()
8805 
          self.ex.read(iprot)
8806 
        else:
8807 
          iprot.skip(ftype)
8808 
      else:
8809 
        iprot.skip(ftype)
8810 
      iprot.readFieldEnd()
8811 
    iprot.readStructEnd()
8812 
 
8813 
  def write(self, oprot):
8814 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8815 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8816 
      return
8817 
    oprot.writeStructBegin('getOrdersInBatch_result')
8818 
    if self.success is not None:
8819 
      oprot.writeFieldBegin('success', TType.LIST, 0)
8820 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
5031 varun.gupt 8821 
      for iter104 in self.success:
8822 
        iter104.write(oprot)
4133 chandransh 8823 
      oprot.writeListEnd()
8824 
      oprot.writeFieldEnd()
8825 
    if self.ex is not None:
8826 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
8827 
      self.ex.write(oprot)
8828 
      oprot.writeFieldEnd()
8829 
    oprot.writeFieldStop()
8830 
    oprot.writeStructEnd()
8831 
 
8832 
  def validate(self):
8833 
    return
8834 
 
8835 
 
8836 
  def __repr__(self):
8837 
    L = ['%s=%r' % (key, value)
8838 
      for key, value in self.__dict__.iteritems()]
8839 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8840 
 
8841 
  def __eq__(self, other):
8842 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8843 
 
8844 
  def __ne__(self, other):
8845 
    return not (self == other)
8846 
 
8847 
class getOrderCount_args:
8848 
  """
8849 
  Attributes:
8850 
   - statuses
8851 
   - warehouseId
8852 
  """
8853 
 
8854 
  thrift_spec = (
8855 
    None, # 0
8856 
    (1, TType.LIST, 'statuses', (TType.I32,None), None, ), # 1
8857 
    (2, TType.I64, 'warehouseId', None, None, ), # 2
8858 
  )
8859 
 
8860 
  def __init__(self, statuses=None, warehouseId=None,):
8861 
    self.statuses = statuses
8862 
    self.warehouseId = warehouseId
8863 
 
8864 
  def read(self, iprot):
8865 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8866 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8867 
      return
8868 
    iprot.readStructBegin()
8869 
    while True:
8870 
      (fname, ftype, fid) = iprot.readFieldBegin()
8871 
      if ftype == TType.STOP:
8872 
        break
8873 
      if fid == 1:
8874 
        if ftype == TType.LIST:
8875 
          self.statuses = []
5031 varun.gupt 8876 
          (_etype108, _size105) = iprot.readListBegin()
8877 
          for _i109 in xrange(_size105):
8878 
            _elem110 = iprot.readI32();
8879 
            self.statuses.append(_elem110)
4133 chandransh 8880 
          iprot.readListEnd()
8881 
        else:
8882 
          iprot.skip(ftype)
8883 
      elif fid == 2:
8884 
        if ftype == TType.I64:
8885 
          self.warehouseId = iprot.readI64();
8886 
        else:
8887 
          iprot.skip(ftype)
8888 
      else:
8889 
        iprot.skip(ftype)
8890 
      iprot.readFieldEnd()
8891 
    iprot.readStructEnd()
8892 
 
8893 
  def write(self, oprot):
8894 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8895 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8896 
      return
8897 
    oprot.writeStructBegin('getOrderCount_args')
8898 
    if self.statuses is not None:
8899 
      oprot.writeFieldBegin('statuses', TType.LIST, 1)
8900 
      oprot.writeListBegin(TType.I32, len(self.statuses))
5031 varun.gupt 8901 
      for iter111 in self.statuses:
8902 
        oprot.writeI32(iter111)
4133 chandransh 8903 
      oprot.writeListEnd()
8904 
      oprot.writeFieldEnd()
8905 
    if self.warehouseId is not None:
8906 
      oprot.writeFieldBegin('warehouseId', TType.I64, 2)
8907 
      oprot.writeI64(self.warehouseId)
8908 
      oprot.writeFieldEnd()
8909 
    oprot.writeFieldStop()
8910 
    oprot.writeStructEnd()
8911 
 
8912 
  def validate(self):
8913 
    return
8914 
 
8915 
 
8916 
  def __repr__(self):
8917 
    L = ['%s=%r' % (key, value)
8918 
      for key, value in self.__dict__.iteritems()]
8919 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8920 
 
8921 
  def __eq__(self, other):
8922 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8923 
 
8924 
  def __ne__(self, other):
8925 
    return not (self == other)
8926 
 
8927 
class getOrderCount_result:
8928 
  """
8929 
  Attributes:
8930 
   - success
8931 
   - ex
8932 
  """
8933 
 
8934 
  thrift_spec = (
8935 
    (0, TType.I32, 'success', None, None, ), # 0
8936 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
8937 
  )
8938 
 
8939 
  def __init__(self, success=None, ex=None,):
8940 
    self.success = success
8941 
    self.ex = ex
8942 
 
8943 
  def read(self, iprot):
8944 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8945 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8946 
      return
8947 
    iprot.readStructBegin()
8948 
    while True:
8949 
      (fname, ftype, fid) = iprot.readFieldBegin()
8950 
      if ftype == TType.STOP:
8951 
        break
8952 
      if fid == 0:
8953 
        if ftype == TType.I32:
8954 
          self.success = iprot.readI32();
8955 
        else:
8956 
          iprot.skip(ftype)
8957 
      elif fid == 1:
8958 
        if ftype == TType.STRUCT:
8959 
          self.ex = TransactionServiceException()
8960 
          self.ex.read(iprot)
8961 
        else:
8962 
          iprot.skip(ftype)
8963 
      else:
8964 
        iprot.skip(ftype)
8965 
      iprot.readFieldEnd()
8966 
    iprot.readStructEnd()
8967 
 
8968 
  def write(self, oprot):
8969 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8970 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8971 
      return
8972 
    oprot.writeStructBegin('getOrderCount_result')
8973 
    if self.success is not None:
8974 
      oprot.writeFieldBegin('success', TType.I32, 0)
8975 
      oprot.writeI32(self.success)
8976 
      oprot.writeFieldEnd()
8977 
    if self.ex is not None:
8978 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
8979 
      self.ex.write(oprot)
8980 
      oprot.writeFieldEnd()
8981 
    oprot.writeFieldStop()
8982 
    oprot.writeStructEnd()
8983 
 
8984 
  def validate(self):
8985 
    return
8986 
 
8987 
 
8988 
  def __repr__(self):
8989 
    L = ['%s=%r' % (key, value)
8990 
      for key, value in self.__dict__.iteritems()]
8991 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8992 
 
8993 
  def __eq__(self, other):
8994 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8995 
 
8996 
  def __ne__(self, other):
8997 
    return not (self == other)
8998 
 
999 varun.gupt 8999 
class getOrdersByBillingDate_args:
9000 
  """
9001 
  Attributes:
9002 
   - status
9003 
   - start_billing_date
9004 
   - end_billing_date
9005 
   - warehouse_id
9006 
  """
9007 
 
9008 
  thrift_spec = (
9009 
    None, # 0
9010 
    (1, TType.I32, 'status', None, None, ), # 1
9011 
    (2, TType.I64, 'start_billing_date', None, None, ), # 2
9012 
    (3, TType.I64, 'end_billing_date', None, None, ), # 3
9013 
    (4, TType.I64, 'warehouse_id', None, None, ), # 4
9014 
  )
9015 
 
9016 
  def __init__(self, status=None, start_billing_date=None, end_billing_date=None, warehouse_id=None,):
9017 
    self.status = status
9018 
    self.start_billing_date = start_billing_date
9019 
    self.end_billing_date = end_billing_date
9020 
    self.warehouse_id = warehouse_id
9021 
 
9022 
  def read(self, iprot):
9023 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9024 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9025 
      return
9026 
    iprot.readStructBegin()
9027 
    while True:
9028 
      (fname, ftype, fid) = iprot.readFieldBegin()
9029 
      if ftype == TType.STOP:
9030 
        break
9031 
      if fid == 1:
9032 
        if ftype == TType.I32:
9033 
          self.status = iprot.readI32();
9034 
        else:
9035 
          iprot.skip(ftype)
9036 
      elif fid == 2:
9037 
        if ftype == TType.I64:
9038 
          self.start_billing_date = iprot.readI64();
9039 
        else:
9040 
          iprot.skip(ftype)
9041 
      elif fid == 3:
9042 
        if ftype == TType.I64:
9043 
          self.end_billing_date = iprot.readI64();
9044 
        else:
9045 
          iprot.skip(ftype)
9046 
      elif fid == 4:
9047 
        if ftype == TType.I64:
9048 
          self.warehouse_id = iprot.readI64();
9049 
        else:
9050 
          iprot.skip(ftype)
9051 
      else:
9052 
        iprot.skip(ftype)
9053 
      iprot.readFieldEnd()
9054 
    iprot.readStructEnd()
9055 
 
9056 
  def write(self, oprot):
9057 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9058 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9059 
      return
9060 
    oprot.writeStructBegin('getOrdersByBillingDate_args')
3431 rajveer 9061 
    if self.status is not None:
999 varun.gupt 9062 
      oprot.writeFieldBegin('status', TType.I32, 1)
9063 
      oprot.writeI32(self.status)
9064 
      oprot.writeFieldEnd()
3431 rajveer 9065 
    if self.start_billing_date is not None:
999 varun.gupt 9066 
      oprot.writeFieldBegin('start_billing_date', TType.I64, 2)
9067 
      oprot.writeI64(self.start_billing_date)
9068 
      oprot.writeFieldEnd()
3431 rajveer 9069 
    if self.end_billing_date is not None:
999 varun.gupt 9070 
      oprot.writeFieldBegin('end_billing_date', TType.I64, 3)
9071 
      oprot.writeI64(self.end_billing_date)
9072 
      oprot.writeFieldEnd()
3431 rajveer 9073 
    if self.warehouse_id is not None:
999 varun.gupt 9074 
      oprot.writeFieldBegin('warehouse_id', TType.I64, 4)
9075 
      oprot.writeI64(self.warehouse_id)
9076 
      oprot.writeFieldEnd()
9077 
    oprot.writeFieldStop()
9078 
    oprot.writeStructEnd()
9079 
 
3431 rajveer 9080 
  def validate(self):
9081 
    return
9082 
 
9083 
 
999 varun.gupt 9084 
  def __repr__(self):
9085 
    L = ['%s=%r' % (key, value)
9086 
      for key, value in self.__dict__.iteritems()]
9087 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9088 
 
9089 
  def __eq__(self, other):
9090 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9091 
 
9092 
  def __ne__(self, other):
9093 
    return not (self == other)
9094 
 
9095 
class getOrdersByBillingDate_result:
9096 
  """
9097 
  Attributes:
9098 
   - success
9099 
   - ex
9100 
  """
9101 
 
9102 
  thrift_spec = (
9103 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
9104 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
9105 
  )
9106 
 
9107 
  def __init__(self, success=None, ex=None,):
9108 
    self.success = success
9109 
    self.ex = ex
9110 
 
9111 
  def read(self, iprot):
9112 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9113 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9114 
      return
9115 
    iprot.readStructBegin()
9116 
    while True:
9117 
      (fname, ftype, fid) = iprot.readFieldBegin()
9118 
      if ftype == TType.STOP:
9119 
        break
9120 
      if fid == 0:
9121 
        if ftype == TType.LIST:
9122 
          self.success = []
5031 varun.gupt 9123 
          (_etype115, _size112) = iprot.readListBegin()
9124 
          for _i116 in xrange(_size112):
9125 
            _elem117 = Order()
9126 
            _elem117.read(iprot)
9127 
            self.success.append(_elem117)
999 varun.gupt 9128 
          iprot.readListEnd()
9129 
        else:
9130 
          iprot.skip(ftype)
9131 
      elif fid == 1:
9132 
        if ftype == TType.STRUCT:
9133 
          self.ex = TransactionServiceException()
9134 
          self.ex.read(iprot)
9135 
        else:
9136 
          iprot.skip(ftype)
9137 
      else:
9138 
        iprot.skip(ftype)
9139 
      iprot.readFieldEnd()
9140 
    iprot.readStructEnd()
9141 
 
9142 
  def write(self, oprot):
9143 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9144 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9145 
      return
9146 
    oprot.writeStructBegin('getOrdersByBillingDate_result')
3431 rajveer 9147 
    if self.success is not None:
999 varun.gupt 9148 
      oprot.writeFieldBegin('success', TType.LIST, 0)
9149 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
5031 varun.gupt 9150 
      for iter118 in self.success:
9151 
        iter118.write(oprot)
999 varun.gupt 9152 
      oprot.writeListEnd()
9153 
      oprot.writeFieldEnd()
3431 rajveer 9154 
    if self.ex is not None:
999 varun.gupt 9155 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
9156 
      self.ex.write(oprot)
9157 
      oprot.writeFieldEnd()
9158 
    oprot.writeFieldStop()
9159 
    oprot.writeStructEnd()
9160 
 
3431 rajveer 9161 
  def validate(self):
9162 
    return
9163 
 
9164 
 
999 varun.gupt 9165 
  def __repr__(self):
9166 
    L = ['%s=%r' % (key, value)
9167 
      for key, value in self.__dict__.iteritems()]
9168 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9169 
 
9170 
  def __eq__(self, other):
9171 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9172 
 
9173 
  def __ne__(self, other):
9174 
    return not (self == other)
9175 
 
3427 chandransh 9176 
class getOrdersByShippingDate_args:
9177 
  """
9178 
  Attributes:
9179 
   - fromShippingDate
9180 
   - toShippingDate
9181 
   - providerId
9182 
   - warehouseId
3451 chandransh 9183 
   - cod
3427 chandransh 9184 
  """
9185 
 
9186 
  thrift_spec = (
9187 
    None, # 0
9188 
    (1, TType.I64, 'fromShippingDate', None, None, ), # 1
9189 
    (2, TType.I64, 'toShippingDate', None, None, ), # 2
9190 
    (3, TType.I64, 'providerId', None, None, ), # 3
9191 
    (4, TType.I64, 'warehouseId', None, None, ), # 4
3451 chandransh 9192 
    (5, TType.BOOL, 'cod', None, None, ), # 5
3427 chandransh 9193 
  )
9194 
 
3451 chandransh 9195 
  def __init__(self, fromShippingDate=None, toShippingDate=None, providerId=None, warehouseId=None, cod=None,):
3427 chandransh 9196 
    self.fromShippingDate = fromShippingDate
9197 
    self.toShippingDate = toShippingDate
9198 
    self.providerId = providerId
9199 
    self.warehouseId = warehouseId
3451 chandransh 9200 
    self.cod = cod
3427 chandransh 9201 
 
9202 
  def read(self, iprot):
9203 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9204 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9205 
      return
9206 
    iprot.readStructBegin()
9207 
    while True:
9208 
      (fname, ftype, fid) = iprot.readFieldBegin()
9209 
      if ftype == TType.STOP:
9210 
        break
9211 
      if fid == 1:
9212 
        if ftype == TType.I64:
9213 
          self.fromShippingDate = iprot.readI64();
9214 
        else:
9215 
          iprot.skip(ftype)
9216 
      elif fid == 2:
9217 
        if ftype == TType.I64:
9218 
          self.toShippingDate = iprot.readI64();
9219 
        else:
9220 
          iprot.skip(ftype)
9221 
      elif fid == 3:
9222 
        if ftype == TType.I64:
9223 
          self.providerId = iprot.readI64();
9224 
        else:
9225 
          iprot.skip(ftype)
9226 
      elif fid == 4:
9227 
        if ftype == TType.I64:
9228 
          self.warehouseId = iprot.readI64();
9229 
        else:
9230 
          iprot.skip(ftype)
3451 chandransh 9231 
      elif fid == 5:
9232 
        if ftype == TType.BOOL:
9233 
          self.cod = iprot.readBool();
9234 
        else:
9235 
          iprot.skip(ftype)
3427 chandransh 9236 
      else:
9237 
        iprot.skip(ftype)
9238 
      iprot.readFieldEnd()
9239 
    iprot.readStructEnd()
9240 
 
9241 
  def write(self, oprot):
9242 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9243 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9244 
      return
9245 
    oprot.writeStructBegin('getOrdersByShippingDate_args')
3431 rajveer 9246 
    if self.fromShippingDate is not None:
3427 chandransh 9247 
      oprot.writeFieldBegin('fromShippingDate', TType.I64, 1)
9248 
      oprot.writeI64(self.fromShippingDate)
9249 
      oprot.writeFieldEnd()
3431 rajveer 9250 
    if self.toShippingDate is not None:
3427 chandransh 9251 
      oprot.writeFieldBegin('toShippingDate', TType.I64, 2)
9252 
      oprot.writeI64(self.toShippingDate)
9253 
      oprot.writeFieldEnd()
3431 rajveer 9254 
    if self.providerId is not None:
3427 chandransh 9255 
      oprot.writeFieldBegin('providerId', TType.I64, 3)
9256 
      oprot.writeI64(self.providerId)
9257 
      oprot.writeFieldEnd()
3431 rajveer 9258 
    if self.warehouseId is not None:
3427 chandransh 9259 
      oprot.writeFieldBegin('warehouseId', TType.I64, 4)
9260 
      oprot.writeI64(self.warehouseId)
9261 
      oprot.writeFieldEnd()
3451 chandransh 9262 
    if self.cod is not None:
9263 
      oprot.writeFieldBegin('cod', TType.BOOL, 5)
9264 
      oprot.writeBool(self.cod)
9265 
      oprot.writeFieldEnd()
3427 chandransh 9266 
    oprot.writeFieldStop()
9267 
    oprot.writeStructEnd()
9268 
 
3431 rajveer 9269 
  def validate(self):
9270 
    return
9271 
 
9272 
 
3427 chandransh 9273 
  def __repr__(self):
9274 
    L = ['%s=%r' % (key, value)
9275 
      for key, value in self.__dict__.iteritems()]
9276 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9277 
 
9278 
  def __eq__(self, other):
9279 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9280 
 
9281 
  def __ne__(self, other):
9282 
    return not (self == other)
9283 
 
9284 
class getOrdersByShippingDate_result:
9285 
  """
9286 
  Attributes:
9287 
   - success
9288 
   - ex
9289 
  """
9290 
 
9291 
  thrift_spec = (
9292 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
9293 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
9294 
  )
9295 
 
9296 
  def __init__(self, success=None, ex=None,):
9297 
    self.success = success
9298 
    self.ex = ex
9299 
 
9300 
  def read(self, iprot):
9301 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9302 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9303 
      return
9304 
    iprot.readStructBegin()
9305 
    while True:
9306 
      (fname, ftype, fid) = iprot.readFieldBegin()
9307 
      if ftype == TType.STOP:
9308 
        break
9309 
      if fid == 0:
9310 
        if ftype == TType.LIST:
9311 
          self.success = []
5031 varun.gupt 9312 
          (_etype122, _size119) = iprot.readListBegin()
9313 
          for _i123 in xrange(_size119):
9314 
            _elem124 = Order()
9315 
            _elem124.read(iprot)
9316 
            self.success.append(_elem124)
3427 chandransh 9317 
          iprot.readListEnd()
9318 
        else:
9319 
          iprot.skip(ftype)
9320 
      elif fid == 1:
9321 
        if ftype == TType.STRUCT:
9322 
          self.ex = TransactionServiceException()
9323 
          self.ex.read(iprot)
9324 
        else:
9325 
          iprot.skip(ftype)
9326 
      else:
9327 
        iprot.skip(ftype)
9328 
      iprot.readFieldEnd()
9329 
    iprot.readStructEnd()
9330 
 
9331 
  def write(self, oprot):
9332 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9333 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9334 
      return
9335 
    oprot.writeStructBegin('getOrdersByShippingDate_result')
3431 rajveer 9336 
    if self.success is not None:
3427 chandransh 9337 
      oprot.writeFieldBegin('success', TType.LIST, 0)
9338 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
5031 varun.gupt 9339 
      for iter125 in self.success:
9340 
        iter125.write(oprot)
3427 chandransh 9341 
      oprot.writeListEnd()
9342 
      oprot.writeFieldEnd()
3431 rajveer 9343 
    if self.ex is not None:
3427 chandransh 9344 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
9345 
      self.ex.write(oprot)
9346 
      oprot.writeFieldEnd()
9347 
    oprot.writeFieldStop()
9348 
    oprot.writeStructEnd()
9349 
 
3431 rajveer 9350 
  def validate(self):
9351 
    return
9352 
 
9353 
 
3427 chandransh 9354 
  def __repr__(self):
9355 
    L = ['%s=%r' % (key, value)
9356 
      for key, value in self.__dict__.iteritems()]
9357 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9358 
 
9359 
  def __eq__(self, other):
9360 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9361 
 
9362 
  def __ne__(self, other):
9363 
    return not (self == other)
9364 
 
1382 varun.gupt 9365 
class getReturnableOrdersForCustomer_args:
9366 
  """
9367 
  Attributes:
9368 
   - customer_id
9369 
   - limit
9370 
  """
9371 
 
9372 
  thrift_spec = (
9373 
    None, # 0
9374 
    (1, TType.I64, 'customer_id', None, None, ), # 1
9375 
    (2, TType.I64, 'limit', None, None, ), # 2
9376 
  )
9377 
 
9378 
  def __init__(self, customer_id=None, limit=None,):
9379 
    self.customer_id = customer_id
9380 
    self.limit = limit
9381 
 
9382 
  def read(self, iprot):
9383 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9384 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9385 
      return
9386 
    iprot.readStructBegin()
9387 
    while True:
9388 
      (fname, ftype, fid) = iprot.readFieldBegin()
9389 
      if ftype == TType.STOP:
9390 
        break
9391 
      if fid == 1:
9392 
        if ftype == TType.I64:
9393 
          self.customer_id = iprot.readI64();
9394 
        else:
9395 
          iprot.skip(ftype)
9396 
      elif fid == 2:
9397 
        if ftype == TType.I64:
9398 
          self.limit = iprot.readI64();
9399 
        else:
9400 
          iprot.skip(ftype)
9401 
      else:
9402 
        iprot.skip(ftype)
9403 
      iprot.readFieldEnd()
9404 
    iprot.readStructEnd()
9405 
 
9406 
  def write(self, oprot):
9407 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9408 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9409 
      return
9410 
    oprot.writeStructBegin('getReturnableOrdersForCustomer_args')
3431 rajveer 9411 
    if self.customer_id is not None:
1382 varun.gupt 9412 
      oprot.writeFieldBegin('customer_id', TType.I64, 1)
9413 
      oprot.writeI64(self.customer_id)
9414 
      oprot.writeFieldEnd()
3431 rajveer 9415 
    if self.limit is not None:
1382 varun.gupt 9416 
      oprot.writeFieldBegin('limit', TType.I64, 2)
9417 
      oprot.writeI64(self.limit)
9418 
      oprot.writeFieldEnd()
9419 
    oprot.writeFieldStop()
9420 
    oprot.writeStructEnd()
9421 
 
3431 rajveer 9422 
  def validate(self):
9423 
    return
9424 
 
9425 
 
1382 varun.gupt 9426 
  def __repr__(self):
9427 
    L = ['%s=%r' % (key, value)
9428 
      for key, value in self.__dict__.iteritems()]
9429 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9430 
 
9431 
  def __eq__(self, other):
9432 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9433 
 
9434 
  def __ne__(self, other):
9435 
    return not (self == other)
9436 
 
9437 
class getReturnableOrdersForCustomer_result:
9438 
  """
9439 
  Attributes:
9440 
   - success
9441 
   - ex
9442 
  """
9443 
 
9444 
  thrift_spec = (
9445 
    (0, TType.LIST, 'success', (TType.I64,None), None, ), # 0
9446 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
9447 
  )
9448 
 
9449 
  def __init__(self, success=None, ex=None,):
9450 
    self.success = success
9451 
    self.ex = ex
9452 
 
9453 
  def read(self, iprot):
9454 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9455 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9456 
      return
9457 
    iprot.readStructBegin()
9458 
    while True:
9459 
      (fname, ftype, fid) = iprot.readFieldBegin()
9460 
      if ftype == TType.STOP:
9461 
        break
9462 
      if fid == 0:
9463 
        if ftype == TType.LIST:
9464 
          self.success = []
5031 varun.gupt 9465 
          (_etype129, _size126) = iprot.readListBegin()
9466 
          for _i130 in xrange(_size126):
9467 
            _elem131 = iprot.readI64();
9468 
            self.success.append(_elem131)
1382 varun.gupt 9469 
          iprot.readListEnd()
9470 
        else:
9471 
          iprot.skip(ftype)
9472 
      elif fid == 1:
9473 
        if ftype == TType.STRUCT:
9474 
          self.ex = TransactionServiceException()
9475 
          self.ex.read(iprot)
9476 
        else:
9477 
          iprot.skip(ftype)
9478 
      else:
9479 
        iprot.skip(ftype)
9480 
      iprot.readFieldEnd()
9481 
    iprot.readStructEnd()
9482 
 
9483 
  def write(self, oprot):
9484 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9485 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9486 
      return
9487 
    oprot.writeStructBegin('getReturnableOrdersForCustomer_result')
3431 rajveer 9488 
    if self.success is not None:
1382 varun.gupt 9489 
      oprot.writeFieldBegin('success', TType.LIST, 0)
9490 
      oprot.writeListBegin(TType.I64, len(self.success))
5031 varun.gupt 9491 
      for iter132 in self.success:
9492 
        oprot.writeI64(iter132)
1382 varun.gupt 9493 
      oprot.writeListEnd()
9494 
      oprot.writeFieldEnd()
3431 rajveer 9495 
    if self.ex is not None:
1382 varun.gupt 9496 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
9497 
      self.ex.write(oprot)
9498 
      oprot.writeFieldEnd()
9499 
    oprot.writeFieldStop()
9500 
    oprot.writeStructEnd()
9501 
 
3431 rajveer 9502 
  def validate(self):
9503 
    return
9504 
 
9505 
 
1382 varun.gupt 9506 
  def __repr__(self):
9507 
    L = ['%s=%r' % (key, value)
9508 
      for key, value in self.__dict__.iteritems()]
9509 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9510 
 
9511 
  def __eq__(self, other):
9512 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9513 
 
9514 
  def __ne__(self, other):
9515 
    return not (self == other)
9516 
 
9517 
class getCancellableOrdersForCustomer_args:
9518 
  """
9519 
  Attributes:
9520 
   - customer_id
9521 
   - limit
9522 
  """
9523 
 
9524 
  thrift_spec = (
9525 
    None, # 0
9526 
    (1, TType.I64, 'customer_id', None, None, ), # 1
9527 
    (2, TType.I64, 'limit', None, None, ), # 2
9528 
  )
9529 
 
9530 
  def __init__(self, customer_id=None, limit=None,):
9531 
    self.customer_id = customer_id
9532 
    self.limit = limit
9533 
 
9534 
  def read(self, iprot):
9535 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9536 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9537 
      return
9538 
    iprot.readStructBegin()
9539 
    while True:
9540 
      (fname, ftype, fid) = iprot.readFieldBegin()
9541 
      if ftype == TType.STOP:
9542 
        break
9543 
      if fid == 1:
9544 
        if ftype == TType.I64:
9545 
          self.customer_id = iprot.readI64();
9546 
        else:
9547 
          iprot.skip(ftype)
9548 
      elif fid == 2:
9549 
        if ftype == TType.I64:
9550 
          self.limit = iprot.readI64();
9551 
        else:
9552 
          iprot.skip(ftype)
9553 
      else:
9554 
        iprot.skip(ftype)
9555 
      iprot.readFieldEnd()
9556 
    iprot.readStructEnd()
9557 
 
9558 
  def write(self, oprot):
9559 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9560 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9561 
      return
9562 
    oprot.writeStructBegin('getCancellableOrdersForCustomer_args')
3431 rajveer 9563 
    if self.customer_id is not None:
1382 varun.gupt 9564 
      oprot.writeFieldBegin('customer_id', TType.I64, 1)
9565 
      oprot.writeI64(self.customer_id)
9566 
      oprot.writeFieldEnd()
3431 rajveer 9567 
    if self.limit is not None:
1382 varun.gupt 9568 
      oprot.writeFieldBegin('limit', TType.I64, 2)
9569 
      oprot.writeI64(self.limit)
9570 
      oprot.writeFieldEnd()
9571 
    oprot.writeFieldStop()
9572 
    oprot.writeStructEnd()
9573 
 
3431 rajveer 9574 
  def validate(self):
9575 
    return
9576 
 
9577 
 
1382 varun.gupt 9578 
  def __repr__(self):
9579 
    L = ['%s=%r' % (key, value)
9580 
      for key, value in self.__dict__.iteritems()]
9581 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9582 
 
9583 
  def __eq__(self, other):
9584 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9585 
 
9586 
  def __ne__(self, other):
9587 
    return not (self == other)
9588 
 
9589 
class getCancellableOrdersForCustomer_result:
9590 
  """
9591 
  Attributes:
9592 
   - success
9593 
   - ex
9594 
  """
9595 
 
9596 
  thrift_spec = (
9597 
    (0, TType.LIST, 'success', (TType.I64,None), None, ), # 0
9598 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
9599 
  )
9600 
 
9601 
  def __init__(self, success=None, ex=None,):
9602 
    self.success = success
9603 
    self.ex = ex
9604 
 
9605 
  def read(self, iprot):
9606 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9607 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9608 
      return
9609 
    iprot.readStructBegin()
9610 
    while True:
9611 
      (fname, ftype, fid) = iprot.readFieldBegin()
9612 
      if ftype == TType.STOP:
9613 
        break
9614 
      if fid == 0:
9615 
        if ftype == TType.LIST:
9616 
          self.success = []
5031 varun.gupt 9617 
          (_etype136, _size133) = iprot.readListBegin()
9618 
          for _i137 in xrange(_size133):
9619 
            _elem138 = iprot.readI64();
9620 
            self.success.append(_elem138)
1382 varun.gupt 9621 
          iprot.readListEnd()
9622 
        else:
9623 
          iprot.skip(ftype)
9624 
      elif fid == 1:
9625 
        if ftype == TType.STRUCT:
9626 
          self.ex = TransactionServiceException()
9627 
          self.ex.read(iprot)
9628 
        else:
9629 
          iprot.skip(ftype)
9630 
      else:
9631 
        iprot.skip(ftype)
9632 
      iprot.readFieldEnd()
9633 
    iprot.readStructEnd()
9634 
 
9635 
  def write(self, oprot):
9636 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9637 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9638 
      return
9639 
    oprot.writeStructBegin('getCancellableOrdersForCustomer_result')
3431 rajveer 9640 
    if self.success is not None:
1382 varun.gupt 9641 
      oprot.writeFieldBegin('success', TType.LIST, 0)
9642 
      oprot.writeListBegin(TType.I64, len(self.success))
5031 varun.gupt 9643 
      for iter139 in self.success:
9644 
        oprot.writeI64(iter139)
1382 varun.gupt 9645 
      oprot.writeListEnd()
9646 
      oprot.writeFieldEnd()
3431 rajveer 9647 
    if self.ex is not None:
1382 varun.gupt 9648 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
9649 
      self.ex.write(oprot)
9650 
      oprot.writeFieldEnd()
9651 
    oprot.writeFieldStop()
9652 
    oprot.writeStructEnd()
9653 
 
3431 rajveer 9654 
  def validate(self):
9655 
    return
9656 
 
9657 
 
1382 varun.gupt 9658 
  def __repr__(self):
9659 
    L = ['%s=%r' % (key, value)
9660 
      for key, value in self.__dict__.iteritems()]
9661 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9662 
 
9663 
  def __eq__(self, other):
9664 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9665 
 
9666 
  def __ne__(self, other):
9667 
    return not (self == other)
9668 
 
483 rajveer 9669 
class changeOrderStatus_args:
94 ashish 9670 
  """
9671 
  Attributes:
483 rajveer 9672 
   - orderId
9673 
   - status
9674 
   - description
94 ashish 9675 
  """
9676 
 
9677 
  thrift_spec = (
9678 
    None, # 0
483 rajveer 9679 
    (1, TType.I64, 'orderId', None, None, ), # 1
9680 
    (2, TType.I32, 'status', None, None, ), # 2
9681 
    (3, TType.STRING, 'description', None, None, ), # 3
94 ashish 9682 
  )
9683 
 
483 rajveer 9684 
  def __init__(self, orderId=None, status=None, description=None,):
9685 
    self.orderId = orderId
9686 
    self.status = status
9687 
    self.description = description
94 ashish 9688 
 
9689 
  def read(self, iprot):
9690 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9691 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9692 
      return
9693 
    iprot.readStructBegin()
9694 
    while True:
9695 
      (fname, ftype, fid) = iprot.readFieldBegin()
9696 
      if ftype == TType.STOP:
9697 
        break
9698 
      if fid == 1:
9699 
        if ftype == TType.I64:
483 rajveer 9700 
          self.orderId = iprot.readI64();
94 ashish 9701 
        else:
9702 
          iprot.skip(ftype)
9703 
      elif fid == 2:
483 rajveer 9704 
        if ftype == TType.I32:
9705 
          self.status = iprot.readI32();
94 ashish 9706 
        else:
9707 
          iprot.skip(ftype)
483 rajveer 9708 
      elif fid == 3:
9709 
        if ftype == TType.STRING:
9710 
          self.description = iprot.readString();
9711 
        else:
9712 
          iprot.skip(ftype)
94 ashish 9713 
      else:
9714 
        iprot.skip(ftype)
9715 
      iprot.readFieldEnd()
9716 
    iprot.readStructEnd()
9717 
 
9718 
  def write(self, oprot):
9719 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9720 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9721 
      return
483 rajveer 9722 
    oprot.writeStructBegin('changeOrderStatus_args')
3431 rajveer 9723 
    if self.orderId is not None:
483 rajveer 9724 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
9725 
      oprot.writeI64(self.orderId)
94 ashish 9726 
      oprot.writeFieldEnd()
3431 rajveer 9727 
    if self.status is not None:
483 rajveer 9728 
      oprot.writeFieldBegin('status', TType.I32, 2)
9729 
      oprot.writeI32(self.status)
94 ashish 9730 
      oprot.writeFieldEnd()
3431 rajveer 9731 
    if self.description is not None:
483 rajveer 9732 
      oprot.writeFieldBegin('description', TType.STRING, 3)
9733 
      oprot.writeString(self.description)
9734 
      oprot.writeFieldEnd()
94 ashish 9735 
    oprot.writeFieldStop()
9736 
    oprot.writeStructEnd()
9737 
 
3431 rajveer 9738 
  def validate(self):
9739 
    return
9740 
 
9741 
 
94 ashish 9742 
  def __repr__(self):
9743 
    L = ['%s=%r' % (key, value)
9744 
      for key, value in self.__dict__.iteritems()]
9745 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9746 
 
9747 
  def __eq__(self, other):
9748 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9749 
 
9750 
  def __ne__(self, other):
9751 
    return not (self == other)
9752 
 
483 rajveer 9753 
class changeOrderStatus_result:
94 ashish 9754 
  """
9755 
  Attributes:
9756 
   - success
9757 
   - ex
9758 
  """
9759 
 
9760 
  thrift_spec = (
9761 
    (0, TType.BOOL, 'success', None, None, ), # 0
9762 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
9763 
  )
9764 
 
9765 
  def __init__(self, success=None, ex=None,):
9766 
    self.success = success
9767 
    self.ex = ex
9768 
 
9769 
  def read(self, iprot):
9770 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9771 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9772 
      return
9773 
    iprot.readStructBegin()
9774 
    while True:
9775 
      (fname, ftype, fid) = iprot.readFieldBegin()
9776 
      if ftype == TType.STOP:
9777 
        break
9778 
      if fid == 0:
9779 
        if ftype == TType.BOOL:
9780 
          self.success = iprot.readBool();
9781 
        else:
9782 
          iprot.skip(ftype)
9783 
      elif fid == 1:
9784 
        if ftype == TType.STRUCT:
9785 
          self.ex = TransactionServiceException()
9786 
          self.ex.read(iprot)
9787 
        else:
9788 
          iprot.skip(ftype)
9789 
      else:
9790 
        iprot.skip(ftype)
9791 
      iprot.readFieldEnd()
9792 
    iprot.readStructEnd()
9793 
 
9794 
  def write(self, oprot):
9795 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9796 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9797 
      return
483 rajveer 9798 
    oprot.writeStructBegin('changeOrderStatus_result')
3431 rajveer 9799 
    if self.success is not None:
94 ashish 9800 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
9801 
      oprot.writeBool(self.success)
9802 
      oprot.writeFieldEnd()
3431 rajveer 9803 
    if self.ex is not None:
94 ashish 9804 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
9805 
      self.ex.write(oprot)
9806 
      oprot.writeFieldEnd()
9807 
    oprot.writeFieldStop()
9808 
    oprot.writeStructEnd()
9809 
 
3431 rajveer 9810 
  def validate(self):
9811 
    return
9812 
 
9813 
 
94 ashish 9814 
  def __repr__(self):
9815 
    L = ['%s=%r' % (key, value)
9816 
      for key, value in self.__dict__.iteritems()]
9817 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9818 
 
9819 
  def __eq__(self, other):
9820 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9821 
 
9822 
  def __ne__(self, other):
9823 
    return not (self == other)
9824 
 
3064 chandransh 9825 
class getOrdersForTransaction_args:
494 rajveer 9826 
  """
9827 
  Attributes:
3064 chandransh 9828 
   - transactionId
9829 
   - customerId
494 rajveer 9830 
  """
9831 
 
9832 
  thrift_spec = (
9833 
    None, # 0
3064 chandransh 9834 
    (1, TType.I64, 'transactionId', None, None, ), # 1
9835 
    (2, TType.I64, 'customerId', None, None, ), # 2
494 rajveer 9836 
  )
9837 
 
3064 chandransh 9838 
  def __init__(self, transactionId=None, customerId=None,):
9839 
    self.transactionId = transactionId
9840 
    self.customerId = customerId
494 rajveer 9841 
 
9842 
  def read(self, iprot):
9843 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9844 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9845 
      return
9846 
    iprot.readStructBegin()
9847 
    while True:
9848 
      (fname, ftype, fid) = iprot.readFieldBegin()
9849 
      if ftype == TType.STOP:
9850 
        break
9851 
      if fid == 1:
9852 
        if ftype == TType.I64:
3064 chandransh 9853 
          self.transactionId = iprot.readI64();
494 rajveer 9854 
        else:
9855 
          iprot.skip(ftype)
9856 
      elif fid == 2:
3064 chandransh 9857 
        if ftype == TType.I64:
9858 
          self.customerId = iprot.readI64();
494 rajveer 9859 
        else:
9860 
          iprot.skip(ftype)
9861 
      else:
9862 
        iprot.skip(ftype)
9863 
      iprot.readFieldEnd()
9864 
    iprot.readStructEnd()
9865 
 
9866 
  def write(self, oprot):
9867 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9868 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9869 
      return
3064 chandransh 9870 
    oprot.writeStructBegin('getOrdersForTransaction_args')
3431 rajveer 9871 
    if self.transactionId is not None:
3064 chandransh 9872 
      oprot.writeFieldBegin('transactionId', TType.I64, 1)
9873 
      oprot.writeI64(self.transactionId)
494 rajveer 9874 
      oprot.writeFieldEnd()
3431 rajveer 9875 
    if self.customerId is not None:
3064 chandransh 9876 
      oprot.writeFieldBegin('customerId', TType.I64, 2)
9877 
      oprot.writeI64(self.customerId)
494 rajveer 9878 
      oprot.writeFieldEnd()
9879 
    oprot.writeFieldStop()
9880 
    oprot.writeStructEnd()
9881 
 
3431 rajveer 9882 
  def validate(self):
9883 
    return
9884 
 
9885 
 
494 rajveer 9886 
  def __repr__(self):
9887 
    L = ['%s=%r' % (key, value)
9888 
      for key, value in self.__dict__.iteritems()]
9889 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9890 
 
9891 
  def __eq__(self, other):
9892 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9893 
 
9894 
  def __ne__(self, other):
9895 
    return not (self == other)
9896 
 
3064 chandransh 9897 
class getOrdersForTransaction_result:
494 rajveer 9898 
  """
9899 
  Attributes:
9900 
   - success
9901 
   - ex
9902 
  """
9903 
 
9904 
  thrift_spec = (
3064 chandransh 9905 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
494 rajveer 9906 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
9907 
  )
9908 
 
9909 
  def __init__(self, success=None, ex=None,):
9910 
    self.success = success
9911 
    self.ex = ex
9912 
 
9913 
  def read(self, iprot):
9914 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9915 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9916 
      return
9917 
    iprot.readStructBegin()
9918 
    while True:
9919 
      (fname, ftype, fid) = iprot.readFieldBegin()
9920 
      if ftype == TType.STOP:
9921 
        break
9922 
      if fid == 0:
3064 chandransh 9923 
        if ftype == TType.LIST:
9924 
          self.success = []
5031 varun.gupt 9925 
          (_etype143, _size140) = iprot.readListBegin()
9926 
          for _i144 in xrange(_size140):
9927 
            _elem145 = Order()
9928 
            _elem145.read(iprot)
9929 
            self.success.append(_elem145)
3064 chandransh 9930 
          iprot.readListEnd()
494 rajveer 9931 
        else:
9932 
          iprot.skip(ftype)
9933 
      elif fid == 1:
9934 
        if ftype == TType.STRUCT:
9935 
          self.ex = TransactionServiceException()
9936 
          self.ex.read(iprot)
9937 
        else:
9938 
          iprot.skip(ftype)
9939 
      else:
9940 
        iprot.skip(ftype)
9941 
      iprot.readFieldEnd()
9942 
    iprot.readStructEnd()
9943 
 
9944 
  def write(self, oprot):
9945 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9946 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9947 
      return
3064 chandransh 9948 
    oprot.writeStructBegin('getOrdersForTransaction_result')
3431 rajveer 9949 
    if self.success is not None:
3064 chandransh 9950 
      oprot.writeFieldBegin('success', TType.LIST, 0)
9951 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
5031 varun.gupt 9952 
      for iter146 in self.success:
9953 
        iter146.write(oprot)
3064 chandransh 9954 
      oprot.writeListEnd()
494 rajveer 9955 
      oprot.writeFieldEnd()
3431 rajveer 9956 
    if self.ex is not None:
494 rajveer 9957 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
9958 
      self.ex.write(oprot)
9959 
      oprot.writeFieldEnd()
9960 
    oprot.writeFieldStop()
9961 
    oprot.writeStructEnd()
9962 
 
3431 rajveer 9963 
  def validate(self):
9964 
    return
9965 
 
9966 
 
494 rajveer 9967 
  def __repr__(self):
9968 
    L = ['%s=%r' % (key, value)
9969 
      for key, value in self.__dict__.iteritems()]
9970 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9971 
 
9972 
  def __eq__(self, other):
9973 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9974 
 
9975 
  def __ne__(self, other):
9976 
    return not (self == other)
9977 
 
3064 chandransh 9978 
class getOrdersForCustomer_args:
1149 chandransh 9979 
  """
9980 
  Attributes:
3064 chandransh 9981 
   - customerId
9982 
   - from_date
9983 
   - to_date
9984 
   - statuses
1149 chandransh 9985 
  """
9986 
 
9987 
  thrift_spec = (
9988 
    None, # 0
3064 chandransh 9989 
    (1, TType.I64, 'customerId', None, None, ), # 1
9990 
    (2, TType.I64, 'from_date', None, None, ), # 2
9991 
    (3, TType.I64, 'to_date', None, None, ), # 3
9992 
    (4, TType.LIST, 'statuses', (TType.I32,None), None, ), # 4
1149 chandransh 9993 
  )
9994 
 
3064 chandransh 9995 
  def __init__(self, customerId=None, from_date=None, to_date=None, statuses=None,):
9996 
    self.customerId = customerId
9997 
    self.from_date = from_date
9998 
    self.to_date = to_date
9999 
    self.statuses = statuses
1149 chandransh 10000 
 
10001 
  def read(self, iprot):
10002 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10003 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10004 
      return
10005 
    iprot.readStructBegin()
10006 
    while True:
10007 
      (fname, ftype, fid) = iprot.readFieldBegin()
10008 
      if ftype == TType.STOP:
10009 
        break
10010 
      if fid == 1:
10011 
        if ftype == TType.I64:
3064 chandransh 10012 
          self.customerId = iprot.readI64();
1149 chandransh 10013 
        else:
10014 
          iprot.skip(ftype)
10015 
      elif fid == 2:
10016 
        if ftype == TType.I64:
3064 chandransh 10017 
          self.from_date = iprot.readI64();
1149 chandransh 10018 
        else:
10019 
          iprot.skip(ftype)
2783 chandransh 10020 
      elif fid == 3:
10021 
        if ftype == TType.I64:
3064 chandransh 10022 
          self.to_date = iprot.readI64();
2783 chandransh 10023 
        else:
10024 
          iprot.skip(ftype)
10025 
      elif fid == 4:
3064 chandransh 10026 
        if ftype == TType.LIST:
10027 
          self.statuses = []
5031 varun.gupt 10028 
          (_etype150, _size147) = iprot.readListBegin()
10029 
          for _i151 in xrange(_size147):
10030 
            _elem152 = iprot.readI32();
10031 
            self.statuses.append(_elem152)
3064 chandransh 10032 
          iprot.readListEnd()
2783 chandransh 10033 
        else:
10034 
          iprot.skip(ftype)
1149 chandransh 10035 
      else:
10036 
        iprot.skip(ftype)
10037 
      iprot.readFieldEnd()
10038 
    iprot.readStructEnd()
10039 
 
10040 
  def write(self, oprot):
10041 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10042 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10043 
      return
3064 chandransh 10044 
    oprot.writeStructBegin('getOrdersForCustomer_args')
3431 rajveer 10045 
    if self.customerId is not None:
3064 chandransh 10046 
      oprot.writeFieldBegin('customerId', TType.I64, 1)
10047 
      oprot.writeI64(self.customerId)
1149 chandransh 10048 
      oprot.writeFieldEnd()
3431 rajveer 10049 
    if self.from_date is not None:
3064 chandransh 10050 
      oprot.writeFieldBegin('from_date', TType.I64, 2)
10051 
      oprot.writeI64(self.from_date)
1149 chandransh 10052 
      oprot.writeFieldEnd()
3431 rajveer 10053 
    if self.to_date is not None:
3064 chandransh 10054 
      oprot.writeFieldBegin('to_date', TType.I64, 3)
10055 
      oprot.writeI64(self.to_date)
2783 chandransh 10056 
      oprot.writeFieldEnd()
3431 rajveer 10057 
    if self.statuses is not None:
3064 chandransh 10058 
      oprot.writeFieldBegin('statuses', TType.LIST, 4)
10059 
      oprot.writeListBegin(TType.I32, len(self.statuses))
5031 varun.gupt 10060 
      for iter153 in self.statuses:
10061 
        oprot.writeI32(iter153)
3064 chandransh 10062 
      oprot.writeListEnd()
2783 chandransh 10063 
      oprot.writeFieldEnd()
1149 chandransh 10064 
    oprot.writeFieldStop()
10065 
    oprot.writeStructEnd()
10066 
 
3431 rajveer 10067 
  def validate(self):
10068 
    return
10069 
 
10070 
 
1149 chandransh 10071 
  def __repr__(self):
10072 
    L = ['%s=%r' % (key, value)
10073 
      for key, value in self.__dict__.iteritems()]
10074 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10075 
 
10076 
  def __eq__(self, other):
10077 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10078 
 
10079 
  def __ne__(self, other):
10080 
    return not (self == other)
10081 
 
3064 chandransh 10082 
class getOrdersForCustomer_result:
1149 chandransh 10083 
  """
10084 
  Attributes:
10085 
   - success
10086 
   - ex
10087 
  """
10088 
 
10089 
  thrift_spec = (
3064 chandransh 10090 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
1149 chandransh 10091 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
10092 
  )
10093 
 
10094 
  def __init__(self, success=None, ex=None,):
10095 
    self.success = success
10096 
    self.ex = ex
10097 
 
10098 
  def read(self, iprot):
10099 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10100 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10101 
      return
10102 
    iprot.readStructBegin()
10103 
    while True:
10104 
      (fname, ftype, fid) = iprot.readFieldBegin()
10105 
      if ftype == TType.STOP:
10106 
        break
10107 
      if fid == 0:
3064 chandransh 10108 
        if ftype == TType.LIST:
10109 
          self.success = []
5031 varun.gupt 10110 
          (_etype157, _size154) = iprot.readListBegin()
10111 
          for _i158 in xrange(_size154):
10112 
            _elem159 = Order()
10113 
            _elem159.read(iprot)
10114 
            self.success.append(_elem159)
3064 chandransh 10115 
          iprot.readListEnd()
1149 chandransh 10116 
        else:
10117 
          iprot.skip(ftype)
10118 
      elif fid == 1:
10119 
        if ftype == TType.STRUCT:
10120 
          self.ex = TransactionServiceException()
10121 
          self.ex.read(iprot)
10122 
        else:
10123 
          iprot.skip(ftype)
10124 
      else:
10125 
        iprot.skip(ftype)
10126 
      iprot.readFieldEnd()
10127 
    iprot.readStructEnd()
10128 
 
10129 
  def write(self, oprot):
10130 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10131 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10132 
      return
3064 chandransh 10133 
    oprot.writeStructBegin('getOrdersForCustomer_result')
3431 rajveer 10134 
    if self.success is not None:
3064 chandransh 10135 
      oprot.writeFieldBegin('success', TType.LIST, 0)
10136 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
5031 varun.gupt 10137 
      for iter160 in self.success:
10138 
        iter160.write(oprot)
3064 chandransh 10139 
      oprot.writeListEnd()
1149 chandransh 10140 
      oprot.writeFieldEnd()
3431 rajveer 10141 
    if self.ex is not None:
1149 chandransh 10142 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
10143 
      self.ex.write(oprot)
10144 
      oprot.writeFieldEnd()
10145 
    oprot.writeFieldStop()
10146 
    oprot.writeStructEnd()
10147 
 
3431 rajveer 10148 
  def validate(self):
10149 
    return
10150 
 
10151 
 
1149 chandransh 10152 
  def __repr__(self):
10153 
    L = ['%s=%r' % (key, value)
10154 
      for key, value in self.__dict__.iteritems()]
10155 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10156 
 
10157 
  def __eq__(self, other):
10158 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10159 
 
10160 
  def __ne__(self, other):
10161 
    return not (self == other)
10162 
 
3064 chandransh 10163 
class createOrder_args:
921 rajveer 10164 
  """
10165 
  Attributes:
3064 chandransh 10166 
   - order
921 rajveer 10167 
  """
10168 
 
10169 
  thrift_spec = (
10170 
    None, # 0
3064 chandransh 10171 
    (1, TType.STRUCT, 'order', (Order, Order.thrift_spec), None, ), # 1
921 rajveer 10172 
  )
10173 
 
3064 chandransh 10174 
  def __init__(self, order=None,):
10175 
    self.order = order
921 rajveer 10176 
 
10177 
  def read(self, iprot):
10178 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10179 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10180 
      return
10181 
    iprot.readStructBegin()
10182 
    while True:
10183 
      (fname, ftype, fid) = iprot.readFieldBegin()
10184 
      if ftype == TType.STOP:
10185 
        break
10186 
      if fid == 1:
3064 chandransh 10187 
        if ftype == TType.STRUCT:
10188 
          self.order = Order()
10189 
          self.order.read(iprot)
921 rajveer 10190 
        else:
10191 
          iprot.skip(ftype)
10192 
      else:
10193 
        iprot.skip(ftype)
10194 
      iprot.readFieldEnd()
10195 
    iprot.readStructEnd()
10196 
 
10197 
  def write(self, oprot):
10198 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10199 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10200 
      return
3064 chandransh 10201 
    oprot.writeStructBegin('createOrder_args')
3431 rajveer 10202 
    if self.order is not None:
3064 chandransh 10203 
      oprot.writeFieldBegin('order', TType.STRUCT, 1)
10204 
      self.order.write(oprot)
921 rajveer 10205 
      oprot.writeFieldEnd()
10206 
    oprot.writeFieldStop()
10207 
    oprot.writeStructEnd()
10208 
 
3431 rajveer 10209 
  def validate(self):
10210 
    return
10211 
 
10212 
 
921 rajveer 10213 
  def __repr__(self):
10214 
    L = ['%s=%r' % (key, value)
10215 
      for key, value in self.__dict__.iteritems()]
10216 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10217 
 
10218 
  def __eq__(self, other):
10219 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10220 
 
10221 
  def __ne__(self, other):
10222 
    return not (self == other)
10223 
 
3064 chandransh 10224 
class createOrder_result:
921 rajveer 10225 
  """
10226 
  Attributes:
10227 
   - success
10228 
   - ex
10229 
  """
10230 
 
10231 
  thrift_spec = (
3064 chandransh 10232 
    (0, TType.I64, 'success', None, None, ), # 0
921 rajveer 10233 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
10234 
  )
10235 
 
10236 
  def __init__(self, success=None, ex=None,):
10237 
    self.success = success
10238 
    self.ex = ex
10239 
 
10240 
  def read(self, iprot):
10241 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10242 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10243 
      return
10244 
    iprot.readStructBegin()
10245 
    while True:
10246 
      (fname, ftype, fid) = iprot.readFieldBegin()
10247 
      if ftype == TType.STOP:
10248 
        break
10249 
      if fid == 0:
3064 chandransh 10250 
        if ftype == TType.I64:
10251 
          self.success = iprot.readI64();
921 rajveer 10252 
        else:
10253 
          iprot.skip(ftype)
10254 
      elif fid == 1:
10255 
        if ftype == TType.STRUCT:
10256 
          self.ex = TransactionServiceException()
10257 
          self.ex.read(iprot)
10258 
        else:
10259 
          iprot.skip(ftype)
10260 
      else:
10261 
        iprot.skip(ftype)
10262 
      iprot.readFieldEnd()
10263 
    iprot.readStructEnd()
10264 
 
10265 
  def write(self, oprot):
10266 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10267 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10268 
      return
3064 chandransh 10269 
    oprot.writeStructBegin('createOrder_result')
3431 rajveer 10270 
    if self.success is not None:
3064 chandransh 10271 
      oprot.writeFieldBegin('success', TType.I64, 0)
10272 
      oprot.writeI64(self.success)
921 rajveer 10273 
      oprot.writeFieldEnd()
3431 rajveer 10274 
    if self.ex is not None:
921 rajveer 10275 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
10276 
      self.ex.write(oprot)
10277 
      oprot.writeFieldEnd()
10278 
    oprot.writeFieldStop()
10279 
    oprot.writeStructEnd()
10280 
 
3431 rajveer 10281 
  def validate(self):
10282 
    return
10283 
 
10284 
 
921 rajveer 10285 
  def __repr__(self):
10286 
    L = ['%s=%r' % (key, value)
10287 
      for key, value in self.__dict__.iteritems()]
10288 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10289 
 
10290 
  def __eq__(self, other):
10291 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10292 
 
10293 
  def __ne__(self, other):
10294 
    return not (self == other)
10295 
 
3064 chandransh 10296 
class getOrder_args:
921 rajveer 10297 
  """
10298 
  Attributes:
3064 chandransh 10299 
   - id
921 rajveer 10300 
  """
10301 
 
10302 
  thrift_spec = (
10303 
    None, # 0
3064 chandransh 10304 
    (1, TType.I64, 'id', None, None, ), # 1
921 rajveer 10305 
  )
10306 
 
3064 chandransh 10307 
  def __init__(self, id=None,):
10308 
    self.id = id
921 rajveer 10309 
 
10310 
  def read(self, iprot):
10311 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10312 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10313 
      return
10314 
    iprot.readStructBegin()
10315 
    while True:
10316 
      (fname, ftype, fid) = iprot.readFieldBegin()
10317 
      if ftype == TType.STOP:
10318 
        break
10319 
      if fid == 1:
10320 
        if ftype == TType.I64:
3064 chandransh 10321 
          self.id = iprot.readI64();
921 rajveer 10322 
        else:
10323 
          iprot.skip(ftype)
10324 
      else:
10325 
        iprot.skip(ftype)
10326 
      iprot.readFieldEnd()
10327 
    iprot.readStructEnd()
10328 
 
10329 
  def write(self, oprot):
10330 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10331 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10332 
      return
3064 chandransh 10333 
    oprot.writeStructBegin('getOrder_args')
3431 rajveer 10334 
    if self.id is not None:
3064 chandransh 10335 
      oprot.writeFieldBegin('id', TType.I64, 1)
10336 
      oprot.writeI64(self.id)
921 rajveer 10337 
      oprot.writeFieldEnd()
10338 
    oprot.writeFieldStop()
10339 
    oprot.writeStructEnd()
10340 
 
3431 rajveer 10341 
  def validate(self):
10342 
    return
10343 
 
10344 
 
921 rajveer 10345 
  def __repr__(self):
10346 
    L = ['%s=%r' % (key, value)
10347 
      for key, value in self.__dict__.iteritems()]
10348 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10349 
 
10350 
  def __eq__(self, other):
10351 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10352 
 
10353 
  def __ne__(self, other):
10354 
    return not (self == other)
10355 
 
3064 chandransh 10356 
class getOrder_result:
921 rajveer 10357 
  """
10358 
  Attributes:
10359 
   - success
10360 
   - ex
10361 
  """
10362 
 
10363 
  thrift_spec = (
3064 chandransh 10364 
    (0, TType.STRUCT, 'success', (Order, Order.thrift_spec), None, ), # 0
921 rajveer 10365 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
10366 
  )
10367 
 
10368 
  def __init__(self, success=None, ex=None,):
10369 
    self.success = success
10370 
    self.ex = ex
10371 
 
10372 
  def read(self, iprot):
10373 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10374 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10375 
      return
10376 
    iprot.readStructBegin()
10377 
    while True:
10378 
      (fname, ftype, fid) = iprot.readFieldBegin()
10379 
      if ftype == TType.STOP:
10380 
        break
10381 
      if fid == 0:
3064 chandransh 10382 
        if ftype == TType.STRUCT:
10383 
          self.success = Order()
10384 
          self.success.read(iprot)
921 rajveer 10385 
        else:
10386 
          iprot.skip(ftype)
10387 
      elif fid == 1:
10388 
        if ftype == TType.STRUCT:
10389 
          self.ex = TransactionServiceException()
10390 
          self.ex.read(iprot)
10391 
        else:
10392 
          iprot.skip(ftype)
10393 
      else:
10394 
        iprot.skip(ftype)
10395 
      iprot.readFieldEnd()
10396 
    iprot.readStructEnd()
10397 
 
10398 
  def write(self, oprot):
10399 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10400 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10401 
      return
3064 chandransh 10402 
    oprot.writeStructBegin('getOrder_result')
3431 rajveer 10403 
    if self.success is not None:
3064 chandransh 10404 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
10405 
      self.success.write(oprot)
921 rajveer 10406 
      oprot.writeFieldEnd()
3431 rajveer 10407 
    if self.ex is not None:
921 rajveer 10408 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
10409 
      self.ex.write(oprot)
10410 
      oprot.writeFieldEnd()
10411 
    oprot.writeFieldStop()
10412 
    oprot.writeStructEnd()
10413 
 
3431 rajveer 10414 
  def validate(self):
10415 
    return
10416 
 
10417 
 
921 rajveer 10418 
  def __repr__(self):
10419 
    L = ['%s=%r' % (key, value)
10420 
      for key, value in self.__dict__.iteritems()]
10421 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10422 
 
10423 
  def __eq__(self, other):
10424 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10425 
 
10426 
  def __ne__(self, other):
10427 
    return not (self == other)
10428 
 
3064 chandransh 10429 
class getLineItemsForOrder_args:
94 ashish 10430 
  """
10431 
  Attributes:
3064 chandransh 10432 
   - orderId
94 ashish 10433 
  """
10434 
 
10435 
  thrift_spec = (
10436 
    None, # 0
3064 chandransh 10437 
    (1, TType.I64, 'orderId', None, None, ), # 1
94 ashish 10438 
  )
10439 
 
3064 chandransh 10440 
  def __init__(self, orderId=None,):
10441 
    self.orderId = orderId
94 ashish 10442 
 
10443 
  def read(self, iprot):
10444 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10445 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10446 
      return
10447 
    iprot.readStructBegin()
10448 
    while True:
10449 
      (fname, ftype, fid) = iprot.readFieldBegin()
10450 
      if ftype == TType.STOP:
10451 
        break
10452 
      if fid == 1:
10453 
        if ftype == TType.I64:
3064 chandransh 10454 
          self.orderId = iprot.readI64();
94 ashish 10455 
        else:
10456 
          iprot.skip(ftype)
10457 
      else:
10458 
        iprot.skip(ftype)
10459 
      iprot.readFieldEnd()
10460 
    iprot.readStructEnd()
10461 
 
10462 
  def write(self, oprot):
10463 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10464 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10465 
      return
3064 chandransh 10466 
    oprot.writeStructBegin('getLineItemsForOrder_args')
3431 rajveer 10467 
    if self.orderId is not None:
3064 chandransh 10468 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
10469 
      oprot.writeI64(self.orderId)
94 ashish 10470 
      oprot.writeFieldEnd()
10471 
    oprot.writeFieldStop()
10472 
    oprot.writeStructEnd()
10473 
 
3431 rajveer 10474 
  def validate(self):
10475 
    return
10476 
 
10477 
 
94 ashish 10478 
  def __repr__(self):
10479 
    L = ['%s=%r' % (key, value)
10480 
      for key, value in self.__dict__.iteritems()]
10481 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10482 
 
10483 
  def __eq__(self, other):
10484 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10485 
 
10486 
  def __ne__(self, other):
10487 
    return not (self == other)
10488 
 
3064 chandransh 10489 
class getLineItemsForOrder_result:
94 ashish 10490 
  """
10491 
  Attributes:
10492 
   - success
10493 
   - ex
10494 
  """
10495 
 
10496 
  thrift_spec = (
3064 chandransh 10497 
    (0, TType.LIST, 'success', (TType.STRUCT,(LineItem, LineItem.thrift_spec)), None, ), # 0
94 ashish 10498 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
10499 
  )
10500 
 
10501 
  def __init__(self, success=None, ex=None,):
10502 
    self.success = success
10503 
    self.ex = ex
10504 
 
10505 
  def read(self, iprot):
10506 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10507 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10508 
      return
10509 
    iprot.readStructBegin()
10510 
    while True:
10511 
      (fname, ftype, fid) = iprot.readFieldBegin()
10512 
      if ftype == TType.STOP:
10513 
        break
10514 
      if fid == 0:
483 rajveer 10515 
        if ftype == TType.LIST:
10516 
          self.success = []
5031 varun.gupt 10517 
          (_etype164, _size161) = iprot.readListBegin()
10518 
          for _i165 in xrange(_size161):
10519 
            _elem166 = LineItem()
10520 
            _elem166.read(iprot)
10521 
            self.success.append(_elem166)
483 rajveer 10522 
          iprot.readListEnd()
94 ashish 10523 
        else:
10524 
          iprot.skip(ftype)
10525 
      elif fid == 1:
10526 
        if ftype == TType.STRUCT:
10527 
          self.ex = TransactionServiceException()
10528 
          self.ex.read(iprot)
10529 
        else:
10530 
          iprot.skip(ftype)
10531 
      else:
10532 
        iprot.skip(ftype)
10533 
      iprot.readFieldEnd()
10534 
    iprot.readStructEnd()
10535 
 
10536 
  def write(self, oprot):
10537 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10538 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10539 
      return
3064 chandransh 10540 
    oprot.writeStructBegin('getLineItemsForOrder_result')
3431 rajveer 10541 
    if self.success is not None:
483 rajveer 10542 
      oprot.writeFieldBegin('success', TType.LIST, 0)
10543 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
5031 varun.gupt 10544 
      for iter167 in self.success:
10545 
        iter167.write(oprot)
483 rajveer 10546 
      oprot.writeListEnd()
94 ashish 10547 
      oprot.writeFieldEnd()
3431 rajveer 10548 
    if self.ex is not None:
94 ashish 10549 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
10550 
      self.ex.write(oprot)
10551 
      oprot.writeFieldEnd()
10552 
    oprot.writeFieldStop()
10553 
    oprot.writeStructEnd()
10554 
 
3431 rajveer 10555 
  def validate(self):
10556 
    return
10557 
 
10558 
 
94 ashish 10559 
  def __repr__(self):
10560 
    L = ['%s=%r' % (key, value)
10561 
      for key, value in self.__dict__.iteritems()]
10562 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10563 
 
10564 
  def __eq__(self, other):
10565 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10566 
 
10567 
  def __ne__(self, other):
10568 
    return not (self == other)
10569 
 
4999 phani.kuma 10570 
class getOrderList_args:
10571 
  """
10572 
  Attributes:
10573 
   - order_ids
10574 
  """
10575 
 
10576 
  thrift_spec = (
10577 
    None, # 0
10578 
    (1, TType.LIST, 'order_ids', (TType.I64,None), None, ), # 1
10579 
  )
10580 
 
10581 
  def __init__(self, order_ids=None,):
10582 
    self.order_ids = order_ids
10583 
 
10584 
  def read(self, iprot):
10585 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10586 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10587 
      return
10588 
    iprot.readStructBegin()
10589 
    while True:
10590 
      (fname, ftype, fid) = iprot.readFieldBegin()
10591 
      if ftype == TType.STOP:
10592 
        break
10593 
      if fid == 1:
10594 
        if ftype == TType.LIST:
10595 
          self.order_ids = []
5031 varun.gupt 10596 
          (_etype171, _size168) = iprot.readListBegin()
10597 
          for _i172 in xrange(_size168):
10598 
            _elem173 = iprot.readI64();
10599 
            self.order_ids.append(_elem173)
4999 phani.kuma 10600 
          iprot.readListEnd()
10601 
        else:
10602 
          iprot.skip(ftype)
10603 
      else:
10604 
        iprot.skip(ftype)
10605 
      iprot.readFieldEnd()
10606 
    iprot.readStructEnd()
10607 
 
10608 
  def write(self, oprot):
10609 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10610 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10611 
      return
10612 
    oprot.writeStructBegin('getOrderList_args')
10613 
    if self.order_ids is not None:
10614 
      oprot.writeFieldBegin('order_ids', TType.LIST, 1)
10615 
      oprot.writeListBegin(TType.I64, len(self.order_ids))
5031 varun.gupt 10616 
      for iter174 in self.order_ids:
10617 
        oprot.writeI64(iter174)
4999 phani.kuma 10618 
      oprot.writeListEnd()
10619 
      oprot.writeFieldEnd()
10620 
    oprot.writeFieldStop()
10621 
    oprot.writeStructEnd()
10622 
 
10623 
  def validate(self):
10624 
    return
10625 
 
10626 
 
10627 
  def __repr__(self):
10628 
    L = ['%s=%r' % (key, value)
10629 
      for key, value in self.__dict__.iteritems()]
10630 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10631 
 
10632 
  def __eq__(self, other):
10633 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10634 
 
10635 
  def __ne__(self, other):
10636 
    return not (self == other)
10637 
 
10638 
class getOrderList_result:
10639 
  """
10640 
  Attributes:
10641 
   - success
10642 
  """
10643 
 
10644 
  thrift_spec = (
10645 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
10646 
  )
10647 
 
10648 
  def __init__(self, success=None,):
10649 
    self.success = success
10650 
 
10651 
  def read(self, iprot):
10652 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10653 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10654 
      return
10655 
    iprot.readStructBegin()
10656 
    while True:
10657 
      (fname, ftype, fid) = iprot.readFieldBegin()
10658 
      if ftype == TType.STOP:
10659 
        break
10660 
      if fid == 0:
10661 
        if ftype == TType.LIST:
10662 
          self.success = []
5031 varun.gupt 10663 
          (_etype178, _size175) = iprot.readListBegin()
10664 
          for _i179 in xrange(_size175):
10665 
            _elem180 = Order()
10666 
            _elem180.read(iprot)
10667 
            self.success.append(_elem180)
4999 phani.kuma 10668 
          iprot.readListEnd()
10669 
        else:
10670 
          iprot.skip(ftype)
10671 
      else:
10672 
        iprot.skip(ftype)
10673 
      iprot.readFieldEnd()
10674 
    iprot.readStructEnd()
10675 
 
10676 
  def write(self, oprot):
10677 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10678 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10679 
      return
10680 
    oprot.writeStructBegin('getOrderList_result')
10681 
    if self.success is not None:
10682 
      oprot.writeFieldBegin('success', TType.LIST, 0)
10683 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
5031 varun.gupt 10684 
      for iter181 in self.success:
10685 
        iter181.write(oprot)
4999 phani.kuma 10686 
      oprot.writeListEnd()
10687 
      oprot.writeFieldEnd()
10688 
    oprot.writeFieldStop()
10689 
    oprot.writeStructEnd()
10690 
 
10691 
  def validate(self):
10692 
    return
10693 
 
10694 
 
10695 
  def __repr__(self):
10696 
    L = ['%s=%r' % (key, value)
10697 
      for key, value in self.__dict__.iteritems()]
10698 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10699 
 
10700 
  def __eq__(self, other):
10701 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10702 
 
10703 
  def __ne__(self, other):
10704 
    return not (self == other)
10705 
 
5386 phani.kuma 10706 
class getOrderListForVendor_args:
10707 
  """
10708 
  Attributes:
10709 
   - order_ids
10710 
   - vendorId
10711 
  """
10712 
 
10713 
  thrift_spec = (
10714 
    None, # 0
10715 
    (1, TType.LIST, 'order_ids', (TType.I64,None), None, ), # 1
10716 
    (2, TType.I64, 'vendorId', None, None, ), # 2
10717 
  )
10718 
 
10719 
  def __init__(self, order_ids=None, vendorId=None,):
10720 
    self.order_ids = order_ids
10721 
    self.vendorId = vendorId
10722 
 
10723 
  def read(self, iprot):
10724 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10725 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10726 
      return
10727 
    iprot.readStructBegin()
10728 
    while True:
10729 
      (fname, ftype, fid) = iprot.readFieldBegin()
10730 
      if ftype == TType.STOP:
10731 
        break
10732 
      if fid == 1:
10733 
        if ftype == TType.LIST:
10734 
          self.order_ids = []
10735 
          (_etype185, _size182) = iprot.readListBegin()
10736 
          for _i186 in xrange(_size182):
10737 
            _elem187 = iprot.readI64();
10738 
            self.order_ids.append(_elem187)
10739 
          iprot.readListEnd()
10740 
        else:
10741 
          iprot.skip(ftype)
10742 
      elif fid == 2:
10743 
        if ftype == TType.I64:
10744 
          self.vendorId = iprot.readI64();
10745 
        else:
10746 
          iprot.skip(ftype)
10747 
      else:
10748 
        iprot.skip(ftype)
10749 
      iprot.readFieldEnd()
10750 
    iprot.readStructEnd()
10751 
 
10752 
  def write(self, oprot):
10753 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10754 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10755 
      return
10756 
    oprot.writeStructBegin('getOrderListForVendor_args')
10757 
    if self.order_ids is not None:
10758 
      oprot.writeFieldBegin('order_ids', TType.LIST, 1)
10759 
      oprot.writeListBegin(TType.I64, len(self.order_ids))
10760 
      for iter188 in self.order_ids:
10761 
        oprot.writeI64(iter188)
10762 
      oprot.writeListEnd()
10763 
      oprot.writeFieldEnd()
10764 
    if self.vendorId is not None:
10765 
      oprot.writeFieldBegin('vendorId', TType.I64, 2)
10766 
      oprot.writeI64(self.vendorId)
10767 
      oprot.writeFieldEnd()
10768 
    oprot.writeFieldStop()
10769 
    oprot.writeStructEnd()
10770 
 
10771 
  def validate(self):
10772 
    return
10773 
 
10774 
 
10775 
  def __repr__(self):
10776 
    L = ['%s=%r' % (key, value)
10777 
      for key, value in self.__dict__.iteritems()]
10778 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10779 
 
10780 
  def __eq__(self, other):
10781 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10782 
 
10783 
  def __ne__(self, other):
10784 
    return not (self == other)
10785 
 
10786 
class getOrderListForVendor_result:
10787 
  """
10788 
  Attributes:
10789 
   - success
10790 
  """
10791 
 
10792 
  thrift_spec = (
10793 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
10794 
  )
10795 
 
10796 
  def __init__(self, success=None,):
10797 
    self.success = success
10798 
 
10799 
  def read(self, iprot):
10800 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10801 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10802 
      return
10803 
    iprot.readStructBegin()
10804 
    while True:
10805 
      (fname, ftype, fid) = iprot.readFieldBegin()
10806 
      if ftype == TType.STOP:
10807 
        break
10808 
      if fid == 0:
10809 
        if ftype == TType.LIST:
10810 
          self.success = []
10811 
          (_etype192, _size189) = iprot.readListBegin()
10812 
          for _i193 in xrange(_size189):
10813 
            _elem194 = Order()
10814 
            _elem194.read(iprot)
10815 
            self.success.append(_elem194)
10816 
          iprot.readListEnd()
10817 
        else:
10818 
          iprot.skip(ftype)
10819 
      else:
10820 
        iprot.skip(ftype)
10821 
      iprot.readFieldEnd()
10822 
    iprot.readStructEnd()
10823 
 
10824 
  def write(self, oprot):
10825 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10826 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10827 
      return
10828 
    oprot.writeStructBegin('getOrderListForVendor_result')
10829 
    if self.success is not None:
10830 
      oprot.writeFieldBegin('success', TType.LIST, 0)
10831 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
10832 
      for iter195 in self.success:
10833 
        iter195.write(oprot)
10834 
      oprot.writeListEnd()
10835 
      oprot.writeFieldEnd()
10836 
    oprot.writeFieldStop()
10837 
    oprot.writeStructEnd()
10838 
 
10839 
  def validate(self):
10840 
    return
10841 
 
10842 
 
10843 
  def __repr__(self):
10844 
    L = ['%s=%r' % (key, value)
10845 
      for key, value in self.__dict__.iteritems()]
10846 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10847 
 
10848 
  def __eq__(self, other):
10849 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10850 
 
10851 
  def __ne__(self, other):
10852 
    return not (self == other)
10853 
 
3064 chandransh 10854 
class getOrderForCustomer_args:
94 ashish 10855 
  """
10856 
  Attributes:
3064 chandransh 10857 
   - orderId
483 rajveer 10858 
   - customerId
94 ashish 10859 
  """
10860 
 
10861 
  thrift_spec = (
10862 
    None, # 0
3064 chandransh 10863 
    (1, TType.I64, 'orderId', None, None, ), # 1
10864 
    (2, TType.I64, 'customerId', None, None, ), # 2
94 ashish 10865 
  )
10866 
 
3064 chandransh 10867 
  def __init__(self, orderId=None, customerId=None,):
10868 
    self.orderId = orderId
483 rajveer 10869 
    self.customerId = customerId
94 ashish 10870 
 
10871 
  def read(self, iprot):
10872 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10873 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10874 
      return
10875 
    iprot.readStructBegin()
10876 
    while True:
10877 
      (fname, ftype, fid) = iprot.readFieldBegin()
10878 
      if ftype == TType.STOP:
10879 
        break
10880 
      if fid == 1:
10881 
        if ftype == TType.I64:
3064 chandransh 10882 
          self.orderId = iprot.readI64();
94 ashish 10883 
        else:
10884 
          iprot.skip(ftype)
10885 
      elif fid == 2:
10886 
        if ftype == TType.I64:
3064 chandransh 10887 
          self.customerId = iprot.readI64();
94 ashish 10888 
        else:
10889 
          iprot.skip(ftype)
10890 
      else:
10891 
        iprot.skip(ftype)
10892 
      iprot.readFieldEnd()
10893 
    iprot.readStructEnd()
10894 
 
10895 
  def write(self, oprot):
10896 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10897 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10898 
      return
3064 chandransh 10899 
    oprot.writeStructBegin('getOrderForCustomer_args')
3431 rajveer 10900 
    if self.orderId is not None:
3064 chandransh 10901 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
10902 
      oprot.writeI64(self.orderId)
10903 
      oprot.writeFieldEnd()
3431 rajveer 10904 
    if self.customerId is not None:
3064 chandransh 10905 
      oprot.writeFieldBegin('customerId', TType.I64, 2)
483 rajveer 10906 
      oprot.writeI64(self.customerId)
94 ashish 10907 
      oprot.writeFieldEnd()
10908 
    oprot.writeFieldStop()
10909 
    oprot.writeStructEnd()
10910 
 
3431 rajveer 10911 
  def validate(self):
10912 
    return
10913 
 
10914 
 
94 ashish 10915 
  def __repr__(self):
10916 
    L = ['%s=%r' % (key, value)
10917 
      for key, value in self.__dict__.iteritems()]
10918 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10919 
 
10920 
  def __eq__(self, other):
10921 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10922 
 
10923 
  def __ne__(self, other):
10924 
    return not (self == other)
10925 
 
3064 chandransh 10926 
class getOrderForCustomer_result:
94 ashish 10927 
  """
10928 
  Attributes:
10929 
   - success
10930 
   - ex
10931 
  """
10932 
 
10933 
  thrift_spec = (
3064 chandransh 10934 
    (0, TType.STRUCT, 'success', (Order, Order.thrift_spec), None, ), # 0
94 ashish 10935 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
10936 
  )
10937 
 
10938 
  def __init__(self, success=None, ex=None,):
10939 
    self.success = success
10940 
    self.ex = ex
10941 
 
10942 
  def read(self, iprot):
10943 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10944 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10945 
      return
10946 
    iprot.readStructBegin()
10947 
    while True:
10948 
      (fname, ftype, fid) = iprot.readFieldBegin()
10949 
      if ftype == TType.STOP:
10950 
        break
10951 
      if fid == 0:
3064 chandransh 10952 
        if ftype == TType.STRUCT:
10953 
          self.success = Order()
10954 
          self.success.read(iprot)
94 ashish 10955 
        else:
10956 
          iprot.skip(ftype)
10957 
      elif fid == 1:
10958 
        if ftype == TType.STRUCT:
10959 
          self.ex = TransactionServiceException()
10960 
          self.ex.read(iprot)
10961 
        else:
10962 
          iprot.skip(ftype)
10963 
      else:
10964 
        iprot.skip(ftype)
10965 
      iprot.readFieldEnd()
10966 
    iprot.readStructEnd()
10967 
 
10968 
  def write(self, oprot):
10969 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10970 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10971 
      return
3064 chandransh 10972 
    oprot.writeStructBegin('getOrderForCustomer_result')
3431 rajveer 10973 
    if self.success is not None:
3064 chandransh 10974 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
10975 
      self.success.write(oprot)
94 ashish 10976 
      oprot.writeFieldEnd()
3431 rajveer 10977 
    if self.ex is not None:
94 ashish 10978 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
10979 
      self.ex.write(oprot)
10980 
      oprot.writeFieldEnd()
10981 
    oprot.writeFieldStop()
10982 
    oprot.writeStructEnd()
10983 
 
3431 rajveer 10984 
  def validate(self):
10985 
    return
10986 
 
10987 
 
94 ashish 10988 
  def __repr__(self):
10989 
    L = ['%s=%r' % (key, value)
10990 
      for key, value in self.__dict__.iteritems()]
10991 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10992 
 
10993 
  def __eq__(self, other):
10994 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10995 
 
10996 
  def __ne__(self, other):
10997 
    return not (self == other)
10998 
 
3064 chandransh 10999 
class getAlerts_args:
94 ashish 11000 
  """
11001 
  Attributes:
4394 rajveer 11002 
   - type
4444 rajveer 11003 
   - warehouseId
4394 rajveer 11004 
   - status
11005 
   - timestamp
94 ashish 11006 
  """
11007 
 
11008 
  thrift_spec = (
11009 
    None, # 0
4394 rajveer 11010 
    (1, TType.I64, 'type', None, None, ), # 1
4444 rajveer 11011 
    (2, TType.I64, 'warehouseId', None, None, ), # 2
11012 
    (3, TType.I64, 'status', None, None, ), # 3
11013 
    (4, TType.I64, 'timestamp', None, None, ), # 4
94 ashish 11014 
  )
11015 
 
4444 rajveer 11016 
  def __init__(self, type=None, warehouseId=None, status=None, timestamp=None,):
4394 rajveer 11017 
    self.type = type
4444 rajveer 11018 
    self.warehouseId = warehouseId
4394 rajveer 11019 
    self.status = status
11020 
    self.timestamp = timestamp
94 ashish 11021 
 
11022 
  def read(self, iprot):
11023 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11024 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11025 
      return
11026 
    iprot.readStructBegin()
11027 
    while True:
11028 
      (fname, ftype, fid) = iprot.readFieldBegin()
11029 
      if ftype == TType.STOP:
11030 
        break
11031 
      if fid == 1:
3064 chandransh 11032 
        if ftype == TType.I64:
4394 rajveer 11033 
          self.type = iprot.readI64();
94 ashish 11034 
        else:
11035 
          iprot.skip(ftype)
3064 chandransh 11036 
      elif fid == 2:
4394 rajveer 11037 
        if ftype == TType.I64:
4444 rajveer 11038 
          self.warehouseId = iprot.readI64();
3064 chandransh 11039 
        else:
11040 
          iprot.skip(ftype)
4394 rajveer 11041 
      elif fid == 3:
11042 
        if ftype == TType.I64:
4444 rajveer 11043 
          self.status = iprot.readI64();
11044 
        else:
11045 
          iprot.skip(ftype)
11046 
      elif fid == 4:
11047 
        if ftype == TType.I64:
4394 rajveer 11048 
          self.timestamp = iprot.readI64();
11049 
        else:
11050 
          iprot.skip(ftype)
94 ashish 11051 
      else:
11052 
        iprot.skip(ftype)
11053 
      iprot.readFieldEnd()
11054 
    iprot.readStructEnd()
11055 
 
11056 
  def write(self, oprot):
11057 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11058 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11059 
      return
3064 chandransh 11060 
    oprot.writeStructBegin('getAlerts_args')
4394 rajveer 11061 
    if self.type is not None:
11062 
      oprot.writeFieldBegin('type', TType.I64, 1)
11063 
      oprot.writeI64(self.type)
94 ashish 11064 
      oprot.writeFieldEnd()
4444 rajveer 11065 
    if self.warehouseId is not None:
11066 
      oprot.writeFieldBegin('warehouseId', TType.I64, 2)
11067 
      oprot.writeI64(self.warehouseId)
11068 
      oprot.writeFieldEnd()
4394 rajveer 11069 
    if self.status is not None:
4444 rajveer 11070 
      oprot.writeFieldBegin('status', TType.I64, 3)
4394 rajveer 11071 
      oprot.writeI64(self.status)
3064 chandransh 11072 
      oprot.writeFieldEnd()
4394 rajveer 11073 
    if self.timestamp is not None:
4444 rajveer 11074 
      oprot.writeFieldBegin('timestamp', TType.I64, 4)
4394 rajveer 11075 
      oprot.writeI64(self.timestamp)
11076 
      oprot.writeFieldEnd()
94 ashish 11077 
    oprot.writeFieldStop()
11078 
    oprot.writeStructEnd()
11079 
 
3431 rajveer 11080 
  def validate(self):
11081 
    return
11082 
 
11083 
 
94 ashish 11084 
  def __repr__(self):
11085 
    L = ['%s=%r' % (key, value)
11086 
      for key, value in self.__dict__.iteritems()]
11087 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11088 
 
11089 
  def __eq__(self, other):
11090 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11091 
 
11092 
  def __ne__(self, other):
11093 
    return not (self == other)
11094 
 
3064 chandransh 11095 
class getAlerts_result:
94 ashish 11096 
  """
11097 
  Attributes:
11098 
   - success
11099 
  """
11100 
 
11101 
  thrift_spec = (
3064 chandransh 11102 
    (0, TType.LIST, 'success', (TType.STRUCT,(Alert, Alert.thrift_spec)), None, ), # 0
94 ashish 11103 
  )
11104 
 
3064 chandransh 11105 
  def __init__(self, success=None,):
94 ashish 11106 
    self.success = success
11107 
 
11108 
  def read(self, iprot):
11109 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11110 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11111 
      return
11112 
    iprot.readStructBegin()
11113 
    while True:
11114 
      (fname, ftype, fid) = iprot.readFieldBegin()
11115 
      if ftype == TType.STOP:
11116 
        break
11117 
      if fid == 0:
3064 chandransh 11118 
        if ftype == TType.LIST:
11119 
          self.success = []
5386 phani.kuma 11120 
          (_etype199, _size196) = iprot.readListBegin()
11121 
          for _i200 in xrange(_size196):
11122 
            _elem201 = Alert()
11123 
            _elem201.read(iprot)
11124 
            self.success.append(_elem201)
3064 chandransh 11125 
          iprot.readListEnd()
94 ashish 11126 
        else:
11127 
          iprot.skip(ftype)
11128 
      else:
11129 
        iprot.skip(ftype)
11130 
      iprot.readFieldEnd()
11131 
    iprot.readStructEnd()
11132 
 
11133 
  def write(self, oprot):
11134 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11135 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11136 
      return
3064 chandransh 11137 
    oprot.writeStructBegin('getAlerts_result')
3431 rajveer 11138 
    if self.success is not None:
3064 chandransh 11139 
      oprot.writeFieldBegin('success', TType.LIST, 0)
11140 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
5386 phani.kuma 11141 
      for iter202 in self.success:
11142 
        iter202.write(oprot)
3064 chandransh 11143 
      oprot.writeListEnd()
94 ashish 11144 
      oprot.writeFieldEnd()
11145 
    oprot.writeFieldStop()
11146 
    oprot.writeStructEnd()
11147 
 
3431 rajveer 11148 
  def validate(self):
11149 
    return
11150 
 
11151 
 
94 ashish 11152 
  def __repr__(self):
11153 
    L = ['%s=%r' % (key, value)
11154 
      for key, value in self.__dict__.iteritems()]
11155 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11156 
 
11157 
  def __eq__(self, other):
11158 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11159 
 
11160 
  def __ne__(self, other):
11161 
    return not (self == other)
11162 
 
4394 rajveer 11163 
class addAlert_args:
94 ashish 11164 
  """
11165 
  Attributes:
3064 chandransh 11166 
   - type
4444 rajveer 11167 
   - warehouseId
4394 rajveer 11168 
   - description
94 ashish 11169 
  """
11170 
 
11171 
  thrift_spec = (
11172 
    None, # 0
4394 rajveer 11173 
    (1, TType.I64, 'type', None, None, ), # 1
4444 rajveer 11174 
    (2, TType.I64, 'warehouseId', None, None, ), # 2
11175 
    (3, TType.STRING, 'description', None, None, ), # 3
94 ashish 11176 
  )
11177 
 
4444 rajveer 11178 
  def __init__(self, type=None, warehouseId=None, description=None,):
3064 chandransh 11179 
    self.type = type
4444 rajveer 11180 
    self.warehouseId = warehouseId
4394 rajveer 11181 
    self.description = description
94 ashish 11182 
 
11183 
  def read(self, iprot):
11184 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11185 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11186 
      return
11187 
    iprot.readStructBegin()
11188 
    while True:
11189 
      (fname, ftype, fid) = iprot.readFieldBegin()
11190 
      if ftype == TType.STOP:
11191 
        break
11192 
      if fid == 1:
11193 
        if ftype == TType.I64:
4394 rajveer 11194 
          self.type = iprot.readI64();
94 ashish 11195 
        else:
11196 
          iprot.skip(ftype)
3064 chandransh 11197 
      elif fid == 2:
4444 rajveer 11198 
        if ftype == TType.I64:
11199 
          self.warehouseId = iprot.readI64();
11200 
        else:
11201 
          iprot.skip(ftype)
11202 
      elif fid == 3:
3064 chandransh 11203 
        if ftype == TType.STRING:
4394 rajveer 11204 
          self.description = iprot.readString();
3064 chandransh 11205 
        else:
11206 
          iprot.skip(ftype)
94 ashish 11207 
      else:
11208 
        iprot.skip(ftype)
11209 
      iprot.readFieldEnd()
11210 
    iprot.readStructEnd()
11211 
 
11212 
  def write(self, oprot):
11213 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11214 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11215 
      return
4394 rajveer 11216 
    oprot.writeStructBegin('addAlert_args')
3431 rajveer 11217 
    if self.type is not None:
4394 rajveer 11218 
      oprot.writeFieldBegin('type', TType.I64, 1)
3064 chandransh 11219 
      oprot.writeI64(self.type)
11220 
      oprot.writeFieldEnd()
4444 rajveer 11221 
    if self.warehouseId is not None:
11222 
      oprot.writeFieldBegin('warehouseId', TType.I64, 2)
11223 
      oprot.writeI64(self.warehouseId)
11224 
      oprot.writeFieldEnd()
4394 rajveer 11225 
    if self.description is not None:
4444 rajveer 11226 
      oprot.writeFieldBegin('description', TType.STRING, 3)
4394 rajveer 11227 
      oprot.writeString(self.description)
3064 chandransh 11228 
      oprot.writeFieldEnd()
94 ashish 11229 
    oprot.writeFieldStop()
11230 
    oprot.writeStructEnd()
11231 
 
3431 rajveer 11232 
  def validate(self):
11233 
    return
11234 
 
11235 
 
94 ashish 11236 
  def __repr__(self):
11237 
    L = ['%s=%r' % (key, value)
11238 
      for key, value in self.__dict__.iteritems()]
11239 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11240 
 
11241 
  def __eq__(self, other):
11242 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11243 
 
11244 
  def __ne__(self, other):
11245 
    return not (self == other)
11246 
 
4394 rajveer 11247 
class addAlert_result:
3064 chandransh 11248 
 
11249 
  thrift_spec = (
11250 
  )
11251 
 
11252 
  def read(self, iprot):
11253 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11254 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11255 
      return
11256 
    iprot.readStructBegin()
11257 
    while True:
11258 
      (fname, ftype, fid) = iprot.readFieldBegin()
11259 
      if ftype == TType.STOP:
11260 
        break
11261 
      else:
11262 
        iprot.skip(ftype)
11263 
      iprot.readFieldEnd()
11264 
    iprot.readStructEnd()
11265 
 
11266 
  def write(self, oprot):
11267 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11268 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11269 
      return
4394 rajveer 11270 
    oprot.writeStructBegin('addAlert_result')
3064 chandransh 11271 
    oprot.writeFieldStop()
11272 
    oprot.writeStructEnd()
11273 
 
3431 rajveer 11274 
  def validate(self):
11275 
    return
11276 
 
11277 
 
3064 chandransh 11278 
  def __repr__(self):
11279 
    L = ['%s=%r' % (key, value)
11280 
      for key, value in self.__dict__.iteritems()]
11281 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11282 
 
11283 
  def __eq__(self, other):
11284 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11285 
 
11286 
  def __ne__(self, other):
11287 
    return not (self == other)
11288 
 
4444 rajveer 11289 
class markAlertsAsSeen_args:
11290 
  """
11291 
  Attributes:
11292 
   - warehouseId
11293 
  """
11294 
 
11295 
  thrift_spec = (
11296 
    None, # 0
11297 
    (1, TType.I64, 'warehouseId', None, None, ), # 1
11298 
  )
11299 
 
11300 
  def __init__(self, warehouseId=None,):
11301 
    self.warehouseId = warehouseId
11302 
 
11303 
  def read(self, iprot):
11304 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11305 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11306 
      return
11307 
    iprot.readStructBegin()
11308 
    while True:
11309 
      (fname, ftype, fid) = iprot.readFieldBegin()
11310 
      if ftype == TType.STOP:
11311 
        break
11312 
      if fid == 1:
11313 
        if ftype == TType.I64:
11314 
          self.warehouseId = iprot.readI64();
11315 
        else:
11316 
          iprot.skip(ftype)
11317 
      else:
11318 
        iprot.skip(ftype)
11319 
      iprot.readFieldEnd()
11320 
    iprot.readStructEnd()
11321 
 
11322 
  def write(self, oprot):
11323 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11324 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11325 
      return
11326 
    oprot.writeStructBegin('markAlertsAsSeen_args')
11327 
    if self.warehouseId is not None:
11328 
      oprot.writeFieldBegin('warehouseId', TType.I64, 1)
11329 
      oprot.writeI64(self.warehouseId)
11330 
      oprot.writeFieldEnd()
11331 
    oprot.writeFieldStop()
11332 
    oprot.writeStructEnd()
11333 
 
11334 
  def validate(self):
11335 
    return
11336 
 
11337 
 
11338 
  def __repr__(self):
11339 
    L = ['%s=%r' % (key, value)
11340 
      for key, value in self.__dict__.iteritems()]
11341 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11342 
 
11343 
  def __eq__(self, other):
11344 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11345 
 
11346 
  def __ne__(self, other):
11347 
    return not (self == other)
11348 
 
11349 
class markAlertsAsSeen_result:
11350 
 
11351 
  thrift_spec = (
11352 
  )
11353 
 
11354 
  def read(self, iprot):
11355 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11356 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11357 
      return
11358 
    iprot.readStructBegin()
11359 
    while True:
11360 
      (fname, ftype, fid) = iprot.readFieldBegin()
11361 
      if ftype == TType.STOP:
11362 
        break
11363 
      else:
11364 
        iprot.skip(ftype)
11365 
      iprot.readFieldEnd()
11366 
    iprot.readStructEnd()
11367 
 
11368 
  def write(self, oprot):
11369 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11370 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11371 
      return
11372 
    oprot.writeStructBegin('markAlertsAsSeen_result')
11373 
    oprot.writeFieldStop()
11374 
    oprot.writeStructEnd()
11375 
 
11376 
  def validate(self):
11377 
    return
11378 
 
11379 
 
11380 
  def __repr__(self):
11381 
    L = ['%s=%r' % (key, value)
11382 
      for key, value in self.__dict__.iteritems()]
11383 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11384 
 
11385 
  def __eq__(self, other):
11386 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11387 
 
11388 
  def __ne__(self, other):
11389 
    return not (self == other)
11390 
 
3064 chandransh 11391 
class getValidOrderCount_args:
11392 
 
11393 
  thrift_spec = (
11394 
  )
11395 
 
11396 
  def read(self, iprot):
11397 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11398 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11399 
      return
11400 
    iprot.readStructBegin()
11401 
    while True:
11402 
      (fname, ftype, fid) = iprot.readFieldBegin()
11403 
      if ftype == TType.STOP:
11404 
        break
11405 
      else:
11406 
        iprot.skip(ftype)
11407 
      iprot.readFieldEnd()
11408 
    iprot.readStructEnd()
11409 
 
11410 
  def write(self, oprot):
11411 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11412 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11413 
      return
11414 
    oprot.writeStructBegin('getValidOrderCount_args')
11415 
    oprot.writeFieldStop()
11416 
    oprot.writeStructEnd()
11417 
 
3431 rajveer 11418 
  def validate(self):
11419 
    return
11420 
 
11421 
 
3064 chandransh 11422 
  def __repr__(self):
11423 
    L = ['%s=%r' % (key, value)
11424 
      for key, value in self.__dict__.iteritems()]
11425 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11426 
 
11427 
  def __eq__(self, other):
11428 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11429 
 
11430 
  def __ne__(self, other):
11431 
    return not (self == other)
11432 
 
11433 
class getValidOrderCount_result:
94 ashish 11434 
  """
11435 
  Attributes:
11436 
   - success
11437 
  """
11438 
 
11439 
  thrift_spec = (
3064 chandransh 11440 
    (0, TType.I64, 'success', None, None, ), # 0
94 ashish 11441 
  )
11442 
 
3064 chandransh 11443 
  def __init__(self, success=None,):
94 ashish 11444 
    self.success = success
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 == 0:
3064 chandransh 11456 
        if ftype == TType.I64:
11457 
          self.success = iprot.readI64();
94 ashish 11458 
        else:
11459 
          iprot.skip(ftype)
11460 
      else:
11461 
        iprot.skip(ftype)
11462 
      iprot.readFieldEnd()
11463 
    iprot.readStructEnd()
11464 
 
11465 
  def write(self, oprot):
11466 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11467 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11468 
      return
3064 chandransh 11469 
    oprot.writeStructBegin('getValidOrderCount_result')
3431 rajveer 11470 
    if self.success is not None:
3064 chandransh 11471 
      oprot.writeFieldBegin('success', TType.I64, 0)
11472 
      oprot.writeI64(self.success)
94 ashish 11473 
      oprot.writeFieldEnd()
11474 
    oprot.writeFieldStop()
11475 
    oprot.writeStructEnd()
11476 
 
3431 rajveer 11477 
  def validate(self):
11478 
    return
11479 
 
11480 
 
94 ashish 11481 
  def __repr__(self):
11482 
    L = ['%s=%r' % (key, value)
11483 
      for key, value in self.__dict__.iteritems()]
11484 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11485 
 
11486 
  def __eq__(self, other):
11487 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11488 
 
11489 
  def __ne__(self, other):
11490 
    return not (self == other)
11491 
 
3064 chandransh 11492 
class getNoOfCustomersWithSuccessfulTransaction_args:
11493 
 
11494 
  thrift_spec = (
11495 
  )
11496 
 
11497 
  def read(self, iprot):
11498 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11499 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11500 
      return
11501 
    iprot.readStructBegin()
11502 
    while True:
11503 
      (fname, ftype, fid) = iprot.readFieldBegin()
11504 
      if ftype == TType.STOP:
11505 
        break
11506 
      else:
11507 
        iprot.skip(ftype)
11508 
      iprot.readFieldEnd()
11509 
    iprot.readStructEnd()
11510 
 
11511 
  def write(self, oprot):
11512 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11513 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11514 
      return
11515 
    oprot.writeStructBegin('getNoOfCustomersWithSuccessfulTransaction_args')
11516 
    oprot.writeFieldStop()
11517 
    oprot.writeStructEnd()
11518 
 
3431 rajveer 11519 
  def validate(self):
11520 
    return
11521 
 
11522 
 
3064 chandransh 11523 
  def __repr__(self):
11524 
    L = ['%s=%r' % (key, value)
11525 
      for key, value in self.__dict__.iteritems()]
11526 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11527 
 
11528 
  def __eq__(self, other):
11529 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11530 
 
11531 
  def __ne__(self, other):
11532 
    return not (self == other)
11533 
 
11534 
class getNoOfCustomersWithSuccessfulTransaction_result:
94 ashish 11535 
  """
11536 
  Attributes:
3064 chandransh 11537 
   - success
94 ashish 11538 
  """
11539 
 
11540 
  thrift_spec = (
3064 chandransh 11541 
    (0, TType.I64, 'success', None, None, ), # 0
94 ashish 11542 
  )
11543 
 
3064 chandransh 11544 
  def __init__(self, success=None,):
11545 
    self.success = success
94 ashish 11546 
 
11547 
  def read(self, iprot):
11548 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11549 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11550 
      return
11551 
    iprot.readStructBegin()
11552 
    while True:
11553 
      (fname, ftype, fid) = iprot.readFieldBegin()
11554 
      if ftype == TType.STOP:
11555 
        break
3064 chandransh 11556 
      if fid == 0:
94 ashish 11557 
        if ftype == TType.I64:
3064 chandransh 11558 
          self.success = iprot.readI64();
94 ashish 11559 
        else:
11560 
          iprot.skip(ftype)
11561 
      else:
11562 
        iprot.skip(ftype)
11563 
      iprot.readFieldEnd()
11564 
    iprot.readStructEnd()
11565 
 
11566 
  def write(self, oprot):
11567 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11568 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11569 
      return
3064 chandransh 11570 
    oprot.writeStructBegin('getNoOfCustomersWithSuccessfulTransaction_result')
3431 rajveer 11571 
    if self.success is not None:
3064 chandransh 11572 
      oprot.writeFieldBegin('success', TType.I64, 0)
11573 
      oprot.writeI64(self.success)
94 ashish 11574 
      oprot.writeFieldEnd()
11575 
    oprot.writeFieldStop()
11576 
    oprot.writeStructEnd()
11577 
 
3431 rajveer 11578 
  def validate(self):
11579 
    return
11580 
 
11581 
 
94 ashish 11582 
  def __repr__(self):
11583 
    L = ['%s=%r' % (key, value)
11584 
      for key, value in self.__dict__.iteritems()]
11585 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11586 
 
11587 
  def __eq__(self, other):
11588 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11589 
 
11590 
  def __ne__(self, other):
11591 
    return not (self == other)
11592 
 
3064 chandransh 11593 
class getValidOrdersAmountRange_args:
11594 
 
11595 
  thrift_spec = (
11596 
  )
11597 
 
11598 
  def read(self, iprot):
11599 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11600 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11601 
      return
11602 
    iprot.readStructBegin()
11603 
    while True:
11604 
      (fname, ftype, fid) = iprot.readFieldBegin()
11605 
      if ftype == TType.STOP:
11606 
        break
11607 
      else:
11608 
        iprot.skip(ftype)
11609 
      iprot.readFieldEnd()
11610 
    iprot.readStructEnd()
11611 
 
11612 
  def write(self, oprot):
11613 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11614 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11615 
      return
11616 
    oprot.writeStructBegin('getValidOrdersAmountRange_args')
11617 
    oprot.writeFieldStop()
11618 
    oprot.writeStructEnd()
11619 
 
3431 rajveer 11620 
  def validate(self):
11621 
    return
11622 
 
11623 
 
3064 chandransh 11624 
  def __repr__(self):
11625 
    L = ['%s=%r' % (key, value)
11626 
      for key, value in self.__dict__.iteritems()]
11627 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11628 
 
11629 
  def __eq__(self, other):
11630 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11631 
 
11632 
  def __ne__(self, other):
11633 
    return not (self == other)
11634 
 
11635 
class getValidOrdersAmountRange_result:
94 ashish 11636 
  """
11637 
  Attributes:
11638 
   - success
11639 
  """
11640 
 
11641 
  thrift_spec = (
3064 chandransh 11642 
    (0, TType.LIST, 'success', (TType.DOUBLE,None), None, ), # 0
94 ashish 11643 
  )
11644 
 
3064 chandransh 11645 
  def __init__(self, success=None,):
94 ashish 11646 
    self.success = success
11647 
 
11648 
  def read(self, iprot):
11649 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11650 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11651 
      return
11652 
    iprot.readStructBegin()
11653 
    while True:
11654 
      (fname, ftype, fid) = iprot.readFieldBegin()
11655 
      if ftype == TType.STOP:
11656 
        break
11657 
      if fid == 0:
483 rajveer 11658 
        if ftype == TType.LIST:
11659 
          self.success = []
5386 phani.kuma 11660 
          (_etype206, _size203) = iprot.readListBegin()
11661 
          for _i207 in xrange(_size203):
11662 
            _elem208 = iprot.readDouble();
11663 
            self.success.append(_elem208)
483 rajveer 11664 
          iprot.readListEnd()
94 ashish 11665 
        else:
11666 
          iprot.skip(ftype)
11667 
      else:
11668 
        iprot.skip(ftype)
11669 
      iprot.readFieldEnd()
11670 
    iprot.readStructEnd()
11671 
 
11672 
  def write(self, oprot):
11673 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11674 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11675 
      return
3064 chandransh 11676 
    oprot.writeStructBegin('getValidOrdersAmountRange_result')
3431 rajveer 11677 
    if self.success is not None:
483 rajveer 11678 
      oprot.writeFieldBegin('success', TType.LIST, 0)
3064 chandransh 11679 
      oprot.writeListBegin(TType.DOUBLE, len(self.success))
5386 phani.kuma 11680 
      for iter209 in self.success:
11681 
        oprot.writeDouble(iter209)
483 rajveer 11682 
      oprot.writeListEnd()
94 ashish 11683 
      oprot.writeFieldEnd()
11684 
    oprot.writeFieldStop()
11685 
    oprot.writeStructEnd()
11686 
 
3431 rajveer 11687 
  def validate(self):
11688 
    return
11689 
 
11690 
 
94 ashish 11691 
  def __repr__(self):
11692 
    L = ['%s=%r' % (key, value)
11693 
      for key, value in self.__dict__.iteritems()]
11694 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11695 
 
11696 
  def __eq__(self, other):
11697 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11698 
 
11699 
  def __ne__(self, other):
11700 
    return not (self == other)
11701 
 
3064 chandransh 11702 
class getValidOrders_args:
1528 ankur.sing 11703 
  """
11704 
  Attributes:
3064 chandransh 11705 
   - limit
5874 rajveer 11706 
   - onlyStore
1528 ankur.sing 11707 
  """
11708 
 
11709 
  thrift_spec = (
11710 
    None, # 0
3064 chandransh 11711 
    (1, TType.I64, 'limit', None, None, ), # 1
5874 rajveer 11712 
    (2, TType.BOOL, 'onlyStore', None, None, ), # 2
1528 ankur.sing 11713 
  )
11714 
 
5874 rajveer 11715 
  def __init__(self, limit=None, onlyStore=None,):
3064 chandransh 11716 
    self.limit = limit
5874 rajveer 11717 
    self.onlyStore = onlyStore
1528 ankur.sing 11718 
 
11719 
  def read(self, iprot):
11720 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11721 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11722 
      return
11723 
    iprot.readStructBegin()
11724 
    while True:
11725 
      (fname, ftype, fid) = iprot.readFieldBegin()
11726 
      if ftype == TType.STOP:
11727 
        break
11728 
      if fid == 1:
11729 
        if ftype == TType.I64:
3064 chandransh 11730 
          self.limit = iprot.readI64();
1528 ankur.sing 11731 
        else:
11732 
          iprot.skip(ftype)
5874 rajveer 11733 
      elif fid == 2:
11734 
        if ftype == TType.BOOL:
11735 
          self.onlyStore = iprot.readBool();
11736 
        else:
11737 
          iprot.skip(ftype)
1528 ankur.sing 11738 
      else:
11739 
        iprot.skip(ftype)
11740 
      iprot.readFieldEnd()
11741 
    iprot.readStructEnd()
11742 
 
11743 
  def write(self, oprot):
11744 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11745 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11746 
      return
3064 chandransh 11747 
    oprot.writeStructBegin('getValidOrders_args')
3431 rajveer 11748 
    if self.limit is not None:
3064 chandransh 11749 
      oprot.writeFieldBegin('limit', TType.I64, 1)
11750 
      oprot.writeI64(self.limit)
1528 ankur.sing 11751 
      oprot.writeFieldEnd()
5874 rajveer 11752 
    if self.onlyStore is not None:
11753 
      oprot.writeFieldBegin('onlyStore', TType.BOOL, 2)
11754 
      oprot.writeBool(self.onlyStore)
11755 
      oprot.writeFieldEnd()
1528 ankur.sing 11756 
    oprot.writeFieldStop()
11757 
    oprot.writeStructEnd()
11758 
 
3431 rajveer 11759 
  def validate(self):
11760 
    return
11761 
 
11762 
 
1528 ankur.sing 11763 
  def __repr__(self):
11764 
    L = ['%s=%r' % (key, value)
11765 
      for key, value in self.__dict__.iteritems()]
11766 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11767 
 
11768 
  def __eq__(self, other):
11769 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11770 
 
11771 
  def __ne__(self, other):
11772 
    return not (self == other)
11773 
 
3064 chandransh 11774 
class getValidOrders_result:
1528 ankur.sing 11775 
  """
11776 
  Attributes:
11777 
   - success
11778 
  """
11779 
 
11780 
  thrift_spec = (
3064 chandransh 11781 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
1528 ankur.sing 11782 
  )
11783 
 
3064 chandransh 11784 
  def __init__(self, success=None,):
1528 ankur.sing 11785 
    self.success = success
11786 
 
11787 
  def read(self, iprot):
11788 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11789 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11790 
      return
11791 
    iprot.readStructBegin()
11792 
    while True:
11793 
      (fname, ftype, fid) = iprot.readFieldBegin()
11794 
      if ftype == TType.STOP:
11795 
        break
11796 
      if fid == 0:
3064 chandransh 11797 
        if ftype == TType.LIST:
11798 
          self.success = []
5386 phani.kuma 11799 
          (_etype213, _size210) = iprot.readListBegin()
11800 
          for _i214 in xrange(_size210):
11801 
            _elem215 = Order()
11802 
            _elem215.read(iprot)
11803 
            self.success.append(_elem215)
3064 chandransh 11804 
          iprot.readListEnd()
1528 ankur.sing 11805 
        else:
11806 
          iprot.skip(ftype)
11807 
      else:
11808 
        iprot.skip(ftype)
11809 
      iprot.readFieldEnd()
11810 
    iprot.readStructEnd()
11811 
 
11812 
  def write(self, oprot):
11813 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11814 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11815 
      return
3064 chandransh 11816 
    oprot.writeStructBegin('getValidOrders_result')
3431 rajveer 11817 
    if self.success is not None:
3064 chandransh 11818 
      oprot.writeFieldBegin('success', TType.LIST, 0)
11819 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
5386 phani.kuma 11820 
      for iter216 in self.success:
11821 
        iter216.write(oprot)
3064 chandransh 11822 
      oprot.writeListEnd()
1528 ankur.sing 11823 
      oprot.writeFieldEnd()
11824 
    oprot.writeFieldStop()
11825 
    oprot.writeStructEnd()
11826 
 
3431 rajveer 11827 
  def validate(self):
11828 
    return
11829 
 
11830 
 
1528 ankur.sing 11831 
  def __repr__(self):
11832 
    L = ['%s=%r' % (key, value)
11833 
      for key, value in self.__dict__.iteritems()]
11834 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11835 
 
11836 
  def __eq__(self, other):
11837 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11838 
 
11839 
  def __ne__(self, other):
11840 
    return not (self == other)
11841 
 
1220 chandransh 11842 
class batchOrders_args:
11843 
  """
11844 
  Attributes:
11845 
   - warehouseId
11846 
  """
11847 
 
11848 
  thrift_spec = (
11849 
    None, # 0
11850 
    (1, TType.I64, 'warehouseId', None, None, ), # 1
11851 
  )
11852 
 
11853 
  def __init__(self, warehouseId=None,):
11854 
    self.warehouseId = warehouseId
11855 
 
11856 
  def read(self, iprot):
11857 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11858 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11859 
      return
11860 
    iprot.readStructBegin()
11861 
    while True:
11862 
      (fname, ftype, fid) = iprot.readFieldBegin()
11863 
      if ftype == TType.STOP:
11864 
        break
11865 
      if fid == 1:
11866 
        if ftype == TType.I64:
11867 
          self.warehouseId = iprot.readI64();
11868 
        else:
11869 
          iprot.skip(ftype)
11870 
      else:
11871 
        iprot.skip(ftype)
11872 
      iprot.readFieldEnd()
11873 
    iprot.readStructEnd()
11874 
 
11875 
  def write(self, oprot):
11876 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11877 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11878 
      return
11879 
    oprot.writeStructBegin('batchOrders_args')
3431 rajveer 11880 
    if self.warehouseId is not None:
1220 chandransh 11881 
      oprot.writeFieldBegin('warehouseId', TType.I64, 1)
11882 
      oprot.writeI64(self.warehouseId)
11883 
      oprot.writeFieldEnd()
11884 
    oprot.writeFieldStop()
11885 
    oprot.writeStructEnd()
11886 
 
3431 rajveer 11887 
  def validate(self):
11888 
    return
11889 
 
11890 
 
1220 chandransh 11891 
  def __repr__(self):
11892 
    L = ['%s=%r' % (key, value)
11893 
      for key, value in self.__dict__.iteritems()]
11894 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11895 
 
11896 
  def __eq__(self, other):
11897 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11898 
 
11899 
  def __ne__(self, other):
11900 
    return not (self == other)
11901 
 
11902 
class batchOrders_result:
11903 
  """
11904 
  Attributes:
11905 
   - success
11906 
   - ex
11907 
  """
11908 
 
11909 
  thrift_spec = (
11910 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
11911 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
11912 
  )
11913 
 
11914 
  def __init__(self, success=None, ex=None,):
11915 
    self.success = success
11916 
    self.ex = ex
11917 
 
11918 
  def read(self, iprot):
11919 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11920 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11921 
      return
11922 
    iprot.readStructBegin()
11923 
    while True:
11924 
      (fname, ftype, fid) = iprot.readFieldBegin()
11925 
      if ftype == TType.STOP:
11926 
        break
11927 
      if fid == 0:
11928 
        if ftype == TType.LIST:
11929 
          self.success = []
5386 phani.kuma 11930 
          (_etype220, _size217) = iprot.readListBegin()
11931 
          for _i221 in xrange(_size217):
11932 
            _elem222 = Order()
11933 
            _elem222.read(iprot)
11934 
            self.success.append(_elem222)
1220 chandransh 11935 
          iprot.readListEnd()
11936 
        else:
11937 
          iprot.skip(ftype)
11938 
      elif fid == 1:
11939 
        if ftype == TType.STRUCT:
11940 
          self.ex = TransactionServiceException()
11941 
          self.ex.read(iprot)
11942 
        else:
11943 
          iprot.skip(ftype)
11944 
      else:
11945 
        iprot.skip(ftype)
11946 
      iprot.readFieldEnd()
11947 
    iprot.readStructEnd()
11948 
 
11949 
  def write(self, oprot):
11950 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11951 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11952 
      return
11953 
    oprot.writeStructBegin('batchOrders_result')
3431 rajveer 11954 
    if self.success is not None:
1220 chandransh 11955 
      oprot.writeFieldBegin('success', TType.LIST, 0)
11956 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
5386 phani.kuma 11957 
      for iter223 in self.success:
11958 
        iter223.write(oprot)
1220 chandransh 11959 
      oprot.writeListEnd()
11960 
      oprot.writeFieldEnd()
3431 rajveer 11961 
    if self.ex is not None:
1220 chandransh 11962 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
11963 
      self.ex.write(oprot)
11964 
      oprot.writeFieldEnd()
11965 
    oprot.writeFieldStop()
11966 
    oprot.writeStructEnd()
11967 
 
3431 rajveer 11968 
  def validate(self):
11969 
    return
11970 
 
11971 
 
1220 chandransh 11972 
  def __repr__(self):
11973 
    L = ['%s=%r' % (key, value)
11974 
      for key, value in self.__dict__.iteritems()]
11975 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11976 
 
11977 
  def __eq__(self, other):
11978 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11979 
 
11980 
  def __ne__(self, other):
11981 
    return not (self == other)
11982 
 
1208 chandransh 11983 
class markOrderAsOutOfStock_args:
11984 
  """
11985 
  Attributes:
11986 
   - orderId
11987 
  """
11988 
 
11989 
  thrift_spec = (
11990 
    None, # 0
11991 
    (1, TType.I64, 'orderId', None, None, ), # 1
11992 
  )
11993 
 
11994 
  def __init__(self, orderId=None,):
11995 
    self.orderId = orderId
11996 
 
11997 
  def read(self, iprot):
11998 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11999 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12000 
      return
12001 
    iprot.readStructBegin()
12002 
    while True:
12003 
      (fname, ftype, fid) = iprot.readFieldBegin()
12004 
      if ftype == TType.STOP:
12005 
        break
12006 
      if fid == 1:
12007 
        if ftype == TType.I64:
12008 
          self.orderId = iprot.readI64();
12009 
        else:
12010 
          iprot.skip(ftype)
12011 
      else:
12012 
        iprot.skip(ftype)
12013 
      iprot.readFieldEnd()
12014 
    iprot.readStructEnd()
12015 
 
12016 
  def write(self, oprot):
12017 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12018 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12019 
      return
12020 
    oprot.writeStructBegin('markOrderAsOutOfStock_args')
3431 rajveer 12021 
    if self.orderId is not None:
1208 chandransh 12022 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
12023 
      oprot.writeI64(self.orderId)
12024 
      oprot.writeFieldEnd()
12025 
    oprot.writeFieldStop()
12026 
    oprot.writeStructEnd()
12027 
 
3431 rajveer 12028 
  def validate(self):
12029 
    return
12030 
 
12031 
 
1208 chandransh 12032 
  def __repr__(self):
12033 
    L = ['%s=%r' % (key, value)
12034 
      for key, value in self.__dict__.iteritems()]
12035 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12036 
 
12037 
  def __eq__(self, other):
12038 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12039 
 
12040 
  def __ne__(self, other):
12041 
    return not (self == other)
12042 
 
12043 
class markOrderAsOutOfStock_result:
12044 
  """
12045 
  Attributes:
12046 
   - success
12047 
   - ex
12048 
  """
12049 
 
12050 
  thrift_spec = (
12051 
    (0, TType.BOOL, 'success', None, None, ), # 0
12052 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
12053 
  )
12054 
 
12055 
  def __init__(self, success=None, ex=None,):
12056 
    self.success = success
12057 
    self.ex = ex
12058 
 
12059 
  def read(self, iprot):
12060 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12061 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12062 
      return
12063 
    iprot.readStructBegin()
12064 
    while True:
12065 
      (fname, ftype, fid) = iprot.readFieldBegin()
12066 
      if ftype == TType.STOP:
12067 
        break
12068 
      if fid == 0:
12069 
        if ftype == TType.BOOL:
12070 
          self.success = iprot.readBool();
12071 
        else:
12072 
          iprot.skip(ftype)
12073 
      elif fid == 1:
12074 
        if ftype == TType.STRUCT:
12075 
          self.ex = TransactionServiceException()
12076 
          self.ex.read(iprot)
12077 
        else:
12078 
          iprot.skip(ftype)
12079 
      else:
12080 
        iprot.skip(ftype)
12081 
      iprot.readFieldEnd()
12082 
    iprot.readStructEnd()
12083 
 
12084 
  def write(self, oprot):
12085 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12086 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12087 
      return
12088 
    oprot.writeStructBegin('markOrderAsOutOfStock_result')
3431 rajveer 12089 
    if self.success is not None:
1208 chandransh 12090 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
12091 
      oprot.writeBool(self.success)
12092 
      oprot.writeFieldEnd()
3431 rajveer 12093 
    if self.ex is not None:
1208 chandransh 12094 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
12095 
      self.ex.write(oprot)
12096 
      oprot.writeFieldEnd()
12097 
    oprot.writeFieldStop()
12098 
    oprot.writeStructEnd()
12099 
 
3431 rajveer 12100 
  def validate(self):
12101 
    return
12102 
 
12103 
 
1208 chandransh 12104 
  def __repr__(self):
12105 
    L = ['%s=%r' % (key, value)
12106 
      for key, value in self.__dict__.iteritems()]
12107 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12108 
 
12109 
  def __eq__(self, other):
12110 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12111 
 
12112 
  def __ne__(self, other):
12113 
    return not (self == other)
12114 
 
3064 chandransh 12115 
class verifyOrder_args:
759 chandransh 12116 
  """
12117 
  Attributes:
3064 chandransh 12118 
   - orderId
759 chandransh 12119 
  """
12120 
 
12121 
  thrift_spec = (
12122 
    None, # 0
3064 chandransh 12123 
    (1, TType.I64, 'orderId', None, None, ), # 1
759 chandransh 12124 
  )
12125 
 
3064 chandransh 12126 
  def __init__(self, orderId=None,):
12127 
    self.orderId = orderId
759 chandransh 12128 
 
12129 
  def read(self, iprot):
12130 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12131 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12132 
      return
12133 
    iprot.readStructBegin()
12134 
    while True:
12135 
      (fname, ftype, fid) = iprot.readFieldBegin()
12136 
      if ftype == TType.STOP:
12137 
        break
12138 
      if fid == 1:
12139 
        if ftype == TType.I64:
3064 chandransh 12140 
          self.orderId = iprot.readI64();
759 chandransh 12141 
        else:
12142 
          iprot.skip(ftype)
12143 
      else:
12144 
        iprot.skip(ftype)
12145 
      iprot.readFieldEnd()
12146 
    iprot.readStructEnd()
12147 
 
12148 
  def write(self, oprot):
12149 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12150 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12151 
      return
3064 chandransh 12152 
    oprot.writeStructBegin('verifyOrder_args')
3431 rajveer 12153 
    if self.orderId is not None:
3064 chandransh 12154 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
12155 
      oprot.writeI64(self.orderId)
759 chandransh 12156 
      oprot.writeFieldEnd()
12157 
    oprot.writeFieldStop()
12158 
    oprot.writeStructEnd()
12159 
 
3431 rajveer 12160 
  def validate(self):
12161 
    return
12162 
 
12163 
 
759 chandransh 12164 
  def __repr__(self):
12165 
    L = ['%s=%r' % (key, value)
12166 
      for key, value in self.__dict__.iteritems()]
12167 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12168 
 
12169 
  def __eq__(self, other):
12170 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12171 
 
12172 
  def __ne__(self, other):
12173 
    return not (self == other)
12174 
 
3064 chandransh 12175 
class verifyOrder_result:
759 chandransh 12176 
  """
12177 
  Attributes:
12178 
   - success
12179 
   - ex
12180 
  """
12181 
 
12182 
  thrift_spec = (
12183 
    (0, TType.BOOL, 'success', None, None, ), # 0
12184 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
12185 
  )
12186 
 
12187 
  def __init__(self, success=None, ex=None,):
12188 
    self.success = success
12189 
    self.ex = ex
12190 
 
12191 
  def read(self, iprot):
12192 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12193 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12194 
      return
12195 
    iprot.readStructBegin()
12196 
    while True:
12197 
      (fname, ftype, fid) = iprot.readFieldBegin()
12198 
      if ftype == TType.STOP:
12199 
        break
12200 
      if fid == 0:
12201 
        if ftype == TType.BOOL:
12202 
          self.success = iprot.readBool();
12203 
        else:
12204 
          iprot.skip(ftype)
12205 
      elif fid == 1:
12206 
        if ftype == TType.STRUCT:
12207 
          self.ex = TransactionServiceException()
12208 
          self.ex.read(iprot)
12209 
        else:
12210 
          iprot.skip(ftype)
12211 
      else:
12212 
        iprot.skip(ftype)
12213 
      iprot.readFieldEnd()
12214 
    iprot.readStructEnd()
12215 
 
12216 
  def write(self, oprot):
12217 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12218 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12219 
      return
3064 chandransh 12220 
    oprot.writeStructBegin('verifyOrder_result')
3431 rajveer 12221 
    if self.success is not None:
759 chandransh 12222 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
12223 
      oprot.writeBool(self.success)
12224 
      oprot.writeFieldEnd()
3431 rajveer 12225 
    if self.ex is not None:
759 chandransh 12226 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
12227 
      self.ex.write(oprot)
12228 
      oprot.writeFieldEnd()
12229 
    oprot.writeFieldStop()
12230 
    oprot.writeStructEnd()
12231 
 
3431 rajveer 12232 
  def validate(self):
12233 
    return
12234 
 
12235 
 
759 chandransh 12236 
  def __repr__(self):
12237 
    L = ['%s=%r' % (key, value)
12238 
      for key, value in self.__dict__.iteritems()]
12239 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12240 
 
12241 
  def __eq__(self, other):
12242 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12243 
 
12244 
  def __ne__(self, other):
12245 
    return not (self == other)
12246 
 
3064 chandransh 12247 
class acceptOrder_args:
1113 chandransh 12248 
  """
12249 
  Attributes:
3064 chandransh 12250 
   - orderId
1113 chandransh 12251 
  """
12252 
 
12253 
  thrift_spec = (
12254 
    None, # 0
3064 chandransh 12255 
    (1, TType.I64, 'orderId', None, None, ), # 1
1113 chandransh 12256 
  )
12257 
 
3064 chandransh 12258 
  def __init__(self, orderId=None,):
12259 
    self.orderId = orderId
1113 chandransh 12260 
 
12261 
  def read(self, iprot):
12262 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12263 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12264 
      return
12265 
    iprot.readStructBegin()
12266 
    while True:
12267 
      (fname, ftype, fid) = iprot.readFieldBegin()
12268 
      if ftype == TType.STOP:
12269 
        break
12270 
      if fid == 1:
12271 
        if ftype == TType.I64:
3064 chandransh 12272 
          self.orderId = iprot.readI64();
1113 chandransh 12273 
        else:
12274 
          iprot.skip(ftype)
12275 
      else:
12276 
        iprot.skip(ftype)
12277 
      iprot.readFieldEnd()
12278 
    iprot.readStructEnd()
12279 
 
12280 
  def write(self, oprot):
12281 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12282 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12283 
      return
3064 chandransh 12284 
    oprot.writeStructBegin('acceptOrder_args')
3431 rajveer 12285 
    if self.orderId is not None:
3064 chandransh 12286 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
12287 
      oprot.writeI64(self.orderId)
1113 chandransh 12288 
      oprot.writeFieldEnd()
12289 
    oprot.writeFieldStop()
12290 
    oprot.writeStructEnd()
12291 
 
3431 rajveer 12292 
  def validate(self):
12293 
    return
12294 
 
12295 
 
1113 chandransh 12296 
  def __repr__(self):
12297 
    L = ['%s=%r' % (key, value)
12298 
      for key, value in self.__dict__.iteritems()]
12299 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12300 
 
12301 
  def __eq__(self, other):
12302 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12303 
 
12304 
  def __ne__(self, other):
12305 
    return not (self == other)
12306 
 
3064 chandransh 12307 
class acceptOrder_result:
1113 chandransh 12308 
  """
12309 
  Attributes:
12310 
   - success
12311 
   - ex
12312 
  """
12313 
 
12314 
  thrift_spec = (
3064 chandransh 12315 
    (0, TType.BOOL, 'success', None, None, ), # 0
1113 chandransh 12316 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
12317 
  )
12318 
 
12319 
  def __init__(self, success=None, ex=None,):
12320 
    self.success = success
12321 
    self.ex = ex
12322 
 
12323 
  def read(self, iprot):
12324 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12325 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12326 
      return
12327 
    iprot.readStructBegin()
12328 
    while True:
12329 
      (fname, ftype, fid) = iprot.readFieldBegin()
12330 
      if ftype == TType.STOP:
12331 
        break
12332 
      if fid == 0:
3064 chandransh 12333 
        if ftype == TType.BOOL:
12334 
          self.success = iprot.readBool();
1113 chandransh 12335 
        else:
12336 
          iprot.skip(ftype)
12337 
      elif fid == 1:
12338 
        if ftype == TType.STRUCT:
12339 
          self.ex = TransactionServiceException()
12340 
          self.ex.read(iprot)
12341 
        else:
12342 
          iprot.skip(ftype)
12343 
      else:
12344 
        iprot.skip(ftype)
12345 
      iprot.readFieldEnd()
12346 
    iprot.readStructEnd()
12347 
 
12348 
  def write(self, oprot):
12349 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12350 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12351 
      return
3064 chandransh 12352 
    oprot.writeStructBegin('acceptOrder_result')
3431 rajveer 12353 
    if self.success is not None:
3064 chandransh 12354 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
12355 
      oprot.writeBool(self.success)
1113 chandransh 12356 
      oprot.writeFieldEnd()
3431 rajveer 12357 
    if self.ex is not None:
1113 chandransh 12358 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
12359 
      self.ex.write(oprot)
12360 
      oprot.writeFieldEnd()
12361 
    oprot.writeFieldStop()
12362 
    oprot.writeStructEnd()
12363 
 
3431 rajveer 12364 
  def validate(self):
12365 
    return
12366 
 
12367 
 
1113 chandransh 12368 
  def __repr__(self):
12369 
    L = ['%s=%r' % (key, value)
12370 
      for key, value in self.__dict__.iteritems()]
12371 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12372 
 
12373 
  def __eq__(self, other):
12374 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12375 
 
12376 
  def __ne__(self, other):
12377 
    return not (self == other)
12378 
 
3064 chandransh 12379 
class addBillingDetails_args:
1135 chandransh 12380 
  """
12381 
  Attributes:
3064 chandransh 12382 
   - orderId
12383 
   - invoice_number
4658 mandeep.dh 12384 
   - serialNumber
4283 anupam.sin 12385 
   - itemNumber
3064 chandransh 12386 
   - billed_by
4264 rajveer 12387 
   - jacketNumber
4283 anupam.sin 12388 
   - billingType
5110 mandeep.dh 12389 
   - fulfilmentWarehouseId
4763 rajveer 12390 
   - authorize
1135 chandransh 12391 
  """
12392 
 
12393 
  thrift_spec = (
12394 
    None, # 0
3064 chandransh 12395 
    (1, TType.I64, 'orderId', None, None, ), # 1
12396 
    (2, TType.STRING, 'invoice_number', None, None, ), # 2
5411 rajveer 12397 
    (3, TType.LIST, 'serialNumber', (TType.STRING,None), None, ), # 3
12398 
    (4, TType.LIST, 'itemNumber', (TType.STRING,None), None, ), # 4
4283 anupam.sin 12399 
    (5, TType.STRING, 'billed_by', None, None, ), # 5
12400 
    (6, TType.I64, 'jacketNumber', None, None, ), # 6
12401 
    (7, TType.I64, 'billingType', None, None, ), # 7
5110 mandeep.dh 12402 
    (8, TType.I64, 'fulfilmentWarehouseId', None, None, ), # 8
4763 rajveer 12403 
    (9, TType.BOOL, 'authorize', None, None, ), # 9
1135 chandransh 12404 
  )
12405 
 
5110 mandeep.dh 12406 
  def __init__(self, orderId=None, invoice_number=None, serialNumber=None, itemNumber=None, billed_by=None, jacketNumber=None, billingType=None, fulfilmentWarehouseId=None, authorize=None,):
3064 chandransh 12407 
    self.orderId = orderId
12408 
    self.invoice_number = invoice_number
4658 mandeep.dh 12409 
    self.serialNumber = serialNumber
4283 anupam.sin 12410 
    self.itemNumber = itemNumber
3064 chandransh 12411 
    self.billed_by = billed_by
4264 rajveer 12412 
    self.jacketNumber = jacketNumber
4283 anupam.sin 12413 
    self.billingType = billingType
5110 mandeep.dh 12414 
    self.fulfilmentWarehouseId = fulfilmentWarehouseId
4763 rajveer 12415 
    self.authorize = authorize
1135 chandransh 12416 
 
12417 
  def read(self, iprot):
12418 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12419 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12420 
      return
12421 
    iprot.readStructBegin()
12422 
    while True:
12423 
      (fname, ftype, fid) = iprot.readFieldBegin()
12424 
      if ftype == TType.STOP:
12425 
        break
12426 
      if fid == 1:
12427 
        if ftype == TType.I64:
3064 chandransh 12428 
          self.orderId = iprot.readI64();
1135 chandransh 12429 
        else:
12430 
          iprot.skip(ftype)
12431 
      elif fid == 2:
3064 chandransh 12432 
        if ftype == TType.STRING:
12433 
          self.invoice_number = iprot.readString();
1135 chandransh 12434 
        else:
12435 
          iprot.skip(ftype)
3064 chandransh 12436 
      elif fid == 3:
5411 rajveer 12437 
        if ftype == TType.LIST:
12438 
          self.serialNumber = []
12439 
          (_etype227, _size224) = iprot.readListBegin()
12440 
          for _i228 in xrange(_size224):
12441 
            _elem229 = iprot.readString();
12442 
            self.serialNumber.append(_elem229)
12443 
          iprot.readListEnd()
3064 chandransh 12444 
        else:
12445 
          iprot.skip(ftype)
12446 
      elif fid == 4:
5411 rajveer 12447 
        if ftype == TType.LIST:
12448 
          self.itemNumber = []
12449 
          (_etype233, _size230) = iprot.readListBegin()
12450 
          for _i234 in xrange(_size230):
12451 
            _elem235 = iprot.readString();
12452 
            self.itemNumber.append(_elem235)
12453 
          iprot.readListEnd()
3064 chandransh 12454 
        else:
12455 
          iprot.skip(ftype)
12456 
      elif fid == 5:
12457 
        if ftype == TType.STRING:
4283 anupam.sin 12458 
          self.billed_by = iprot.readString();
3064 chandransh 12459 
        else:
12460 
          iprot.skip(ftype)
12461 
      elif fid == 6:
12462 
        if ftype == TType.I64:
4283 anupam.sin 12463 
          self.jacketNumber = iprot.readI64();
12464 
        else:
12465 
          iprot.skip(ftype)
12466 
      elif fid == 7:
12467 
        if ftype == TType.I64:
3064 chandransh 12468 
          self.billingType = iprot.readI64();
12469 
        else:
12470 
          iprot.skip(ftype)
4283 anupam.sin 12471 
      elif fid == 8:
12472 
        if ftype == TType.I64:
5110 mandeep.dh 12473 
          self.fulfilmentWarehouseId = iprot.readI64();
4283 anupam.sin 12474 
        else:
12475 
          iprot.skip(ftype)
4763 rajveer 12476 
      elif fid == 9:
12477 
        if ftype == TType.BOOL:
12478 
          self.authorize = iprot.readBool();
12479 
        else:
12480 
          iprot.skip(ftype)
1246 chandransh 12481 
      else:
12482 
        iprot.skip(ftype)
12483 
      iprot.readFieldEnd()
12484 
    iprot.readStructEnd()
12485 
 
12486 
  def write(self, oprot):
12487 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12488 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12489 
      return
4283 anupam.sin 12490 
    oprot.writeStructBegin('addBillingDetails_args')
3431 rajveer 12491 
    if self.orderId is not None:
3064 chandransh 12492 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
12493 
      oprot.writeI64(self.orderId)
1246 chandransh 12494 
      oprot.writeFieldEnd()
4283 anupam.sin 12495 
    if self.invoice_number is not None:
12496 
      oprot.writeFieldBegin('invoice_number', TType.STRING, 2)
12497 
      oprot.writeString(self.invoice_number)
1246 chandransh 12498 
      oprot.writeFieldEnd()
4658 mandeep.dh 12499 
    if self.serialNumber is not None:
5411 rajveer 12500 
      oprot.writeFieldBegin('serialNumber', TType.LIST, 3)
12501 
      oprot.writeListBegin(TType.STRING, len(self.serialNumber))
12502 
      for iter236 in self.serialNumber:
12503 
        oprot.writeString(iter236)
12504 
      oprot.writeListEnd()
3064 chandransh 12505 
      oprot.writeFieldEnd()
3431 rajveer 12506 
    if self.itemNumber is not None:
5411 rajveer 12507 
      oprot.writeFieldBegin('itemNumber', TType.LIST, 4)
12508 
      oprot.writeListBegin(TType.STRING, len(self.itemNumber))
12509 
      for iter237 in self.itemNumber:
12510 
        oprot.writeString(iter237)
12511 
      oprot.writeListEnd()
3064 chandransh 12512 
      oprot.writeFieldEnd()
4283 anupam.sin 12513 
    if self.billed_by is not None:
12514 
      oprot.writeFieldBegin('billed_by', TType.STRING, 5)
12515 
      oprot.writeString(self.billed_by)
3064 chandransh 12516 
      oprot.writeFieldEnd()
4283 anupam.sin 12517 
    if self.jacketNumber is not None:
12518 
      oprot.writeFieldBegin('jacketNumber', TType.I64, 6)
12519 
      oprot.writeI64(self.jacketNumber)
12520 
      oprot.writeFieldEnd()
3431 rajveer 12521 
    if self.billingType is not None:
4283 anupam.sin 12522 
      oprot.writeFieldBegin('billingType', TType.I64, 7)
3064 chandransh 12523 
      oprot.writeI64(self.billingType)
12524 
      oprot.writeFieldEnd()
5110 mandeep.dh 12525 
    if self.fulfilmentWarehouseId is not None:
12526 
      oprot.writeFieldBegin('fulfilmentWarehouseId', TType.I64, 8)
12527 
      oprot.writeI64(self.fulfilmentWarehouseId)
4283 anupam.sin 12528 
      oprot.writeFieldEnd()
4763 rajveer 12529 
    if self.authorize is not None:
12530 
      oprot.writeFieldBegin('authorize', TType.BOOL, 9)
12531 
      oprot.writeBool(self.authorize)
12532 
      oprot.writeFieldEnd()
1246 chandransh 12533 
    oprot.writeFieldStop()
12534 
    oprot.writeStructEnd()
12535 
 
3431 rajveer 12536 
  def validate(self):
12537 
    return
12538 
 
12539 
 
1246 chandransh 12540 
  def __repr__(self):
12541 
    L = ['%s=%r' % (key, value)
12542 
      for key, value in self.__dict__.iteritems()]
12543 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12544 
 
12545 
  def __eq__(self, other):
12546 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12547 
 
12548 
  def __ne__(self, other):
12549 
    return not (self == other)
12550 
 
4283 anupam.sin 12551 
class addBillingDetails_result:
1246 chandransh 12552 
  """
12553 
  Attributes:
3064 chandransh 12554 
   - success
1246 chandransh 12555 
   - ex
12556 
  """
12557 
 
12558 
  thrift_spec = (
3064 chandransh 12559 
    (0, TType.BOOL, 'success', None, None, ), # 0
1246 chandransh 12560 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
12561 
  )
12562 
 
3064 chandransh 12563 
  def __init__(self, success=None, ex=None,):
12564 
    self.success = success
1246 chandransh 12565 
    self.ex = ex
12566 
 
12567 
  def read(self, iprot):
12568 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12569 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12570 
      return
12571 
    iprot.readStructBegin()
12572 
    while True:
12573 
      (fname, ftype, fid) = iprot.readFieldBegin()
12574 
      if ftype == TType.STOP:
12575 
        break
3064 chandransh 12576 
      if fid == 0:
12577 
        if ftype == TType.BOOL:
12578 
          self.success = iprot.readBool();
12579 
        else:
12580 
          iprot.skip(ftype)
12581 
      elif fid == 1:
1246 chandransh 12582 
        if ftype == TType.STRUCT:
12583 
          self.ex = TransactionServiceException()
12584 
          self.ex.read(iprot)
12585 
        else:
12586 
          iprot.skip(ftype)
12587 
      else:
12588 
        iprot.skip(ftype)
12589 
      iprot.readFieldEnd()
12590 
    iprot.readStructEnd()
12591 
 
12592 
  def write(self, oprot):
12593 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12594 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12595 
      return
4283 anupam.sin 12596 
    oprot.writeStructBegin('addBillingDetails_result')
3431 rajveer 12597 
    if self.success is not None:
3064 chandransh 12598 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
12599 
      oprot.writeBool(self.success)
12600 
      oprot.writeFieldEnd()
3431 rajveer 12601 
    if self.ex is not None:
1246 chandransh 12602 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
12603 
      self.ex.write(oprot)
12604 
      oprot.writeFieldEnd()
12605 
    oprot.writeFieldStop()
12606 
    oprot.writeStructEnd()
12607 
 
3431 rajveer 12608 
  def validate(self):
12609 
    return
12610 
 
12611 
 
1246 chandransh 12612 
  def __repr__(self):
12613 
    L = ['%s=%r' % (key, value)
12614 
      for key, value in self.__dict__.iteritems()]
12615 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12616 
 
12617 
  def __eq__(self, other):
12618 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12619 
 
12620 
  def __ne__(self, other):
12621 
    return not (self == other)
12622 
 
4579 rajveer 12623 
class addInvoiceNumber_args:
12624 
  """
12625 
  Attributes:
12626 
   - orderId
12627 
   - invoiceNumber
4763 rajveer 12628 
   - color
4579 rajveer 12629 
  """
12630 
 
12631 
  thrift_spec = (
12632 
    None, # 0
12633 
    (1, TType.I64, 'orderId', None, None, ), # 1
12634 
    (2, TType.STRING, 'invoiceNumber', None, None, ), # 2
4763 rajveer 12635 
    (3, TType.STRING, 'color', None, None, ), # 3
4579 rajveer 12636 
  )
12637 
 
4763 rajveer 12638 
  def __init__(self, orderId=None, invoiceNumber=None, color=None,):
4579 rajveer 12639 
    self.orderId = orderId
12640 
    self.invoiceNumber = invoiceNumber
4763 rajveer 12641 
    self.color = color
4579 rajveer 12642 
 
12643 
  def read(self, iprot):
12644 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12645 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12646 
      return
12647 
    iprot.readStructBegin()
12648 
    while True:
12649 
      (fname, ftype, fid) = iprot.readFieldBegin()
12650 
      if ftype == TType.STOP:
12651 
        break
12652 
      if fid == 1:
12653 
        if ftype == TType.I64:
12654 
          self.orderId = iprot.readI64();
12655 
        else:
12656 
          iprot.skip(ftype)
12657 
      elif fid == 2:
12658 
        if ftype == TType.STRING:
12659 
          self.invoiceNumber = iprot.readString();
12660 
        else:
12661 
          iprot.skip(ftype)
4763 rajveer 12662 
      elif fid == 3:
12663 
        if ftype == TType.STRING:
12664 
          self.color = iprot.readString();
12665 
        else:
12666 
          iprot.skip(ftype)
4579 rajveer 12667 
      else:
12668 
        iprot.skip(ftype)
12669 
      iprot.readFieldEnd()
12670 
    iprot.readStructEnd()
12671 
 
12672 
  def write(self, oprot):
12673 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12674 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12675 
      return
12676 
    oprot.writeStructBegin('addInvoiceNumber_args')
12677 
    if self.orderId is not None:
12678 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
12679 
      oprot.writeI64(self.orderId)
12680 
      oprot.writeFieldEnd()
12681 
    if self.invoiceNumber is not None:
12682 
      oprot.writeFieldBegin('invoiceNumber', TType.STRING, 2)
12683 
      oprot.writeString(self.invoiceNumber)
12684 
      oprot.writeFieldEnd()
4763 rajveer 12685 
    if self.color is not None:
12686 
      oprot.writeFieldBegin('color', TType.STRING, 3)
12687 
      oprot.writeString(self.color)
12688 
      oprot.writeFieldEnd()
4579 rajveer 12689 
    oprot.writeFieldStop()
12690 
    oprot.writeStructEnd()
12691 
 
12692 
  def validate(self):
12693 
    return
12694 
 
12695 
 
12696 
  def __repr__(self):
12697 
    L = ['%s=%r' % (key, value)
12698 
      for key, value in self.__dict__.iteritems()]
12699 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12700 
 
12701 
  def __eq__(self, other):
12702 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12703 
 
12704 
  def __ne__(self, other):
12705 
    return not (self == other)
12706 
 
12707 
class addInvoiceNumber_result:
12708 
  """
12709 
  Attributes:
12710 
   - ex
12711 
  """
12712 
 
12713 
  thrift_spec = (
12714 
    None, # 0
12715 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
12716 
  )
12717 
 
12718 
  def __init__(self, ex=None,):
12719 
    self.ex = ex
12720 
 
12721 
  def read(self, iprot):
12722 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12723 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12724 
      return
12725 
    iprot.readStructBegin()
12726 
    while True:
12727 
      (fname, ftype, fid) = iprot.readFieldBegin()
12728 
      if ftype == TType.STOP:
12729 
        break
12730 
      if fid == 1:
12731 
        if ftype == TType.STRUCT:
12732 
          self.ex = TransactionServiceException()
12733 
          self.ex.read(iprot)
12734 
        else:
12735 
          iprot.skip(ftype)
12736 
      else:
12737 
        iprot.skip(ftype)
12738 
      iprot.readFieldEnd()
12739 
    iprot.readStructEnd()
12740 
 
12741 
  def write(self, oprot):
12742 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12743 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12744 
      return
12745 
    oprot.writeStructBegin('addInvoiceNumber_result')
12746 
    if self.ex is not None:
12747 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
12748 
      self.ex.write(oprot)
12749 
      oprot.writeFieldEnd()
12750 
    oprot.writeFieldStop()
12751 
    oprot.writeStructEnd()
12752 
 
12753 
  def validate(self):
12754 
    return
12755 
 
12756 
 
12757 
  def __repr__(self):
12758 
    L = ['%s=%r' % (key, value)
12759 
      for key, value in self.__dict__.iteritems()]
12760 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12761 
 
12762 
  def __eq__(self, other):
12763 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12764 
 
12765 
  def __ne__(self, other):
12766 
    return not (self == other)
12767 
 
4910 phani.kuma 12768 
class markOrdersAsShippedFromWarehouse_args:
1408 ankur.sing 12769 
  """
12770 
  Attributes:
3064 chandransh 12771 
   - warehouseId
1408 ankur.sing 12772 
   - providerId
3064 chandransh 12773 
   - cod
4910 phani.kuma 12774 
   - orderIds
1408 ankur.sing 12775 
  """
12776 
 
12777 
  thrift_spec = (
12778 
    None, # 0
3064 chandransh 12779 
    (1, TType.I64, 'warehouseId', None, None, ), # 1
12780 
    (2, TType.I64, 'providerId', None, None, ), # 2
12781 
    (3, TType.BOOL, 'cod', None, None, ), # 3
4910 phani.kuma 12782 
    (4, TType.LIST, 'orderIds', (TType.I64,None), None, ), # 4
1408 ankur.sing 12783 
  )
12784 
 
4910 phani.kuma 12785 
  def __init__(self, warehouseId=None, providerId=None, cod=None, orderIds=None,):
3064 chandransh 12786 
    self.warehouseId = warehouseId
1408 ankur.sing 12787 
    self.providerId = providerId
3064 chandransh 12788 
    self.cod = cod
4910 phani.kuma 12789 
    self.orderIds = orderIds
1408 ankur.sing 12790 
 
12791 
  def read(self, iprot):
12792 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12793 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12794 
      return
12795 
    iprot.readStructBegin()
12796 
    while True:
12797 
      (fname, ftype, fid) = iprot.readFieldBegin()
12798 
      if ftype == TType.STOP:
12799 
        break
12800 
      if fid == 1:
12801 
        if ftype == TType.I64:
3064 chandransh 12802 
          self.warehouseId = iprot.readI64();
1408 ankur.sing 12803 
        else:
12804 
          iprot.skip(ftype)
12805 
      elif fid == 2:
12806 
        if ftype == TType.I64:
3064 chandransh 12807 
          self.providerId = iprot.readI64();
1408 ankur.sing 12808 
        else:
12809 
          iprot.skip(ftype)
3064 chandransh 12810 
      elif fid == 3:
12811 
        if ftype == TType.BOOL:
12812 
          self.cod = iprot.readBool();
12813 
        else:
12814 
          iprot.skip(ftype)
4910 phani.kuma 12815 
      elif fid == 4:
12816 
        if ftype == TType.LIST:
12817 
          self.orderIds = []
5411 rajveer 12818 
          (_etype241, _size238) = iprot.readListBegin()
12819 
          for _i242 in xrange(_size238):
12820 
            _elem243 = iprot.readI64();
12821 
            self.orderIds.append(_elem243)
4910 phani.kuma 12822 
          iprot.readListEnd()
12823 
        else:
12824 
          iprot.skip(ftype)
1408 ankur.sing 12825 
      else:
12826 
        iprot.skip(ftype)
12827 
      iprot.readFieldEnd()
12828 
    iprot.readStructEnd()
12829 
 
12830 
  def write(self, oprot):
12831 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12832 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12833 
      return
4910 phani.kuma 12834 
    oprot.writeStructBegin('markOrdersAsShippedFromWarehouse_args')
3431 rajveer 12835 
    if self.warehouseId is not None:
3064 chandransh 12836 
      oprot.writeFieldBegin('warehouseId', TType.I64, 1)
12837 
      oprot.writeI64(self.warehouseId)
12838 
      oprot.writeFieldEnd()
3431 rajveer 12839 
    if self.providerId is not None:
3064 chandransh 12840 
      oprot.writeFieldBegin('providerId', TType.I64, 2)
1408 ankur.sing 12841 
      oprot.writeI64(self.providerId)
12842 
      oprot.writeFieldEnd()
3431 rajveer 12843 
    if self.cod is not None:
3064 chandransh 12844 
      oprot.writeFieldBegin('cod', TType.BOOL, 3)
12845 
      oprot.writeBool(self.cod)
1408 ankur.sing 12846 
      oprot.writeFieldEnd()
4910 phani.kuma 12847 
    if self.orderIds is not None:
12848 
      oprot.writeFieldBegin('orderIds', TType.LIST, 4)
12849 
      oprot.writeListBegin(TType.I64, len(self.orderIds))
5411 rajveer 12850 
      for iter244 in self.orderIds:
12851 
        oprot.writeI64(iter244)
4910 phani.kuma 12852 
      oprot.writeListEnd()
12853 
      oprot.writeFieldEnd()
1408 ankur.sing 12854 
    oprot.writeFieldStop()
12855 
    oprot.writeStructEnd()
12856 
 
3431 rajveer 12857 
  def validate(self):
12858 
    return
12859 
 
12860 
 
1408 ankur.sing 12861 
  def __repr__(self):
12862 
    L = ['%s=%r' % (key, value)
12863 
      for key, value in self.__dict__.iteritems()]
12864 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12865 
 
12866 
  def __eq__(self, other):
12867 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12868 
 
12869 
  def __ne__(self, other):
12870 
    return not (self == other)
12871 
 
4910 phani.kuma 12872 
class markOrdersAsShippedFromWarehouse_result:
1408 ankur.sing 12873 
  """
12874 
  Attributes:
12875 
   - success
3064 chandransh 12876 
   - ex
1408 ankur.sing 12877 
  """
12878 
 
12879 
  thrift_spec = (
3064 chandransh 12880 
    (0, TType.BOOL, 'success', None, None, ), # 0
12881 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
1408 ankur.sing 12882 
  )
12883 
 
3064 chandransh 12884 
  def __init__(self, success=None, ex=None,):
1408 ankur.sing 12885 
    self.success = success
3064 chandransh 12886 
    self.ex = ex
1408 ankur.sing 12887 
 
12888 
  def read(self, iprot):
12889 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12890 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12891 
      return
12892 
    iprot.readStructBegin()
12893 
    while True:
12894 
      (fname, ftype, fid) = iprot.readFieldBegin()
12895 
      if ftype == TType.STOP:
12896 
        break
12897 
      if fid == 0:
3064 chandransh 12898 
        if ftype == TType.BOOL:
12899 
          self.success = iprot.readBool();
1408 ankur.sing 12900 
        else:
12901 
          iprot.skip(ftype)
3064 chandransh 12902 
      elif fid == 1:
12903 
        if ftype == TType.STRUCT:
12904 
          self.ex = TransactionServiceException()
12905 
          self.ex.read(iprot)
12906 
        else:
12907 
          iprot.skip(ftype)
1408 ankur.sing 12908 
      else:
12909 
        iprot.skip(ftype)
12910 
      iprot.readFieldEnd()
12911 
    iprot.readStructEnd()
12912 
 
12913 
  def write(self, oprot):
12914 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12915 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12916 
      return
4910 phani.kuma 12917 
    oprot.writeStructBegin('markOrdersAsShippedFromWarehouse_result')
3431 rajveer 12918 
    if self.success is not None:
3064 chandransh 12919 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
12920 
      oprot.writeBool(self.success)
1408 ankur.sing 12921 
      oprot.writeFieldEnd()
3431 rajveer 12922 
    if self.ex is not None:
3064 chandransh 12923 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
12924 
      self.ex.write(oprot)
12925 
      oprot.writeFieldEnd()
1408 ankur.sing 12926 
    oprot.writeFieldStop()
12927 
    oprot.writeStructEnd()
12928 
 
3431 rajveer 12929 
  def validate(self):
12930 
    return
12931 
 
12932 
 
1408 ankur.sing 12933 
  def __repr__(self):
12934 
    L = ['%s=%r' % (key, value)
12935 
      for key, value in self.__dict__.iteritems()]
12936 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12937 
 
12938 
  def __eq__(self, other):
12939 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12940 
 
12941 
  def __ne__(self, other):
12942 
    return not (self == other)
12943 
 
5676 rajveer 12944 
class markOrdersAsReturnedFromStore_args:
12945 
  """
12946 
  Attributes:
12947 
   - providerId
12948 
   - orderIds
5713 rajveer 12949 
   - awbs
5676 rajveer 12950 
  """
12951 
 
12952 
  thrift_spec = (
12953 
    None, # 0
12954 
    (1, TType.I64, 'providerId', None, None, ), # 1
12955 
    (2, TType.LIST, 'orderIds', (TType.I64,None), None, ), # 2
5713 rajveer 12956 
    (3, TType.LIST, 'awbs', (TType.STRING,None), None, ), # 3
5676 rajveer 12957 
  )
12958 
 
5713 rajveer 12959 
  def __init__(self, providerId=None, orderIds=None, awbs=None,):
5676 rajveer 12960 
    self.providerId = providerId
12961 
    self.orderIds = orderIds
5713 rajveer 12962 
    self.awbs = awbs
5676 rajveer 12963 
 
12964 
  def read(self, iprot):
12965 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12966 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12967 
      return
12968 
    iprot.readStructBegin()
12969 
    while True:
12970 
      (fname, ftype, fid) = iprot.readFieldBegin()
12971 
      if ftype == TType.STOP:
12972 
        break
12973 
      if fid == 1:
12974 
        if ftype == TType.I64:
12975 
          self.providerId = iprot.readI64();
12976 
        else:
12977 
          iprot.skip(ftype)
12978 
      elif fid == 2:
12979 
        if ftype == TType.LIST:
12980 
          self.orderIds = []
12981 
          (_etype248, _size245) = iprot.readListBegin()
12982 
          for _i249 in xrange(_size245):
12983 
            _elem250 = iprot.readI64();
12984 
            self.orderIds.append(_elem250)
12985 
          iprot.readListEnd()
12986 
        else:
12987 
          iprot.skip(ftype)
5713 rajveer 12988 
      elif fid == 3:
12989 
        if ftype == TType.LIST:
12990 
          self.awbs = []
12991 
          (_etype254, _size251) = iprot.readListBegin()
12992 
          for _i255 in xrange(_size251):
12993 
            _elem256 = iprot.readString();
12994 
            self.awbs.append(_elem256)
12995 
          iprot.readListEnd()
12996 
        else:
12997 
          iprot.skip(ftype)
5676 rajveer 12998 
      else:
12999 
        iprot.skip(ftype)
13000 
      iprot.readFieldEnd()
13001 
    iprot.readStructEnd()
13002 
 
13003 
  def write(self, oprot):
13004 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13005 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13006 
      return
13007 
    oprot.writeStructBegin('markOrdersAsReturnedFromStore_args')
13008 
    if self.providerId is not None:
13009 
      oprot.writeFieldBegin('providerId', TType.I64, 1)
13010 
      oprot.writeI64(self.providerId)
13011 
      oprot.writeFieldEnd()
13012 
    if self.orderIds is not None:
13013 
      oprot.writeFieldBegin('orderIds', TType.LIST, 2)
13014 
      oprot.writeListBegin(TType.I64, len(self.orderIds))
5713 rajveer 13015 
      for iter257 in self.orderIds:
13016 
        oprot.writeI64(iter257)
5676 rajveer 13017 
      oprot.writeListEnd()
13018 
      oprot.writeFieldEnd()
5713 rajveer 13019 
    if self.awbs is not None:
13020 
      oprot.writeFieldBegin('awbs', TType.LIST, 3)
13021 
      oprot.writeListBegin(TType.STRING, len(self.awbs))
13022 
      for iter258 in self.awbs:
13023 
        oprot.writeString(iter258)
13024 
      oprot.writeListEnd()
13025 
      oprot.writeFieldEnd()
5676 rajveer 13026 
    oprot.writeFieldStop()
13027 
    oprot.writeStructEnd()
13028 
 
13029 
  def validate(self):
13030 
    return
13031 
 
13032 
 
13033 
  def __repr__(self):
13034 
    L = ['%s=%r' % (key, value)
13035 
      for key, value in self.__dict__.iteritems()]
13036 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13037 
 
13038 
  def __eq__(self, other):
13039 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13040 
 
13041 
  def __ne__(self, other):
13042 
    return not (self == other)
13043 
 
13044 
class markOrdersAsReturnedFromStore_result:
13045 
  """
13046 
  Attributes:
13047 
   - success
13048 
   - ex
13049 
  """
13050 
 
13051 
  thrift_spec = (
13052 
    (0, TType.BOOL, 'success', None, None, ), # 0
13053 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
13054 
  )
13055 
 
13056 
  def __init__(self, success=None, ex=None,):
13057 
    self.success = success
13058 
    self.ex = ex
13059 
 
13060 
  def read(self, iprot):
13061 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13062 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13063 
      return
13064 
    iprot.readStructBegin()
13065 
    while True:
13066 
      (fname, ftype, fid) = iprot.readFieldBegin()
13067 
      if ftype == TType.STOP:
13068 
        break
13069 
      if fid == 0:
13070 
        if ftype == TType.BOOL:
13071 
          self.success = iprot.readBool();
13072 
        else:
13073 
          iprot.skip(ftype)
13074 
      elif fid == 1:
13075 
        if ftype == TType.STRUCT:
13076 
          self.ex = TransactionServiceException()
13077 
          self.ex.read(iprot)
13078 
        else:
13079 
          iprot.skip(ftype)
13080 
      else:
13081 
        iprot.skip(ftype)
13082 
      iprot.readFieldEnd()
13083 
    iprot.readStructEnd()
13084 
 
13085 
  def write(self, oprot):
13086 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13087 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13088 
      return
13089 
    oprot.writeStructBegin('markOrdersAsReturnedFromStore_result')
13090 
    if self.success is not None:
13091 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
13092 
      oprot.writeBool(self.success)
13093 
      oprot.writeFieldEnd()
13094 
    if self.ex is not None:
13095 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
13096 
      self.ex.write(oprot)
13097 
      oprot.writeFieldEnd()
13098 
    oprot.writeFieldStop()
13099 
    oprot.writeStructEnd()
13100 
 
13101 
  def validate(self):
13102 
    return
13103 
 
13104 
 
13105 
  def __repr__(self):
13106 
    L = ['%s=%r' % (key, value)
13107 
      for key, value in self.__dict__.iteritems()]
13108 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13109 
 
13110 
  def __eq__(self, other):
13111 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13112 
 
13113 
  def __ne__(self, other):
13114 
    return not (self == other)
13115 
 
4910 phani.kuma 13116 
class markOrdersAsPickedUp_args:
4410 rajveer 13117 
  """
13118 
  Attributes:
13119 
   - providerId
4910 phani.kuma 13120 
   - pickupDetails
4410 rajveer 13121 
  """
13122 
 
13123 
  thrift_spec = (
13124 
    None, # 0
4910 phani.kuma 13125 
    (1, TType.I64, 'providerId', None, None, ), # 1
13126 
    (2, TType.MAP, 'pickupDetails', (TType.STRING,None,TType.STRING,None), None, ), # 2
4410 rajveer 13127 
  )
13128 
 
4910 phani.kuma 13129 
  def __init__(self, providerId=None, pickupDetails=None,):
4410 rajveer 13130 
    self.providerId = providerId
4910 phani.kuma 13131 
    self.pickupDetails = pickupDetails
4410 rajveer 13132 
 
13133 
  def read(self, iprot):
13134 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13135 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13136 
      return
13137 
    iprot.readStructBegin()
13138 
    while True:
13139 
      (fname, ftype, fid) = iprot.readFieldBegin()
13140 
      if ftype == TType.STOP:
13141 
        break
13142 
      if fid == 1:
13143 
        if ftype == TType.I64:
4910 phani.kuma 13144 
          self.providerId = iprot.readI64();
4410 rajveer 13145 
        else:
13146 
          iprot.skip(ftype)
13147 
      elif fid == 2:
4910 phani.kuma 13148 
        if ftype == TType.MAP:
13149 
          self.pickupDetails = {}
5713 rajveer 13150 
          (_ktype260, _vtype261, _size259 ) = iprot.readMapBegin()
13151 
          for _i263 in xrange(_size259):
13152 
            _key264 = iprot.readString();
13153 
            _val265 = iprot.readString();
13154 
            self.pickupDetails[_key264] = _val265
4910 phani.kuma 13155 
          iprot.readMapEnd()
4410 rajveer 13156 
        else:
13157 
          iprot.skip(ftype)
13158 
      else:
13159 
        iprot.skip(ftype)
13160 
      iprot.readFieldEnd()
13161 
    iprot.readStructEnd()
13162 
 
13163 
  def write(self, oprot):
13164 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13165 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13166 
      return
4910 phani.kuma 13167 
    oprot.writeStructBegin('markOrdersAsPickedUp_args')
4410 rajveer 13168 
    if self.providerId is not None:
4910 phani.kuma 13169 
      oprot.writeFieldBegin('providerId', TType.I64, 1)
4410 rajveer 13170 
      oprot.writeI64(self.providerId)
13171 
      oprot.writeFieldEnd()
4910 phani.kuma 13172 
    if self.pickupDetails is not None:
13173 
      oprot.writeFieldBegin('pickupDetails', TType.MAP, 2)
13174 
      oprot.writeMapBegin(TType.STRING, TType.STRING, len(self.pickupDetails))
5713 rajveer 13175 
      for kiter266,viter267 in self.pickupDetails.items():
13176 
        oprot.writeString(kiter266)
13177 
        oprot.writeString(viter267)
4910 phani.kuma 13178 
      oprot.writeMapEnd()
4410 rajveer 13179 
      oprot.writeFieldEnd()
13180 
    oprot.writeFieldStop()
13181 
    oprot.writeStructEnd()
13182 
 
13183 
  def validate(self):
13184 
    return
13185 
 
13186 
 
13187 
  def __repr__(self):
13188 
    L = ['%s=%r' % (key, value)
13189 
      for key, value in self.__dict__.iteritems()]
13190 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13191 
 
13192 
  def __eq__(self, other):
13193 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13194 
 
13195 
  def __ne__(self, other):
13196 
    return not (self == other)
13197 
 
4910 phani.kuma 13198 
class markOrdersAsPickedUp_result:
4410 rajveer 13199 
  """
13200 
  Attributes:
13201 
   - ex
13202 
  """
13203 
 
13204 
  thrift_spec = (
4910 phani.kuma 13205 
    None, # 0
4410 rajveer 13206 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
13207 
  )
13208 
 
4910 phani.kuma 13209 
  def __init__(self, ex=None,):
4410 rajveer 13210 
    self.ex = ex
13211 
 
13212 
  def read(self, iprot):
13213 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13214 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13215 
      return
13216 
    iprot.readStructBegin()
13217 
    while True:
13218 
      (fname, ftype, fid) = iprot.readFieldBegin()
13219 
      if ftype == TType.STOP:
13220 
        break
4910 phani.kuma 13221 
      if fid == 1:
4410 rajveer 13222 
        if ftype == TType.STRUCT:
13223 
          self.ex = TransactionServiceException()
13224 
          self.ex.read(iprot)
13225 
        else:
13226 
          iprot.skip(ftype)
13227 
      else:
13228 
        iprot.skip(ftype)
13229 
      iprot.readFieldEnd()
13230 
    iprot.readStructEnd()
13231 
 
13232 
  def write(self, oprot):
13233 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13234 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13235 
      return
4910 phani.kuma 13236 
    oprot.writeStructBegin('markOrdersAsPickedUp_result')
4410 rajveer 13237 
    if self.ex is not None:
13238 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
13239 
      self.ex.write(oprot)
13240 
      oprot.writeFieldEnd()
13241 
    oprot.writeFieldStop()
13242 
    oprot.writeStructEnd()
13243 
 
13244 
  def validate(self):
13245 
    return
13246 
 
13247 
 
13248 
  def __repr__(self):
13249 
    L = ['%s=%r' % (key, value)
13250 
      for key, value in self.__dict__.iteritems()]
13251 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13252 
 
13253 
  def __eq__(self, other):
13254 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13255 
 
13256 
  def __ne__(self, other):
13257 
    return not (self == other)
13258 
 
4910 phani.kuma 13259 
class getOrdersNotPickedUp_args:
304 ashish 13260 
  """
13261 
  Attributes:
3064 chandransh 13262 
   - providerId
304 ashish 13263 
  """
94 ashish 13264 
 
304 ashish 13265 
  thrift_spec = (
13266 
    None, # 0
3064 chandransh 13267 
    (1, TType.I64, 'providerId', None, None, ), # 1
304 ashish 13268 
  )
13269 
 
4910 phani.kuma 13270 
  def __init__(self, providerId=None,):
3064 chandransh 13271 
    self.providerId = providerId
304 ashish 13272 
 
13273 
  def read(self, iprot):
13274 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13275 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13276 
      return
13277 
    iprot.readStructBegin()
13278 
    while True:
13279 
      (fname, ftype, fid) = iprot.readFieldBegin()
13280 
      if ftype == TType.STOP:
13281 
        break
13282 
      if fid == 1:
13283 
        if ftype == TType.I64:
3064 chandransh 13284 
          self.providerId = iprot.readI64();
304 ashish 13285 
        else:
13286 
          iprot.skip(ftype)
13287 
      else:
13288 
        iprot.skip(ftype)
13289 
      iprot.readFieldEnd()
13290 
    iprot.readStructEnd()
13291 
 
13292 
  def write(self, oprot):
13293 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13294 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13295 
      return
4910 phani.kuma 13296 
    oprot.writeStructBegin('getOrdersNotPickedUp_args')
3431 rajveer 13297 
    if self.providerId is not None:
3064 chandransh 13298 
      oprot.writeFieldBegin('providerId', TType.I64, 1)
13299 
      oprot.writeI64(self.providerId)
304 ashish 13300 
      oprot.writeFieldEnd()
13301 
    oprot.writeFieldStop()
13302 
    oprot.writeStructEnd()
13303 
 
3431 rajveer 13304 
  def validate(self):
13305 
    return
13306 
 
13307 
 
304 ashish 13308 
  def __repr__(self):
13309 
    L = ['%s=%r' % (key, value)
13310 
      for key, value in self.__dict__.iteritems()]
13311 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13312 
 
13313 
  def __eq__(self, other):
13314 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13315 
 
13316 
  def __ne__(self, other):
13317 
    return not (self == other)
13318 
 
4910 phani.kuma 13319 
class getOrdersNotPickedUp_result:
304 ashish 13320 
  """
13321 
  Attributes:
13322 
   - success
13323 
  """
13324 
 
13325 
  thrift_spec = (
3064 chandransh 13326 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
304 ashish 13327 
  )
13328 
 
4910 phani.kuma 13329 
  def __init__(self, success=None,):
304 ashish 13330 
    self.success = success
13331 
 
13332 
  def read(self, iprot):
13333 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13334 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13335 
      return
13336 
    iprot.readStructBegin()
13337 
    while True:
13338 
      (fname, ftype, fid) = iprot.readFieldBegin()
13339 
      if ftype == TType.STOP:
13340 
        break
13341 
      if fid == 0:
13342 
        if ftype == TType.LIST:
13343 
          self.success = []
5713 rajveer 13344 
          (_etype271, _size268) = iprot.readListBegin()
13345 
          for _i272 in xrange(_size268):
13346 
            _elem273 = Order()
13347 
            _elem273.read(iprot)
13348 
            self.success.append(_elem273)
304 ashish 13349 
          iprot.readListEnd()
13350 
        else:
13351 
          iprot.skip(ftype)
13352 
      else:
13353 
        iprot.skip(ftype)
13354 
      iprot.readFieldEnd()
13355 
    iprot.readStructEnd()
13356 
 
13357 
  def write(self, oprot):
13358 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13359 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13360 
      return
4910 phani.kuma 13361 
    oprot.writeStructBegin('getOrdersNotPickedUp_result')
3431 rajveer 13362 
    if self.success is not None:
304 ashish 13363 
      oprot.writeFieldBegin('success', TType.LIST, 0)
13364 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
5713 rajveer 13365 
      for iter274 in self.success:
13366 
        iter274.write(oprot)
304 ashish 13367 
      oprot.writeListEnd()
13368 
      oprot.writeFieldEnd()
13369 
    oprot.writeFieldStop()
13370 
    oprot.writeStructEnd()
13371 
 
3431 rajveer 13372 
  def validate(self):
13373 
    return
13374 
 
13375 
 
304 ashish 13376 
  def __repr__(self):
13377 
    L = ['%s=%r' % (key, value)
13378 
      for key, value in self.__dict__.iteritems()]
13379 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13380 
 
13381 
  def __eq__(self, other):
13382 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13383 
 
13384 
  def __ne__(self, other):
13385 
    return not (self == other)
13386 
 
3064 chandransh 13387 
class markOrdersAsDelivered_args:
304 ashish 13388 
  """
13389 
  Attributes:
3064 chandransh 13390 
   - providerId
13391 
   - deliveredOrders
304 ashish 13392 
  """
13393 
 
13394 
  thrift_spec = (
13395 
    None, # 0
3064 chandransh 13396 
    (1, TType.I64, 'providerId', None, None, ), # 1
13397 
    (2, TType.MAP, 'deliveredOrders', (TType.STRING,None,TType.STRING,None), None, ), # 2
304 ashish 13398 
  )
13399 
 
3064 chandransh 13400 
  def __init__(self, providerId=None, deliveredOrders=None,):
13401 
    self.providerId = providerId
13402 
    self.deliveredOrders = deliveredOrders
304 ashish 13403 
 
13404 
  def read(self, iprot):
13405 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13406 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13407 
      return
13408 
    iprot.readStructBegin()
13409 
    while True:
13410 
      (fname, ftype, fid) = iprot.readFieldBegin()
13411 
      if ftype == TType.STOP:
13412 
        break
13413 
      if fid == 1:
13414 
        if ftype == TType.I64:
3064 chandransh 13415 
          self.providerId = iprot.readI64();
304 ashish 13416 
        else:
13417 
          iprot.skip(ftype)
13418 
      elif fid == 2:
3064 chandransh 13419 
        if ftype == TType.MAP:
13420 
          self.deliveredOrders = {}
5713 rajveer 13421 
          (_ktype276, _vtype277, _size275 ) = iprot.readMapBegin()
13422 
          for _i279 in xrange(_size275):
13423 
            _key280 = iprot.readString();
13424 
            _val281 = iprot.readString();
13425 
            self.deliveredOrders[_key280] = _val281
3064 chandransh 13426 
          iprot.readMapEnd()
304 ashish 13427 
        else:
13428 
          iprot.skip(ftype)
13429 
      else:
13430 
        iprot.skip(ftype)
13431 
      iprot.readFieldEnd()
13432 
    iprot.readStructEnd()
13433 
 
13434 
  def write(self, oprot):
13435 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13436 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13437 
      return
3064 chandransh 13438 
    oprot.writeStructBegin('markOrdersAsDelivered_args')
3431 rajveer 13439 
    if self.providerId is not None:
3064 chandransh 13440 
      oprot.writeFieldBegin('providerId', TType.I64, 1)
13441 
      oprot.writeI64(self.providerId)
304 ashish 13442 
      oprot.writeFieldEnd()
3431 rajveer 13443 
    if self.deliveredOrders is not None:
3064 chandransh 13444 
      oprot.writeFieldBegin('deliveredOrders', TType.MAP, 2)
13445 
      oprot.writeMapBegin(TType.STRING, TType.STRING, len(self.deliveredOrders))
5713 rajveer 13446 
      for kiter282,viter283 in self.deliveredOrders.items():
13447 
        oprot.writeString(kiter282)
13448 
        oprot.writeString(viter283)
3064 chandransh 13449 
      oprot.writeMapEnd()
304 ashish 13450 
      oprot.writeFieldEnd()
13451 
    oprot.writeFieldStop()
13452 
    oprot.writeStructEnd()
13453 
 
3431 rajveer 13454 
  def validate(self):
13455 
    return
13456 
 
13457 
 
304 ashish 13458 
  def __repr__(self):
13459 
    L = ['%s=%r' % (key, value)
13460 
      for key, value in self.__dict__.iteritems()]
13461 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13462 
 
13463 
  def __eq__(self, other):
13464 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13465 
 
13466 
  def __ne__(self, other):
13467 
    return not (self == other)
13468 
 
3064 chandransh 13469 
class markOrdersAsDelivered_result:
13470 
  """
13471 
  Attributes:
13472 
   - ex
13473 
  """
304 ashish 13474 
 
13475 
  thrift_spec = (
3064 chandransh 13476 
    None, # 0
13477 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
304 ashish 13478 
  )
13479 
 
3064 chandransh 13480 
  def __init__(self, ex=None,):
13481 
    self.ex = ex
304 ashish 13482 
 
1596 ankur.sing 13483 
  def read(self, iprot):
13484 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13485 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13486 
      return
13487 
    iprot.readStructBegin()
13488 
    while True:
13489 
      (fname, ftype, fid) = iprot.readFieldBegin()
13490 
      if ftype == TType.STOP:
13491 
        break
3064 chandransh 13492 
      if fid == 1:
13493 
        if ftype == TType.STRUCT:
13494 
          self.ex = TransactionServiceException()
13495 
          self.ex.read(iprot)
13496 
        else:
13497 
          iprot.skip(ftype)
1596 ankur.sing 13498 
      else:
13499 
        iprot.skip(ftype)
13500 
      iprot.readFieldEnd()
13501 
    iprot.readStructEnd()
13502 
 
13503 
  def write(self, oprot):
13504 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13505 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13506 
      return
3064 chandransh 13507 
    oprot.writeStructBegin('markOrdersAsDelivered_result')
3431 rajveer 13508 
    if self.ex is not None:
3064 chandransh 13509 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
13510 
      self.ex.write(oprot)
13511 
      oprot.writeFieldEnd()
1596 ankur.sing 13512 
    oprot.writeFieldStop()
13513 
    oprot.writeStructEnd()
13514 
 
3431 rajveer 13515 
  def validate(self):
13516 
    return
13517 
 
13518 
 
1596 ankur.sing 13519 
  def __repr__(self):
13520 
    L = ['%s=%r' % (key, value)
13521 
      for key, value in self.__dict__.iteritems()]
13522 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13523 
 
13524 
  def __eq__(self, other):
13525 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13526 
 
13527 
  def __ne__(self, other):
13528 
    return not (self == other)
13529 
 
4910 phani.kuma 13530 
class markAsRTOrders_args:
1596 ankur.sing 13531 
  """
13532 
  Attributes:
3064 chandransh 13533 
   - providerId
13534 
   - returnedOrders
1596 ankur.sing 13535 
  """
13536 
 
13537 
  thrift_spec = (
3064 chandransh 13538 
    None, # 0
13539 
    (1, TType.I64, 'providerId', None, None, ), # 1
13540 
    (2, TType.MAP, 'returnedOrders', (TType.STRING,None,TType.STRING,None), None, ), # 2
1596 ankur.sing 13541 
  )
13542 
 
3064 chandransh 13543 
  def __init__(self, providerId=None, returnedOrders=None,):
13544 
    self.providerId = providerId
13545 
    self.returnedOrders = returnedOrders
1596 ankur.sing 13546 
 
13547 
  def read(self, iprot):
13548 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13549 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13550 
      return
13551 
    iprot.readStructBegin()
13552 
    while True:
13553 
      (fname, ftype, fid) = iprot.readFieldBegin()
13554 
      if ftype == TType.STOP:
13555 
        break
3064 chandransh 13556 
      if fid == 1:
1596 ankur.sing 13557 
        if ftype == TType.I64:
3064 chandransh 13558 
          self.providerId = iprot.readI64();
1596 ankur.sing 13559 
        else:
13560 
          iprot.skip(ftype)
3064 chandransh 13561 
      elif fid == 2:
13562 
        if ftype == TType.MAP:
13563 
          self.returnedOrders = {}
5713 rajveer 13564 
          (_ktype285, _vtype286, _size284 ) = iprot.readMapBegin()
13565 
          for _i288 in xrange(_size284):
13566 
            _key289 = iprot.readString();
13567 
            _val290 = iprot.readString();
13568 
            self.returnedOrders[_key289] = _val290
3064 chandransh 13569 
          iprot.readMapEnd()
13570 
        else:
13571 
          iprot.skip(ftype)
1596 ankur.sing 13572 
      else:
13573 
        iprot.skip(ftype)
13574 
      iprot.readFieldEnd()
13575 
    iprot.readStructEnd()
13576 
 
13577 
  def write(self, oprot):
13578 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13579 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13580 
      return
4910 phani.kuma 13581 
    oprot.writeStructBegin('markAsRTOrders_args')
3431 rajveer 13582 
    if self.providerId is not None:
3064 chandransh 13583 
      oprot.writeFieldBegin('providerId', TType.I64, 1)
13584 
      oprot.writeI64(self.providerId)
1596 ankur.sing 13585 
      oprot.writeFieldEnd()
3431 rajveer 13586 
    if self.returnedOrders is not None:
3064 chandransh 13587 
      oprot.writeFieldBegin('returnedOrders', TType.MAP, 2)
13588 
      oprot.writeMapBegin(TType.STRING, TType.STRING, len(self.returnedOrders))
5713 rajveer 13589 
      for kiter291,viter292 in self.returnedOrders.items():
13590 
        oprot.writeString(kiter291)
13591 
        oprot.writeString(viter292)
3064 chandransh 13592 
      oprot.writeMapEnd()
13593 
      oprot.writeFieldEnd()
1596 ankur.sing 13594 
    oprot.writeFieldStop()
13595 
    oprot.writeStructEnd()
13596 
 
3431 rajveer 13597 
  def validate(self):
13598 
    return
13599 
 
13600 
 
1596 ankur.sing 13601 
  def __repr__(self):
13602 
    L = ['%s=%r' % (key, value)
13603 
      for key, value in self.__dict__.iteritems()]
13604 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13605 
 
13606 
  def __eq__(self, other):
13607 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13608 
 
13609 
  def __ne__(self, other):
13610 
    return not (self == other)
13611 
 
4910 phani.kuma 13612 
class markAsRTOrders_result:
3064 chandransh 13613 
  """
13614 
  Attributes:
13615 
   - ex
13616 
  """
1596 ankur.sing 13617 
 
1627 ankur.sing 13618 
  thrift_spec = (
3064 chandransh 13619 
    None, # 0
13620 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
1627 ankur.sing 13621 
  )
13622 
 
3064 chandransh 13623 
  def __init__(self, ex=None,):
13624 
    self.ex = ex
13625 
 
1627 ankur.sing 13626 
  def read(self, iprot):
13627 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13628 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13629 
      return
13630 
    iprot.readStructBegin()
13631 
    while True:
13632 
      (fname, ftype, fid) = iprot.readFieldBegin()
13633 
      if ftype == TType.STOP:
13634 
        break
3064 chandransh 13635 
      if fid == 1:
13636 
        if ftype == TType.STRUCT:
13637 
          self.ex = TransactionServiceException()
13638 
          self.ex.read(iprot)
13639 
        else:
13640 
          iprot.skip(ftype)
1627 ankur.sing 13641 
      else:
13642 
        iprot.skip(ftype)
13643 
      iprot.readFieldEnd()
13644 
    iprot.readStructEnd()
13645 
 
13646 
  def write(self, oprot):
13647 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13648 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13649 
      return
4910 phani.kuma 13650 
    oprot.writeStructBegin('markAsRTOrders_result')
3431 rajveer 13651 
    if self.ex is not None:
3064 chandransh 13652 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
13653 
      self.ex.write(oprot)
13654 
      oprot.writeFieldEnd()
1627 ankur.sing 13655 
    oprot.writeFieldStop()
13656 
    oprot.writeStructEnd()
13657 
 
3431 rajveer 13658 
  def validate(self):
13659 
    return
13660 
 
13661 
 
1627 ankur.sing 13662 
  def __repr__(self):
13663 
    L = ['%s=%r' % (key, value)
13664 
      for key, value in self.__dict__.iteritems()]
13665 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13666 
 
13667 
  def __eq__(self, other):
13668 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13669 
 
13670 
  def __ne__(self, other):
13671 
    return not (self == other)
13672 
 
4910 phani.kuma 13673 
class getRTOrders_args:
13674 
  """
13675 
  Attributes:
13676 
   - providerId
13677 
  """
13678 
 
13679 
  thrift_spec = (
13680 
    None, # 0
13681 
    (1, TType.I64, 'providerId', None, None, ), # 1
13682 
  )
13683 
 
13684 
  def __init__(self, providerId=None,):
13685 
    self.providerId = providerId
13686 
 
13687 
  def read(self, iprot):
13688 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13689 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13690 
      return
13691 
    iprot.readStructBegin()
13692 
    while True:
13693 
      (fname, ftype, fid) = iprot.readFieldBegin()
13694 
      if ftype == TType.STOP:
13695 
        break
13696 
      if fid == 1:
13697 
        if ftype == TType.I64:
13698 
          self.providerId = iprot.readI64();
13699 
        else:
13700 
          iprot.skip(ftype)
13701 
      else:
13702 
        iprot.skip(ftype)
13703 
      iprot.readFieldEnd()
13704 
    iprot.readStructEnd()
13705 
 
13706 
  def write(self, oprot):
13707 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13708 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13709 
      return
13710 
    oprot.writeStructBegin('getRTOrders_args')
13711 
    if self.providerId is not None:
13712 
      oprot.writeFieldBegin('providerId', TType.I64, 1)
13713 
      oprot.writeI64(self.providerId)
13714 
      oprot.writeFieldEnd()
13715 
    oprot.writeFieldStop()
13716 
    oprot.writeStructEnd()
13717 
 
13718 
  def validate(self):
13719 
    return
13720 
 
13721 
 
13722 
  def __repr__(self):
13723 
    L = ['%s=%r' % (key, value)
13724 
      for key, value in self.__dict__.iteritems()]
13725 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13726 
 
13727 
  def __eq__(self, other):
13728 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13729 
 
13730 
  def __ne__(self, other):
13731 
    return not (self == other)
13732 
 
13733 
class getRTOrders_result:
13734 
  """
13735 
  Attributes:
13736 
   - success
13737 
  """
13738 
 
13739 
  thrift_spec = (
13740 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
13741 
  )
13742 
 
13743 
  def __init__(self, success=None,):
13744 
    self.success = success
13745 
 
13746 
  def read(self, iprot):
13747 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13748 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13749 
      return
13750 
    iprot.readStructBegin()
13751 
    while True:
13752 
      (fname, ftype, fid) = iprot.readFieldBegin()
13753 
      if ftype == TType.STOP:
13754 
        break
13755 
      if fid == 0:
13756 
        if ftype == TType.LIST:
13757 
          self.success = []
5713 rajveer 13758 
          (_etype296, _size293) = iprot.readListBegin()
13759 
          for _i297 in xrange(_size293):
13760 
            _elem298 = Order()
13761 
            _elem298.read(iprot)
13762 
            self.success.append(_elem298)
4910 phani.kuma 13763 
          iprot.readListEnd()
13764 
        else:
13765 
          iprot.skip(ftype)
13766 
      else:
13767 
        iprot.skip(ftype)
13768 
      iprot.readFieldEnd()
13769 
    iprot.readStructEnd()
13770 
 
13771 
  def write(self, oprot):
13772 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13773 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13774 
      return
13775 
    oprot.writeStructBegin('getRTOrders_result')
13776 
    if self.success is not None:
13777 
      oprot.writeFieldBegin('success', TType.LIST, 0)
13778 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
5713 rajveer 13779 
      for iter299 in self.success:
13780 
        iter299.write(oprot)
4910 phani.kuma 13781 
      oprot.writeListEnd()
13782 
      oprot.writeFieldEnd()
13783 
    oprot.writeFieldStop()
13784 
    oprot.writeStructEnd()
13785 
 
13786 
  def validate(self):
13787 
    return
13788 
 
13789 
 
13790 
  def __repr__(self):
13791 
    L = ['%s=%r' % (key, value)
13792 
      for key, value in self.__dict__.iteritems()]
13793 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13794 
 
13795 
  def __eq__(self, other):
13796 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13797 
 
13798 
  def __ne__(self, other):
13799 
    return not (self == other)
13800 
 
3064 chandransh 13801 
class updateNonDeliveryReason_args:
1627 ankur.sing 13802 
  """
13803 
  Attributes:
3064 chandransh 13804 
   - providerId
13805 
   - undeliveredOrders
1627 ankur.sing 13806 
  """
13807 
 
13808 
  thrift_spec = (
3064 chandransh 13809 
    None, # 0
13810 
    (1, TType.I64, 'providerId', None, None, ), # 1
13811 
    (2, TType.MAP, 'undeliveredOrders', (TType.STRING,None,TType.STRING,None), None, ), # 2
1627 ankur.sing 13812 
  )
13813 
 
3064 chandransh 13814 
  def __init__(self, providerId=None, undeliveredOrders=None,):
13815 
    self.providerId = providerId
13816 
    self.undeliveredOrders = undeliveredOrders
1627 ankur.sing 13817 
 
13818 
  def read(self, iprot):
13819 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13820 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13821 
      return
13822 
    iprot.readStructBegin()
13823 
    while True:
13824 
      (fname, ftype, fid) = iprot.readFieldBegin()
13825 
      if ftype == TType.STOP:
13826 
        break
3064 chandransh 13827 
      if fid == 1:
1627 ankur.sing 13828 
        if ftype == TType.I64:
3064 chandransh 13829 
          self.providerId = iprot.readI64();
1627 ankur.sing 13830 
        else:
13831 
          iprot.skip(ftype)
3064 chandransh 13832 
      elif fid == 2:
13833 
        if ftype == TType.MAP:
13834 
          self.undeliveredOrders = {}
5713 rajveer 13835 
          (_ktype301, _vtype302, _size300 ) = iprot.readMapBegin()
13836 
          for _i304 in xrange(_size300):
13837 
            _key305 = iprot.readString();
13838 
            _val306 = iprot.readString();
13839 
            self.undeliveredOrders[_key305] = _val306
3064 chandransh 13840 
          iprot.readMapEnd()
13841 
        else:
13842 
          iprot.skip(ftype)
1627 ankur.sing 13843 
      else:
13844 
        iprot.skip(ftype)
13845 
      iprot.readFieldEnd()
13846 
    iprot.readStructEnd()
13847 
 
13848 
  def write(self, oprot):
13849 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13850 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13851 
      return
3064 chandransh 13852 
    oprot.writeStructBegin('updateNonDeliveryReason_args')
3431 rajveer 13853 
    if self.providerId is not None:
3064 chandransh 13854 
      oprot.writeFieldBegin('providerId', TType.I64, 1)
13855 
      oprot.writeI64(self.providerId)
1627 ankur.sing 13856 
      oprot.writeFieldEnd()
3431 rajveer 13857 
    if self.undeliveredOrders is not None:
3064 chandransh 13858 
      oprot.writeFieldBegin('undeliveredOrders', TType.MAP, 2)
13859 
      oprot.writeMapBegin(TType.STRING, TType.STRING, len(self.undeliveredOrders))
5713 rajveer 13860 
      for kiter307,viter308 in self.undeliveredOrders.items():
13861 
        oprot.writeString(kiter307)
13862 
        oprot.writeString(viter308)
3064 chandransh 13863 
      oprot.writeMapEnd()
13864 
      oprot.writeFieldEnd()
1627 ankur.sing 13865 
    oprot.writeFieldStop()
13866 
    oprot.writeStructEnd()
13867 
 
3431 rajveer 13868 
  def validate(self):
13869 
    return
13870 
 
13871 
 
1627 ankur.sing 13872 
  def __repr__(self):
13873 
    L = ['%s=%r' % (key, value)
13874 
      for key, value in self.__dict__.iteritems()]
13875 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13876 
 
13877 
  def __eq__(self, other):
13878 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13879 
 
13880 
  def __ne__(self, other):
13881 
    return not (self == other)
13882 
 
3064 chandransh 13883 
class updateNonDeliveryReason_result:
1627 ankur.sing 13884 
  """
13885 
  Attributes:
3064 chandransh 13886 
   - ex
1627 ankur.sing 13887 
  """
13888 
 
13889 
  thrift_spec = (
4910 phani.kuma 13890 
    None, # 0
3064 chandransh 13891 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
1627 ankur.sing 13892 
  )
13893 
 
4910 phani.kuma 13894 
  def __init__(self, ex=None,):
3064 chandransh 13895 
    self.ex = ex
1627 ankur.sing 13896 
 
13897 
  def read(self, iprot):
13898 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13899 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13900 
      return
13901 
    iprot.readStructBegin()
13902 
    while True:
13903 
      (fname, ftype, fid) = iprot.readFieldBegin()
13904 
      if ftype == TType.STOP:
13905 
        break
4910 phani.kuma 13906 
      if fid == 1:
13907 
        if ftype == TType.STRUCT:
13908 
          self.ex = TransactionServiceException()
13909 
          self.ex.read(iprot)
13910 
        else:
13911 
          iprot.skip(ftype)
13912 
      else:
13913 
        iprot.skip(ftype)
13914 
      iprot.readFieldEnd()
13915 
    iprot.readStructEnd()
13916 
 
13917 
  def write(self, oprot):
13918 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13919 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13920 
      return
13921 
    oprot.writeStructBegin('updateNonDeliveryReason_result')
13922 
    if self.ex is not None:
13923 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
13924 
      self.ex.write(oprot)
13925 
      oprot.writeFieldEnd()
13926 
    oprot.writeFieldStop()
13927 
    oprot.writeStructEnd()
13928 
 
13929 
  def validate(self):
13930 
    return
13931 
 
13932 
 
13933 
  def __repr__(self):
13934 
    L = ['%s=%r' % (key, value)
13935 
      for key, value in self.__dict__.iteritems()]
13936 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13937 
 
13938 
  def __eq__(self, other):
13939 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13940 
 
13941 
  def __ne__(self, other):
13942 
    return not (self == other)
13943 
 
13944 
class getNonDeliveredOrdersbyCourier_args:
13945 
  """
13946 
  Attributes:
13947 
   - providerId
13948 
  """
13949 
 
13950 
  thrift_spec = (
13951 
    None, # 0
13952 
    (1, TType.I64, 'providerId', None, None, ), # 1
13953 
  )
13954 
 
13955 
  def __init__(self, providerId=None,):
13956 
    self.providerId = providerId
13957 
 
13958 
  def read(self, iprot):
13959 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13960 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13961 
      return
13962 
    iprot.readStructBegin()
13963 
    while True:
13964 
      (fname, ftype, fid) = iprot.readFieldBegin()
13965 
      if ftype == TType.STOP:
13966 
        break
13967 
      if fid == 1:
13968 
        if ftype == TType.I64:
13969 
          self.providerId = iprot.readI64();
13970 
        else:
13971 
          iprot.skip(ftype)
13972 
      else:
13973 
        iprot.skip(ftype)
13974 
      iprot.readFieldEnd()
13975 
    iprot.readStructEnd()
13976 
 
13977 
  def write(self, oprot):
13978 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13979 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13980 
      return
13981 
    oprot.writeStructBegin('getNonDeliveredOrdersbyCourier_args')
13982 
    if self.providerId is not None:
13983 
      oprot.writeFieldBegin('providerId', TType.I64, 1)
13984 
      oprot.writeI64(self.providerId)
13985 
      oprot.writeFieldEnd()
13986 
    oprot.writeFieldStop()
13987 
    oprot.writeStructEnd()
13988 
 
13989 
  def validate(self):
13990 
    return
13991 
 
13992 
 
13993 
  def __repr__(self):
13994 
    L = ['%s=%r' % (key, value)
13995 
      for key, value in self.__dict__.iteritems()]
13996 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13997 
 
13998 
  def __eq__(self, other):
13999 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14000 
 
14001 
  def __ne__(self, other):
14002 
    return not (self == other)
14003 
 
14004 
class getNonDeliveredOrdersbyCourier_result:
14005 
  """
14006 
  Attributes:
14007 
   - success
14008 
  """
14009 
 
14010 
  thrift_spec = (
14011 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
14012 
  )
14013 
 
14014 
  def __init__(self, success=None,):
14015 
    self.success = success
14016 
 
14017 
  def read(self, iprot):
14018 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14019 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14020 
      return
14021 
    iprot.readStructBegin()
14022 
    while True:
14023 
      (fname, ftype, fid) = iprot.readFieldBegin()
14024 
      if ftype == TType.STOP:
14025 
        break
4581 phani.kuma 14026 
      if fid == 0:
14027 
        if ftype == TType.LIST:
14028 
          self.success = []
5713 rajveer 14029 
          (_etype312, _size309) = iprot.readListBegin()
14030 
          for _i313 in xrange(_size309):
14031 
            _elem314 = Order()
14032 
            _elem314.read(iprot)
14033 
            self.success.append(_elem314)
4581 phani.kuma 14034 
          iprot.readListEnd()
14035 
        else:
14036 
          iprot.skip(ftype)
4910 phani.kuma 14037 
      else:
14038 
        iprot.skip(ftype)
14039 
      iprot.readFieldEnd()
14040 
    iprot.readStructEnd()
14041 
 
14042 
  def write(self, oprot):
14043 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14044 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14045 
      return
14046 
    oprot.writeStructBegin('getNonDeliveredOrdersbyCourier_result')
14047 
    if self.success is not None:
14048 
      oprot.writeFieldBegin('success', TType.LIST, 0)
14049 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
5713 rajveer 14050 
      for iter315 in self.success:
14051 
        iter315.write(oprot)
4910 phani.kuma 14052 
      oprot.writeListEnd()
14053 
      oprot.writeFieldEnd()
14054 
    oprot.writeFieldStop()
14055 
    oprot.writeStructEnd()
14056 
 
14057 
  def validate(self):
14058 
    return
14059 
 
14060 
 
14061 
  def __repr__(self):
14062 
    L = ['%s=%r' % (key, value)
14063 
      for key, value in self.__dict__.iteritems()]
14064 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14065 
 
14066 
  def __eq__(self, other):
14067 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14068 
 
14069 
  def __ne__(self, other):
14070 
    return not (self == other)
14071 
 
14072 
class markOrdersAsLocalConnected_args:
14073 
  """
14074 
  Attributes:
14075 
   - providerId
14076 
   - local_connected_orders
14077 
  """
14078 
 
14079 
  thrift_spec = (
14080 
    None, # 0
14081 
    (1, TType.I64, 'providerId', None, None, ), # 1
14082 
    (2, TType.MAP, 'local_connected_orders', (TType.STRING,None,TType.STRING,None), None, ), # 2
14083 
  )
14084 
 
14085 
  def __init__(self, providerId=None, local_connected_orders=None,):
14086 
    self.providerId = providerId
14087 
    self.local_connected_orders = local_connected_orders
14088 
 
14089 
  def read(self, iprot):
14090 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14091 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14092 
      return
14093 
    iprot.readStructBegin()
14094 
    while True:
14095 
      (fname, ftype, fid) = iprot.readFieldBegin()
14096 
      if ftype == TType.STOP:
14097 
        break
14098 
      if fid == 1:
14099 
        if ftype == TType.I64:
14100 
          self.providerId = iprot.readI64();
14101 
        else:
14102 
          iprot.skip(ftype)
14103 
      elif fid == 2:
14104 
        if ftype == TType.MAP:
14105 
          self.local_connected_orders = {}
5713 rajveer 14106 
          (_ktype317, _vtype318, _size316 ) = iprot.readMapBegin()
14107 
          for _i320 in xrange(_size316):
14108 
            _key321 = iprot.readString();
14109 
            _val322 = iprot.readString();
14110 
            self.local_connected_orders[_key321] = _val322
4910 phani.kuma 14111 
          iprot.readMapEnd()
14112 
        else:
14113 
          iprot.skip(ftype)
14114 
      else:
14115 
        iprot.skip(ftype)
14116 
      iprot.readFieldEnd()
14117 
    iprot.readStructEnd()
14118 
 
14119 
  def write(self, oprot):
14120 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14121 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14122 
      return
14123 
    oprot.writeStructBegin('markOrdersAsLocalConnected_args')
14124 
    if self.providerId is not None:
14125 
      oprot.writeFieldBegin('providerId', TType.I64, 1)
14126 
      oprot.writeI64(self.providerId)
14127 
      oprot.writeFieldEnd()
14128 
    if self.local_connected_orders is not None:
14129 
      oprot.writeFieldBegin('local_connected_orders', TType.MAP, 2)
14130 
      oprot.writeMapBegin(TType.STRING, TType.STRING, len(self.local_connected_orders))
5713 rajveer 14131 
      for kiter323,viter324 in self.local_connected_orders.items():
14132 
        oprot.writeString(kiter323)
14133 
        oprot.writeString(viter324)
4910 phani.kuma 14134 
      oprot.writeMapEnd()
14135 
      oprot.writeFieldEnd()
14136 
    oprot.writeFieldStop()
14137 
    oprot.writeStructEnd()
14138 
 
14139 
  def validate(self):
14140 
    return
14141 
 
14142 
 
14143 
  def __repr__(self):
14144 
    L = ['%s=%r' % (key, value)
14145 
      for key, value in self.__dict__.iteritems()]
14146 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14147 
 
14148 
  def __eq__(self, other):
14149 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14150 
 
14151 
  def __ne__(self, other):
14152 
    return not (self == other)
14153 
 
14154 
class markOrdersAsLocalConnected_result:
14155 
  """
14156 
  Attributes:
14157 
   - ex
14158 
  """
14159 
 
14160 
  thrift_spec = (
14161 
    None, # 0
14162 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
14163 
  )
14164 
 
14165 
  def __init__(self, ex=None,):
14166 
    self.ex = ex
14167 
 
14168 
  def read(self, iprot):
14169 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14170 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14171 
      return
14172 
    iprot.readStructBegin()
14173 
    while True:
14174 
      (fname, ftype, fid) = iprot.readFieldBegin()
14175 
      if ftype == TType.STOP:
14176 
        break
14177 
      if fid == 1:
3064 chandransh 14178 
        if ftype == TType.STRUCT:
14179 
          self.ex = TransactionServiceException()
14180 
          self.ex.read(iprot)
1627 ankur.sing 14181 
        else:
14182 
          iprot.skip(ftype)
14183 
      else:
14184 
        iprot.skip(ftype)
14185 
      iprot.readFieldEnd()
14186 
    iprot.readStructEnd()
14187 
 
14188 
  def write(self, oprot):
14189 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14190 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14191 
      return
4910 phani.kuma 14192 
    oprot.writeStructBegin('markOrdersAsLocalConnected_result')
14193 
    if self.ex is not None:
14194 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
14195 
      self.ex.write(oprot)
14196 
      oprot.writeFieldEnd()
14197 
    oprot.writeFieldStop()
14198 
    oprot.writeStructEnd()
14199 
 
14200 
  def validate(self):
14201 
    return
14202 
 
14203 
 
14204 
  def __repr__(self):
14205 
    L = ['%s=%r' % (key, value)
14206 
      for key, value in self.__dict__.iteritems()]
14207 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14208 
 
14209 
  def __eq__(self, other):
14210 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14211 
 
14212 
  def __ne__(self, other):
14213 
    return not (self == other)
14214 
 
14215 
class getOrdersNotLocalConnected_args:
14216 
  """
14217 
  Attributes:
14218 
   - providerId
14219 
  """
14220 
 
14221 
  thrift_spec = (
14222 
    None, # 0
14223 
    (1, TType.I64, 'providerId', None, None, ), # 1
14224 
  )
14225 
 
14226 
  def __init__(self, providerId=None,):
14227 
    self.providerId = providerId
14228 
 
14229 
  def read(self, iprot):
14230 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14231 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14232 
      return
14233 
    iprot.readStructBegin()
14234 
    while True:
14235 
      (fname, ftype, fid) = iprot.readFieldBegin()
14236 
      if ftype == TType.STOP:
14237 
        break
14238 
      if fid == 1:
14239 
        if ftype == TType.I64:
14240 
          self.providerId = iprot.readI64();
14241 
        else:
14242 
          iprot.skip(ftype)
14243 
      else:
14244 
        iprot.skip(ftype)
14245 
      iprot.readFieldEnd()
14246 
    iprot.readStructEnd()
14247 
 
14248 
  def write(self, oprot):
14249 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14250 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14251 
      return
14252 
    oprot.writeStructBegin('getOrdersNotLocalConnected_args')
14253 
    if self.providerId is not None:
14254 
      oprot.writeFieldBegin('providerId', TType.I64, 1)
14255 
      oprot.writeI64(self.providerId)
14256 
      oprot.writeFieldEnd()
14257 
    oprot.writeFieldStop()
14258 
    oprot.writeStructEnd()
14259 
 
14260 
  def validate(self):
14261 
    return
14262 
 
14263 
 
14264 
  def __repr__(self):
14265 
    L = ['%s=%r' % (key, value)
14266 
      for key, value in self.__dict__.iteritems()]
14267 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14268 
 
14269 
  def __eq__(self, other):
14270 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14271 
 
14272 
  def __ne__(self, other):
14273 
    return not (self == other)
14274 
 
14275 
class getOrdersNotLocalConnected_result:
14276 
  """
14277 
  Attributes:
14278 
   - success
14279 
  """
14280 
 
14281 
  thrift_spec = (
14282 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
14283 
  )
14284 
 
14285 
  def __init__(self, success=None,):
14286 
    self.success = success
14287 
 
14288 
  def read(self, iprot):
14289 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14290 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14291 
      return
14292 
    iprot.readStructBegin()
14293 
    while True:
14294 
      (fname, ftype, fid) = iprot.readFieldBegin()
14295 
      if ftype == TType.STOP:
14296 
        break
14297 
      if fid == 0:
14298 
        if ftype == TType.LIST:
14299 
          self.success = []
5713 rajveer 14300 
          (_etype328, _size325) = iprot.readListBegin()
14301 
          for _i329 in xrange(_size325):
14302 
            _elem330 = Order()
14303 
            _elem330.read(iprot)
14304 
            self.success.append(_elem330)
4910 phani.kuma 14305 
          iprot.readListEnd()
14306 
        else:
14307 
          iprot.skip(ftype)
14308 
      else:
14309 
        iprot.skip(ftype)
14310 
      iprot.readFieldEnd()
14311 
    iprot.readStructEnd()
14312 
 
14313 
  def write(self, oprot):
14314 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14315 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14316 
      return
14317 
    oprot.writeStructBegin('getOrdersNotLocalConnected_result')
4581 phani.kuma 14318 
    if self.success is not None:
14319 
      oprot.writeFieldBegin('success', TType.LIST, 0)
14320 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
5713 rajveer 14321 
      for iter331 in self.success:
14322 
        iter331.write(oprot)
4581 phani.kuma 14323 
      oprot.writeListEnd()
14324 
      oprot.writeFieldEnd()
4910 phani.kuma 14325 
    oprot.writeFieldStop()
14326 
    oprot.writeStructEnd()
14327 
 
14328 
  def validate(self):
14329 
    return
14330 
 
14331 
 
14332 
  def __repr__(self):
14333 
    L = ['%s=%r' % (key, value)
14334 
      for key, value in self.__dict__.iteritems()]
14335 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14336 
 
14337 
  def __eq__(self, other):
14338 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14339 
 
14340 
  def __ne__(self, other):
14341 
    return not (self == other)
14342 
 
14343 
class markOrdersAsDestinationCityReached_args:
14344 
  """
14345 
  Attributes:
14346 
   - providerId
14347 
   - destination_city_reached_orders
14348 
  """
14349 
 
14350 
  thrift_spec = (
14351 
    None, # 0
14352 
    (1, TType.I64, 'providerId', None, None, ), # 1
14353 
    (2, TType.MAP, 'destination_city_reached_orders', (TType.STRING,None,TType.STRING,None), None, ), # 2
14354 
  )
14355 
 
14356 
  def __init__(self, providerId=None, destination_city_reached_orders=None,):
14357 
    self.providerId = providerId
14358 
    self.destination_city_reached_orders = destination_city_reached_orders
14359 
 
14360 
  def read(self, iprot):
14361 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14362 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14363 
      return
14364 
    iprot.readStructBegin()
14365 
    while True:
14366 
      (fname, ftype, fid) = iprot.readFieldBegin()
14367 
      if ftype == TType.STOP:
14368 
        break
14369 
      if fid == 1:
14370 
        if ftype == TType.I64:
14371 
          self.providerId = iprot.readI64();
14372 
        else:
14373 
          iprot.skip(ftype)
14374 
      elif fid == 2:
14375 
        if ftype == TType.MAP:
14376 
          self.destination_city_reached_orders = {}
5713 rajveer 14377 
          (_ktype333, _vtype334, _size332 ) = iprot.readMapBegin()
14378 
          for _i336 in xrange(_size332):
14379 
            _key337 = iprot.readString();
14380 
            _val338 = iprot.readString();
14381 
            self.destination_city_reached_orders[_key337] = _val338
4910 phani.kuma 14382 
          iprot.readMapEnd()
14383 
        else:
14384 
          iprot.skip(ftype)
14385 
      else:
14386 
        iprot.skip(ftype)
14387 
      iprot.readFieldEnd()
14388 
    iprot.readStructEnd()
14389 
 
14390 
  def write(self, oprot):
14391 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14392 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14393 
      return
14394 
    oprot.writeStructBegin('markOrdersAsDestinationCityReached_args')
14395 
    if self.providerId is not None:
14396 
      oprot.writeFieldBegin('providerId', TType.I64, 1)
14397 
      oprot.writeI64(self.providerId)
14398 
      oprot.writeFieldEnd()
14399 
    if self.destination_city_reached_orders is not None:
14400 
      oprot.writeFieldBegin('destination_city_reached_orders', TType.MAP, 2)
14401 
      oprot.writeMapBegin(TType.STRING, TType.STRING, len(self.destination_city_reached_orders))
5713 rajveer 14402 
      for kiter339,viter340 in self.destination_city_reached_orders.items():
14403 
        oprot.writeString(kiter339)
14404 
        oprot.writeString(viter340)
4910 phani.kuma 14405 
      oprot.writeMapEnd()
14406 
      oprot.writeFieldEnd()
14407 
    oprot.writeFieldStop()
14408 
    oprot.writeStructEnd()
14409 
 
14410 
  def validate(self):
14411 
    return
14412 
 
14413 
 
14414 
  def __repr__(self):
14415 
    L = ['%s=%r' % (key, value)
14416 
      for key, value in self.__dict__.iteritems()]
14417 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14418 
 
14419 
  def __eq__(self, other):
14420 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14421 
 
14422 
  def __ne__(self, other):
14423 
    return not (self == other)
14424 
 
14425 
class markOrdersAsDestinationCityReached_result:
14426 
  """
14427 
  Attributes:
14428 
   - ex
14429 
  """
14430 
 
14431 
  thrift_spec = (
14432 
    None, # 0
14433 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
14434 
  )
14435 
 
14436 
  def __init__(self, ex=None,):
14437 
    self.ex = ex
14438 
 
14439 
  def read(self, iprot):
14440 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14441 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14442 
      return
14443 
    iprot.readStructBegin()
14444 
    while True:
14445 
      (fname, ftype, fid) = iprot.readFieldBegin()
14446 
      if ftype == TType.STOP:
14447 
        break
14448 
      if fid == 1:
14449 
        if ftype == TType.STRUCT:
14450 
          self.ex = TransactionServiceException()
14451 
          self.ex.read(iprot)
14452 
        else:
14453 
          iprot.skip(ftype)
14454 
      else:
14455 
        iprot.skip(ftype)
14456 
      iprot.readFieldEnd()
14457 
    iprot.readStructEnd()
14458 
 
14459 
  def write(self, oprot):
14460 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14461 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14462 
      return
14463 
    oprot.writeStructBegin('markOrdersAsDestinationCityReached_result')
3431 rajveer 14464 
    if self.ex is not None:
3064 chandransh 14465 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
14466 
      self.ex.write(oprot)
1627 ankur.sing 14467 
      oprot.writeFieldEnd()
14468 
    oprot.writeFieldStop()
14469 
    oprot.writeStructEnd()
14470 
 
3431 rajveer 14471 
  def validate(self):
14472 
    return
14473 
 
14474 
 
1627 ankur.sing 14475 
  def __repr__(self):
14476 
    L = ['%s=%r' % (key, value)
14477 
      for key, value in self.__dict__.iteritems()]
14478 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14479 
 
14480 
  def __eq__(self, other):
14481 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14482 
 
14483 
  def __ne__(self, other):
14484 
    return not (self == other)
14485 
 
4910 phani.kuma 14486 
class markOrdersAsFirstDeliveryAttempted_args:
14487 
  """
14488 
  Attributes:
14489 
   - providerId
14490 
   - first_atdl_orders
14491 
  """
14492 
 
14493 
  thrift_spec = (
14494 
    None, # 0
14495 
    (1, TType.I64, 'providerId', None, None, ), # 1
14496 
    (2, TType.MAP, 'first_atdl_orders', (TType.STRING,None,TType.STRING,None), None, ), # 2
14497 
  )
14498 
 
14499 
  def __init__(self, providerId=None, first_atdl_orders=None,):
14500 
    self.providerId = providerId
14501 
    self.first_atdl_orders = first_atdl_orders
14502 
 
14503 
  def read(self, iprot):
14504 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14505 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14506 
      return
14507 
    iprot.readStructBegin()
14508 
    while True:
14509 
      (fname, ftype, fid) = iprot.readFieldBegin()
14510 
      if ftype == TType.STOP:
14511 
        break
14512 
      if fid == 1:
14513 
        if ftype == TType.I64:
14514 
          self.providerId = iprot.readI64();
14515 
        else:
14516 
          iprot.skip(ftype)
14517 
      elif fid == 2:
14518 
        if ftype == TType.MAP:
14519 
          self.first_atdl_orders = {}
5713 rajveer 14520 
          (_ktype342, _vtype343, _size341 ) = iprot.readMapBegin()
14521 
          for _i345 in xrange(_size341):
14522 
            _key346 = iprot.readString();
14523 
            _val347 = iprot.readString();
14524 
            self.first_atdl_orders[_key346] = _val347
4910 phani.kuma 14525 
          iprot.readMapEnd()
14526 
        else:
14527 
          iprot.skip(ftype)
14528 
      else:
14529 
        iprot.skip(ftype)
14530 
      iprot.readFieldEnd()
14531 
    iprot.readStructEnd()
14532 
 
14533 
  def write(self, oprot):
14534 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14535 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14536 
      return
14537 
    oprot.writeStructBegin('markOrdersAsFirstDeliveryAttempted_args')
14538 
    if self.providerId is not None:
14539 
      oprot.writeFieldBegin('providerId', TType.I64, 1)
14540 
      oprot.writeI64(self.providerId)
14541 
      oprot.writeFieldEnd()
14542 
    if self.first_atdl_orders is not None:
14543 
      oprot.writeFieldBegin('first_atdl_orders', TType.MAP, 2)
14544 
      oprot.writeMapBegin(TType.STRING, TType.STRING, len(self.first_atdl_orders))
5713 rajveer 14545 
      for kiter348,viter349 in self.first_atdl_orders.items():
14546 
        oprot.writeString(kiter348)
14547 
        oprot.writeString(viter349)
4910 phani.kuma 14548 
      oprot.writeMapEnd()
14549 
      oprot.writeFieldEnd()
14550 
    oprot.writeFieldStop()
14551 
    oprot.writeStructEnd()
14552 
 
14553 
  def validate(self):
14554 
    return
14555 
 
14556 
 
14557 
  def __repr__(self):
14558 
    L = ['%s=%r' % (key, value)
14559 
      for key, value in self.__dict__.iteritems()]
14560 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14561 
 
14562 
  def __eq__(self, other):
14563 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14564 
 
14565 
  def __ne__(self, other):
14566 
    return not (self == other)
14567 
 
14568 
class markOrdersAsFirstDeliveryAttempted_result:
14569 
  """
14570 
  Attributes:
14571 
   - ex
14572 
  """
14573 
 
14574 
  thrift_spec = (
14575 
    None, # 0
14576 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
14577 
  )
14578 
 
14579 
  def __init__(self, ex=None,):
14580 
    self.ex = ex
14581 
 
14582 
  def read(self, iprot):
14583 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14584 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14585 
      return
14586 
    iprot.readStructBegin()
14587 
    while True:
14588 
      (fname, ftype, fid) = iprot.readFieldBegin()
14589 
      if ftype == TType.STOP:
14590 
        break
14591 
      if 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('markOrdersAsFirstDeliveryAttempted_result')
14607 
    if self.ex is not None:
14608 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
14609 
      self.ex.write(oprot)
14610 
      oprot.writeFieldEnd()
14611 
    oprot.writeFieldStop()
14612 
    oprot.writeStructEnd()
14613 
 
14614 
  def validate(self):
14615 
    return
14616 
 
14617 
 
14618 
  def __repr__(self):
14619 
    L = ['%s=%r' % (key, value)
14620 
      for key, value in self.__dict__.iteritems()]
14621 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14622 
 
14623 
  def __eq__(self, other):
14624 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14625 
 
14626 
  def __ne__(self, other):
14627 
    return not (self == other)
14628 
 
3064 chandransh 14629 
class getUndeliveredOrders_args:
1886 ankur.sing 14630 
  """
14631 
  Attributes:
3064 chandransh 14632 
   - providerId
14633 
   - warehouseId
1886 ankur.sing 14634 
  """
1627 ankur.sing 14635 
 
1886 ankur.sing 14636 
  thrift_spec = (
14637 
    None, # 0
3064 chandransh 14638 
    (1, TType.I64, 'providerId', None, None, ), # 1
14639 
    (2, TType.I64, 'warehouseId', None, None, ), # 2
1886 ankur.sing 14640 
  )
14641 
 
3064 chandransh 14642 
  def __init__(self, providerId=None, warehouseId=None,):
14643 
    self.providerId = providerId
14644 
    self.warehouseId = warehouseId
1886 ankur.sing 14645 
 
14646 
  def read(self, iprot):
14647 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14648 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14649 
      return
14650 
    iprot.readStructBegin()
14651 
    while True:
14652 
      (fname, ftype, fid) = iprot.readFieldBegin()
14653 
      if ftype == TType.STOP:
14654 
        break
14655 
      if fid == 1:
14656 
        if ftype == TType.I64:
3064 chandransh 14657 
          self.providerId = iprot.readI64();
1886 ankur.sing 14658 
        else:
14659 
          iprot.skip(ftype)
3064 chandransh 14660 
      elif fid == 2:
14661 
        if ftype == TType.I64:
14662 
          self.warehouseId = iprot.readI64();
14663 
        else:
14664 
          iprot.skip(ftype)
1886 ankur.sing 14665 
      else:
14666 
        iprot.skip(ftype)
14667 
      iprot.readFieldEnd()
14668 
    iprot.readStructEnd()
14669 
 
14670 
  def write(self, oprot):
14671 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14672 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14673 
      return
3064 chandransh 14674 
    oprot.writeStructBegin('getUndeliveredOrders_args')
3431 rajveer 14675 
    if self.providerId is not None:
3064 chandransh 14676 
      oprot.writeFieldBegin('providerId', TType.I64, 1)
14677 
      oprot.writeI64(self.providerId)
1886 ankur.sing 14678 
      oprot.writeFieldEnd()
3431 rajveer 14679 
    if self.warehouseId is not None:
3064 chandransh 14680 
      oprot.writeFieldBegin('warehouseId', TType.I64, 2)
14681 
      oprot.writeI64(self.warehouseId)
14682 
      oprot.writeFieldEnd()
1886 ankur.sing 14683 
    oprot.writeFieldStop()
14684 
    oprot.writeStructEnd()
14685 
 
3431 rajveer 14686 
  def validate(self):
14687 
    return
14688 
 
14689 
 
1886 ankur.sing 14690 
  def __repr__(self):
14691 
    L = ['%s=%r' % (key, value)
14692 
      for key, value in self.__dict__.iteritems()]
14693 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14694 
 
14695 
  def __eq__(self, other):
14696 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14697 
 
14698 
  def __ne__(self, other):
14699 
    return not (self == other)
14700 
 
3064 chandransh 14701 
class getUndeliveredOrders_result:
1886 ankur.sing 14702 
  """
14703 
  Attributes:
14704 
   - success
14705 
  """
14706 
 
14707 
  thrift_spec = (
14708 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
14709 
  )
14710 
 
14711 
  def __init__(self, success=None,):
14712 
    self.success = success
14713 
 
14714 
  def read(self, iprot):
14715 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14716 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14717 
      return
14718 
    iprot.readStructBegin()
14719 
    while True:
14720 
      (fname, ftype, fid) = iprot.readFieldBegin()
14721 
      if ftype == TType.STOP:
14722 
        break
14723 
      if fid == 0:
14724 
        if ftype == TType.LIST:
14725 
          self.success = []
5713 rajveer 14726 
          (_etype353, _size350) = iprot.readListBegin()
14727 
          for _i354 in xrange(_size350):
14728 
            _elem355 = Order()
14729 
            _elem355.read(iprot)
14730 
            self.success.append(_elem355)
1886 ankur.sing 14731 
          iprot.readListEnd()
14732 
        else:
14733 
          iprot.skip(ftype)
14734 
      else:
14735 
        iprot.skip(ftype)
14736 
      iprot.readFieldEnd()
14737 
    iprot.readStructEnd()
14738 
 
14739 
  def write(self, oprot):
14740 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14741 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14742 
      return
3064 chandransh 14743 
    oprot.writeStructBegin('getUndeliveredOrders_result')
3431 rajveer 14744 
    if self.success is not None:
1886 ankur.sing 14745 
      oprot.writeFieldBegin('success', TType.LIST, 0)
14746 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
5713 rajveer 14747 
      for iter356 in self.success:
14748 
        iter356.write(oprot)
1886 ankur.sing 14749 
      oprot.writeListEnd()
14750 
      oprot.writeFieldEnd()
14751 
    oprot.writeFieldStop()
14752 
    oprot.writeStructEnd()
14753 
 
3431 rajveer 14754 
  def validate(self):
14755 
    return
14756 
 
14757 
 
1886 ankur.sing 14758 
  def __repr__(self):
14759 
    L = ['%s=%r' % (key, value)
14760 
      for key, value in self.__dict__.iteritems()]
14761 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14762 
 
14763 
  def __eq__(self, other):
14764 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14765 
 
14766 
  def __ne__(self, other):
14767 
    return not (self == other)
14768 
 
4783 phani.kuma 14769 
class getUndeliveredOrdersExpectedDeliveryDateNotMet_args:
14770 
 
14771 
  thrift_spec = (
14772 
  )
14773 
 
14774 
  def read(self, iprot):
14775 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14776 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14777 
      return
14778 
    iprot.readStructBegin()
14779 
    while True:
14780 
      (fname, ftype, fid) = iprot.readFieldBegin()
14781 
      if ftype == TType.STOP:
14782 
        break
14783 
      else:
14784 
        iprot.skip(ftype)
14785 
      iprot.readFieldEnd()
14786 
    iprot.readStructEnd()
14787 
 
14788 
  def write(self, oprot):
14789 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14790 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14791 
      return
14792 
    oprot.writeStructBegin('getUndeliveredOrdersExpectedDeliveryDateNotMet_args')
14793 
    oprot.writeFieldStop()
14794 
    oprot.writeStructEnd()
14795 
 
14796 
  def validate(self):
14797 
    return
14798 
 
14799 
 
14800 
  def __repr__(self):
14801 
    L = ['%s=%r' % (key, value)
14802 
      for key, value in self.__dict__.iteritems()]
14803 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14804 
 
14805 
  def __eq__(self, other):
14806 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14807 
 
14808 
  def __ne__(self, other):
14809 
    return not (self == other)
14810 
 
14811 
class getUndeliveredOrdersExpectedDeliveryDateNotMet_result:
14812 
  """
14813 
  Attributes:
14814 
   - success
14815 
  """
14816 
 
14817 
  thrift_spec = (
14818 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
14819 
  )
14820 
 
14821 
  def __init__(self, success=None,):
14822 
    self.success = success
14823 
 
14824 
  def read(self, iprot):
14825 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14826 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14827 
      return
14828 
    iprot.readStructBegin()
14829 
    while True:
14830 
      (fname, ftype, fid) = iprot.readFieldBegin()
14831 
      if ftype == TType.STOP:
14832 
        break
14833 
      if fid == 0:
14834 
        if ftype == TType.LIST:
14835 
          self.success = []
5713 rajveer 14836 
          (_etype360, _size357) = iprot.readListBegin()
14837 
          for _i361 in xrange(_size357):
14838 
            _elem362 = Order()
14839 
            _elem362.read(iprot)
14840 
            self.success.append(_elem362)
4783 phani.kuma 14841 
          iprot.readListEnd()
14842 
        else:
14843 
          iprot.skip(ftype)
14844 
      else:
14845 
        iprot.skip(ftype)
14846 
      iprot.readFieldEnd()
14847 
    iprot.readStructEnd()
14848 
 
14849 
  def write(self, oprot):
14850 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14851 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14852 
      return
14853 
    oprot.writeStructBegin('getUndeliveredOrdersExpectedDeliveryDateNotMet_result')
14854 
    if self.success is not None:
14855 
      oprot.writeFieldBegin('success', TType.LIST, 0)
14856 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
5713 rajveer 14857 
      for iter363 in self.success:
14858 
        iter363.write(oprot)
4783 phani.kuma 14859 
      oprot.writeListEnd()
14860 
      oprot.writeFieldEnd()
14861 
    oprot.writeFieldStop()
14862 
    oprot.writeStructEnd()
14863 
 
14864 
  def validate(self):
14865 
    return
14866 
 
14867 
 
14868 
  def __repr__(self):
14869 
    L = ['%s=%r' % (key, value)
14870 
      for key, value in self.__dict__.iteritems()]
14871 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14872 
 
14873 
  def __eq__(self, other):
14874 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14875 
 
14876 
  def __ne__(self, other):
14877 
    return not (self == other)
14878 
 
2536 chandransh 14879 
class toggleDOAFlag_args:
14880 
  """
14881 
  Attributes:
14882 
   - orderId
14883 
  """
1886 ankur.sing 14884 
 
2536 chandransh 14885 
  thrift_spec = (
14886 
    None, # 0
14887 
    (1, TType.I64, 'orderId', None, None, ), # 1
14888 
  )
14889 
 
14890 
  def __init__(self, orderId=None,):
14891 
    self.orderId = orderId
14892 
 
14893 
  def read(self, iprot):
14894 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14895 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14896 
      return
14897 
    iprot.readStructBegin()
14898 
    while True:
14899 
      (fname, ftype, fid) = iprot.readFieldBegin()
14900 
      if ftype == TType.STOP:
14901 
        break
14902 
      if fid == 1:
14903 
        if ftype == TType.I64:
14904 
          self.orderId = iprot.readI64();
14905 
        else:
14906 
          iprot.skip(ftype)
14907 
      else:
14908 
        iprot.skip(ftype)
14909 
      iprot.readFieldEnd()
14910 
    iprot.readStructEnd()
14911 
 
14912 
  def write(self, oprot):
14913 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14914 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14915 
      return
14916 
    oprot.writeStructBegin('toggleDOAFlag_args')
3431 rajveer 14917 
    if self.orderId is not None:
2536 chandransh 14918 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
14919 
      oprot.writeI64(self.orderId)
14920 
      oprot.writeFieldEnd()
14921 
    oprot.writeFieldStop()
14922 
    oprot.writeStructEnd()
14923 
 
3431 rajveer 14924 
  def validate(self):
14925 
    return
14926 
 
14927 
 
2536 chandransh 14928 
  def __repr__(self):
14929 
    L = ['%s=%r' % (key, value)
14930 
      for key, value in self.__dict__.iteritems()]
14931 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14932 
 
14933 
  def __eq__(self, other):
14934 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14935 
 
14936 
  def __ne__(self, other):
14937 
    return not (self == other)
14938 
 
14939 
class toggleDOAFlag_result:
14940 
  """
14941 
  Attributes:
14942 
   - success
14943 
   - ex
14944 
  """
14945 
 
14946 
  thrift_spec = (
14947 
    (0, TType.BOOL, 'success', None, None, ), # 0
14948 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
14949 
  )
14950 
 
14951 
  def __init__(self, success=None, ex=None,):
14952 
    self.success = success
14953 
    self.ex = ex
14954 
 
14955 
  def read(self, iprot):
14956 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14957 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14958 
      return
14959 
    iprot.readStructBegin()
14960 
    while True:
14961 
      (fname, ftype, fid) = iprot.readFieldBegin()
14962 
      if ftype == TType.STOP:
14963 
        break
14964 
      if fid == 0:
14965 
        if ftype == TType.BOOL:
14966 
          self.success = iprot.readBool();
14967 
        else:
14968 
          iprot.skip(ftype)
14969 
      elif fid == 1:
14970 
        if ftype == TType.STRUCT:
14971 
          self.ex = TransactionServiceException()
14972 
          self.ex.read(iprot)
14973 
        else:
14974 
          iprot.skip(ftype)
14975 
      else:
14976 
        iprot.skip(ftype)
14977 
      iprot.readFieldEnd()
14978 
    iprot.readStructEnd()
14979 
 
14980 
  def write(self, oprot):
14981 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14982 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14983 
      return
14984 
    oprot.writeStructBegin('toggleDOAFlag_result')
3431 rajveer 14985 
    if self.success is not None:
2536 chandransh 14986 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
14987 
      oprot.writeBool(self.success)
14988 
      oprot.writeFieldEnd()
3431 rajveer 14989 
    if self.ex is not None:
2536 chandransh 14990 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
14991 
      self.ex.write(oprot)
14992 
      oprot.writeFieldEnd()
14993 
    oprot.writeFieldStop()
14994 
    oprot.writeStructEnd()
14995 
 
3431 rajveer 14996 
  def validate(self):
14997 
    return
14998 
 
14999 
 
2536 chandransh 15000 
  def __repr__(self):
15001 
    L = ['%s=%r' % (key, value)
15002 
      for key, value in self.__dict__.iteritems()]
15003 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15004 
 
15005 
  def __eq__(self, other):
15006 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15007 
 
15008 
  def __ne__(self, other):
15009 
    return not (self == other)
15010 
 
4712 rajveer 15011 
class markOrderAsDelivered_args:
15012 
  """
15013 
  Attributes:
15014 
   - orderId
15015 
   - deliveryTimestamp
15016 
   - receiver
15017 
  """
15018 
 
15019 
  thrift_spec = None
15020 
  def __init__(self, orderId=None, deliveryTimestamp=None, receiver=None,):
15021 
    self.orderId = orderId
15022 
    self.deliveryTimestamp = deliveryTimestamp
15023 
    self.receiver = receiver
15024 
 
15025 
  def read(self, iprot):
15026 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15027 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15028 
      return
15029 
    iprot.readStructBegin()
15030 
    while True:
15031 
      (fname, ftype, fid) = iprot.readFieldBegin()
15032 
      if ftype == TType.STOP:
15033 
        break
15034 
      if fid == 1:
15035 
        if ftype == TType.I64:
15036 
          self.orderId = iprot.readI64();
15037 
        else:
15038 
          iprot.skip(ftype)
15039 
      elif fid == 2:
15040 
        if ftype == TType.I64:
15041 
          self.deliveryTimestamp = iprot.readI64();
15042 
        else:
15043 
          iprot.skip(ftype)
15044 
      elif fid == -1:
15045 
        if ftype == TType.STRING:
15046 
          self.receiver = iprot.readString();
15047 
        else:
15048 
          iprot.skip(ftype)
15049 
      else:
15050 
        iprot.skip(ftype)
15051 
      iprot.readFieldEnd()
15052 
    iprot.readStructEnd()
15053 
 
15054 
  def write(self, oprot):
15055 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15056 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15057 
      return
15058 
    oprot.writeStructBegin('markOrderAsDelivered_args')
15059 
    if self.receiver is not None:
15060 
      oprot.writeFieldBegin('receiver', TType.STRING, -1)
15061 
      oprot.writeString(self.receiver)
15062 
      oprot.writeFieldEnd()
15063 
    if self.orderId is not None:
15064 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
15065 
      oprot.writeI64(self.orderId)
15066 
      oprot.writeFieldEnd()
15067 
    if self.deliveryTimestamp is not None:
15068 
      oprot.writeFieldBegin('deliveryTimestamp', TType.I64, 2)
15069 
      oprot.writeI64(self.deliveryTimestamp)
15070 
      oprot.writeFieldEnd()
15071 
    oprot.writeFieldStop()
15072 
    oprot.writeStructEnd()
15073 
 
15074 
  def validate(self):
15075 
    return
15076 
 
15077 
 
15078 
  def __repr__(self):
15079 
    L = ['%s=%r' % (key, value)
15080 
      for key, value in self.__dict__.iteritems()]
15081 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15082 
 
15083 
  def __eq__(self, other):
15084 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15085 
 
15086 
  def __ne__(self, other):
15087 
    return not (self == other)
15088 
 
15089 
class markOrderAsDelivered_result:
15090 
  """
15091 
  Attributes:
15092 
   - ex
15093 
  """
15094 
 
15095 
  thrift_spec = (
15096 
    None, # 0
15097 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
15098 
  )
15099 
 
15100 
  def __init__(self, ex=None,):
15101 
    self.ex = ex
15102 
 
15103 
  def read(self, iprot):
15104 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15105 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15106 
      return
15107 
    iprot.readStructBegin()
15108 
    while True:
15109 
      (fname, ftype, fid) = iprot.readFieldBegin()
15110 
      if ftype == TType.STOP:
15111 
        break
15112 
      if fid == 1:
15113 
        if ftype == TType.STRUCT:
15114 
          self.ex = TransactionServiceException()
15115 
          self.ex.read(iprot)
15116 
        else:
15117 
          iprot.skip(ftype)
15118 
      else:
15119 
        iprot.skip(ftype)
15120 
      iprot.readFieldEnd()
15121 
    iprot.readStructEnd()
15122 
 
15123 
  def write(self, oprot):
15124 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15125 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15126 
      return
15127 
    oprot.writeStructBegin('markOrderAsDelivered_result')
15128 
    if self.ex is not None:
15129 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
15130 
      self.ex.write(oprot)
15131 
      oprot.writeFieldEnd()
15132 
    oprot.writeFieldStop()
15133 
    oprot.writeStructEnd()
15134 
 
15135 
  def validate(self):
15136 
    return
15137 
 
15138 
 
15139 
  def __repr__(self):
15140 
    L = ['%s=%r' % (key, value)
15141 
      for key, value in self.__dict__.iteritems()]
15142 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15143 
 
15144 
  def __eq__(self, other):
15145 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15146 
 
15147 
  def __ne__(self, other):
15148 
    return not (self == other)
15149 
 
5553 rajveer 15150 
class markOrderAsReceivedAtStore_args:
15151 
  """
15152 
  Attributes:
15153 
   - orderId
15154 
   - deliveryTimestamp
15155 
  """
15156 
 
15157 
  thrift_spec = (
15158 
    None, # 0
15159 
    (1, TType.I64, 'orderId', None, None, ), # 1
15160 
    (2, TType.I64, 'deliveryTimestamp', None, None, ), # 2
15161 
  )
15162 
 
15163 
  def __init__(self, orderId=None, deliveryTimestamp=None,):
15164 
    self.orderId = orderId
15165 
    self.deliveryTimestamp = deliveryTimestamp
15166 
 
15167 
  def read(self, iprot):
15168 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15169 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15170 
      return
15171 
    iprot.readStructBegin()
15172 
    while True:
15173 
      (fname, ftype, fid) = iprot.readFieldBegin()
15174 
      if ftype == TType.STOP:
15175 
        break
15176 
      if fid == 1:
15177 
        if ftype == TType.I64:
15178 
          self.orderId = iprot.readI64();
15179 
        else:
15180 
          iprot.skip(ftype)
15181 
      elif fid == 2:
15182 
        if ftype == TType.I64:
15183 
          self.deliveryTimestamp = iprot.readI64();
15184 
        else:
15185 
          iprot.skip(ftype)
15186 
      else:
15187 
        iprot.skip(ftype)
15188 
      iprot.readFieldEnd()
15189 
    iprot.readStructEnd()
15190 
 
15191 
  def write(self, oprot):
15192 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15193 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15194 
      return
15195 
    oprot.writeStructBegin('markOrderAsReceivedAtStore_args')
15196 
    if self.orderId is not None:
15197 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
15198 
      oprot.writeI64(self.orderId)
15199 
      oprot.writeFieldEnd()
15200 
    if self.deliveryTimestamp is not None:
15201 
      oprot.writeFieldBegin('deliveryTimestamp', TType.I64, 2)
15202 
      oprot.writeI64(self.deliveryTimestamp)
15203 
      oprot.writeFieldEnd()
15204 
    oprot.writeFieldStop()
15205 
    oprot.writeStructEnd()
15206 
 
15207 
  def validate(self):
15208 
    return
15209 
 
15210 
 
15211 
  def __repr__(self):
15212 
    L = ['%s=%r' % (key, value)
15213 
      for key, value in self.__dict__.iteritems()]
15214 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15215 
 
15216 
  def __eq__(self, other):
15217 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15218 
 
15219 
  def __ne__(self, other):
15220 
    return not (self == other)
15221 
 
15222 
class markOrderAsReceivedAtStore_result:
15223 
  """
15224 
  Attributes:
15225 
   - ex
15226 
  """
15227 
 
15228 
  thrift_spec = (
15229 
    None, # 0
15230 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
15231 
  )
15232 
 
15233 
  def __init__(self, ex=None,):
15234 
    self.ex = ex
15235 
 
15236 
  def read(self, iprot):
15237 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15238 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15239 
      return
15240 
    iprot.readStructBegin()
15241 
    while True:
15242 
      (fname, ftype, fid) = iprot.readFieldBegin()
15243 
      if ftype == TType.STOP:
15244 
        break
15245 
      if fid == 1:
15246 
        if ftype == TType.STRUCT:
15247 
          self.ex = TransactionServiceException()
15248 
          self.ex.read(iprot)
15249 
        else:
15250 
          iprot.skip(ftype)
15251 
      else:
15252 
        iprot.skip(ftype)
15253 
      iprot.readFieldEnd()
15254 
    iprot.readStructEnd()
15255 
 
15256 
  def write(self, oprot):
15257 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15258 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15259 
      return
15260 
    oprot.writeStructBegin('markOrderAsReceivedAtStore_result')
15261 
    if self.ex is not None:
15262 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
15263 
      self.ex.write(oprot)
15264 
      oprot.writeFieldEnd()
15265 
    oprot.writeFieldStop()
15266 
    oprot.writeStructEnd()
15267 
 
15268 
  def validate(self):
15269 
    return
15270 
 
15271 
 
15272 
  def __repr__(self):
15273 
    L = ['%s=%r' % (key, value)
15274 
      for key, value in self.__dict__.iteritems()]
15275 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15276 
 
15277 
  def __eq__(self, other):
15278 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15279 
 
15280 
  def __ne__(self, other):
15281 
    return not (self == other)
15282 
 
4454 rajveer 15283 
class markOrderDoaRequestReceived_args:
15284 
  """
15285 
  Attributes:
15286 
   - orderId
15287 
  """
15288 
 
15289 
  thrift_spec = (
15290 
    None, # 0
15291 
    (1, TType.I64, 'orderId', None, None, ), # 1
15292 
  )
15293 
 
15294 
  def __init__(self, orderId=None,):
15295 
    self.orderId = orderId
15296 
 
15297 
  def read(self, iprot):
15298 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15299 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15300 
      return
15301 
    iprot.readStructBegin()
15302 
    while True:
15303 
      (fname, ftype, fid) = iprot.readFieldBegin()
15304 
      if ftype == TType.STOP:
15305 
        break
15306 
      if fid == 1:
15307 
        if ftype == TType.I64:
15308 
          self.orderId = iprot.readI64();
15309 
        else:
15310 
          iprot.skip(ftype)
15311 
      else:
15312 
        iprot.skip(ftype)
15313 
      iprot.readFieldEnd()
15314 
    iprot.readStructEnd()
15315 
 
15316 
  def write(self, oprot):
15317 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15318 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15319 
      return
15320 
    oprot.writeStructBegin('markOrderDoaRequestReceived_args')
15321 
    if self.orderId is not None:
15322 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
15323 
      oprot.writeI64(self.orderId)
15324 
      oprot.writeFieldEnd()
15325 
    oprot.writeFieldStop()
15326 
    oprot.writeStructEnd()
15327 
 
15328 
  def validate(self):
15329 
    return
15330 
 
15331 
 
15332 
  def __repr__(self):
15333 
    L = ['%s=%r' % (key, value)
15334 
      for key, value in self.__dict__.iteritems()]
15335 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15336 
 
15337 
  def __eq__(self, other):
15338 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15339 
 
15340 
  def __ne__(self, other):
15341 
    return not (self == other)
15342 
 
15343 
class markOrderDoaRequestReceived_result:
15344 
  """
15345 
  Attributes:
15346 
   - success
15347 
   - ex
15348 
  """
15349 
 
15350 
  thrift_spec = (
15351 
    (0, TType.BOOL, 'success', None, None, ), # 0
15352 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
15353 
  )
15354 
 
15355 
  def __init__(self, success=None, ex=None,):
15356 
    self.success = success
15357 
    self.ex = ex
15358 
 
15359 
  def read(self, iprot):
15360 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15361 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15362 
      return
15363 
    iprot.readStructBegin()
15364 
    while True:
15365 
      (fname, ftype, fid) = iprot.readFieldBegin()
15366 
      if ftype == TType.STOP:
15367 
        break
15368 
      if fid == 0:
15369 
        if ftype == TType.BOOL:
15370 
          self.success = iprot.readBool();
15371 
        else:
15372 
          iprot.skip(ftype)
15373 
      elif fid == 1:
15374 
        if ftype == TType.STRUCT:
15375 
          self.ex = TransactionServiceException()
15376 
          self.ex.read(iprot)
15377 
        else:
15378 
          iprot.skip(ftype)
15379 
      else:
15380 
        iprot.skip(ftype)
15381 
      iprot.readFieldEnd()
15382 
    iprot.readStructEnd()
15383 
 
15384 
  def write(self, oprot):
15385 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15386 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15387 
      return
15388 
    oprot.writeStructBegin('markOrderDoaRequestReceived_result')
15389 
    if self.success is not None:
15390 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
15391 
      oprot.writeBool(self.success)
15392 
      oprot.writeFieldEnd()
15393 
    if self.ex is not None:
15394 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
15395 
      self.ex.write(oprot)
15396 
      oprot.writeFieldEnd()
15397 
    oprot.writeFieldStop()
15398 
    oprot.writeStructEnd()
15399 
 
15400 
  def validate(self):
15401 
    return
15402 
 
15403 
 
15404 
  def __repr__(self):
15405 
    L = ['%s=%r' % (key, value)
15406 
      for key, value in self.__dict__.iteritems()]
15407 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15408 
 
15409 
  def __eq__(self, other):
15410 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15411 
 
15412 
  def __ne__(self, other):
15413 
    return not (self == other)
15414 
 
15415 
class markOrderDoaRequestAuthorized_args:
15416 
  """
15417 
  Attributes:
15418 
   - orderId
15419 
   - isAuthorized
15420 
  """
15421 
 
15422 
  thrift_spec = (
15423 
    None, # 0
15424 
    (1, TType.I64, 'orderId', None, None, ), # 1
15425 
    (2, TType.BOOL, 'isAuthorized', None, None, ), # 2
15426 
  )
15427 
 
15428 
  def __init__(self, orderId=None, isAuthorized=None,):
15429 
    self.orderId = orderId
15430 
    self.isAuthorized = isAuthorized
15431 
 
15432 
  def read(self, iprot):
15433 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15434 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15435 
      return
15436 
    iprot.readStructBegin()
15437 
    while True:
15438 
      (fname, ftype, fid) = iprot.readFieldBegin()
15439 
      if ftype == TType.STOP:
15440 
        break
15441 
      if fid == 1:
15442 
        if ftype == TType.I64:
15443 
          self.orderId = iprot.readI64();
15444 
        else:
15445 
          iprot.skip(ftype)
15446 
      elif fid == 2:
15447 
        if ftype == TType.BOOL:
15448 
          self.isAuthorized = iprot.readBool();
15449 
        else:
15450 
          iprot.skip(ftype)
15451 
      else:
15452 
        iprot.skip(ftype)
15453 
      iprot.readFieldEnd()
15454 
    iprot.readStructEnd()
15455 
 
15456 
  def write(self, oprot):
15457 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15458 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15459 
      return
15460 
    oprot.writeStructBegin('markOrderDoaRequestAuthorized_args')
15461 
    if self.orderId is not None:
15462 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
15463 
      oprot.writeI64(self.orderId)
15464 
      oprot.writeFieldEnd()
15465 
    if self.isAuthorized is not None:
15466 
      oprot.writeFieldBegin('isAuthorized', TType.BOOL, 2)
15467 
      oprot.writeBool(self.isAuthorized)
15468 
      oprot.writeFieldEnd()
15469 
    oprot.writeFieldStop()
15470 
    oprot.writeStructEnd()
15471 
 
15472 
  def validate(self):
15473 
    return
15474 
 
15475 
 
15476 
  def __repr__(self):
15477 
    L = ['%s=%r' % (key, value)
15478 
      for key, value in self.__dict__.iteritems()]
15479 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15480 
 
15481 
  def __eq__(self, other):
15482 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15483 
 
15484 
  def __ne__(self, other):
15485 
    return not (self == other)
15486 
 
15487 
class markOrderDoaRequestAuthorized_result:
15488 
  """
15489 
  Attributes:
15490 
   - success
15491 
   - ex
15492 
  """
15493 
 
15494 
  thrift_spec = (
15495 
    (0, TType.BOOL, 'success', None, None, ), # 0
15496 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
15497 
  )
15498 
 
15499 
  def __init__(self, success=None, ex=None,):
15500 
    self.success = success
15501 
    self.ex = ex
15502 
 
15503 
  def read(self, iprot):
15504 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15505 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15506 
      return
15507 
    iprot.readStructBegin()
15508 
    while True:
15509 
      (fname, ftype, fid) = iprot.readFieldBegin()
15510 
      if ftype == TType.STOP:
15511 
        break
15512 
      if fid == 0:
15513 
        if ftype == TType.BOOL:
15514 
          self.success = iprot.readBool();
15515 
        else:
15516 
          iprot.skip(ftype)
15517 
      elif fid == 1:
15518 
        if ftype == TType.STRUCT:
15519 
          self.ex = TransactionServiceException()
15520 
          self.ex.read(iprot)
15521 
        else:
15522 
          iprot.skip(ftype)
15523 
      else:
15524 
        iprot.skip(ftype)
15525 
      iprot.readFieldEnd()
15526 
    iprot.readStructEnd()
15527 
 
15528 
  def write(self, oprot):
15529 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15530 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15531 
      return
15532 
    oprot.writeStructBegin('markOrderDoaRequestAuthorized_result')
15533 
    if self.success is not None:
15534 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
15535 
      oprot.writeBool(self.success)
15536 
      oprot.writeFieldEnd()
15537 
    if self.ex is not None:
15538 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
15539 
      self.ex.write(oprot)
15540 
      oprot.writeFieldEnd()
15541 
    oprot.writeFieldStop()
15542 
    oprot.writeStructEnd()
15543 
 
15544 
  def validate(self):
15545 
    return
15546 
 
15547 
 
15548 
  def __repr__(self):
15549 
    L = ['%s=%r' % (key, value)
15550 
      for key, value in self.__dict__.iteritems()]
15551 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15552 
 
15553 
  def __eq__(self, other):
15554 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15555 
 
15556 
  def __ne__(self, other):
15557 
    return not (self == other)
15558 
 
4488 rajveer 15559 
class markOrderReturnRequestReceived_args:
15560 
  """
15561 
  Attributes:
15562 
   - orderId
15563 
  """
15564 
 
15565 
  thrift_spec = (
15566 
    None, # 0
15567 
    (1, TType.I64, 'orderId', None, None, ), # 1
15568 
  )
15569 
 
15570 
  def __init__(self, orderId=None,):
15571 
    self.orderId = orderId
15572 
 
15573 
  def read(self, iprot):
15574 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15575 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15576 
      return
15577 
    iprot.readStructBegin()
15578 
    while True:
15579 
      (fname, ftype, fid) = iprot.readFieldBegin()
15580 
      if ftype == TType.STOP:
15581 
        break
15582 
      if fid == 1:
15583 
        if ftype == TType.I64:
15584 
          self.orderId = iprot.readI64();
15585 
        else:
15586 
          iprot.skip(ftype)
15587 
      else:
15588 
        iprot.skip(ftype)
15589 
      iprot.readFieldEnd()
15590 
    iprot.readStructEnd()
15591 
 
15592 
  def write(self, oprot):
15593 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15594 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15595 
      return
15596 
    oprot.writeStructBegin('markOrderReturnRequestReceived_args')
15597 
    if self.orderId is not None:
15598 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
15599 
      oprot.writeI64(self.orderId)
15600 
      oprot.writeFieldEnd()
15601 
    oprot.writeFieldStop()
15602 
    oprot.writeStructEnd()
15603 
 
15604 
  def validate(self):
15605 
    return
15606 
 
15607 
 
15608 
  def __repr__(self):
15609 
    L = ['%s=%r' % (key, value)
15610 
      for key, value in self.__dict__.iteritems()]
15611 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15612 
 
15613 
  def __eq__(self, other):
15614 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15615 
 
15616 
  def __ne__(self, other):
15617 
    return not (self == other)
15618 
 
15619 
class markOrderReturnRequestReceived_result:
15620 
  """
15621 
  Attributes:
15622 
   - success
15623 
   - ex
15624 
  """
15625 
 
15626 
  thrift_spec = (
15627 
    (0, TType.BOOL, 'success', None, None, ), # 0
15628 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
15629 
  )
15630 
 
15631 
  def __init__(self, success=None, ex=None,):
15632 
    self.success = success
15633 
    self.ex = ex
15634 
 
15635 
  def read(self, iprot):
15636 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15637 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15638 
      return
15639 
    iprot.readStructBegin()
15640 
    while True:
15641 
      (fname, ftype, fid) = iprot.readFieldBegin()
15642 
      if ftype == TType.STOP:
15643 
        break
15644 
      if fid == 0:
15645 
        if ftype == TType.BOOL:
15646 
          self.success = iprot.readBool();
15647 
        else:
15648 
          iprot.skip(ftype)
15649 
      elif fid == 1:
15650 
        if ftype == TType.STRUCT:
15651 
          self.ex = TransactionServiceException()
15652 
          self.ex.read(iprot)
15653 
        else:
15654 
          iprot.skip(ftype)
15655 
      else:
15656 
        iprot.skip(ftype)
15657 
      iprot.readFieldEnd()
15658 
    iprot.readStructEnd()
15659 
 
15660 
  def write(self, oprot):
15661 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15662 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15663 
      return
15664 
    oprot.writeStructBegin('markOrderReturnRequestReceived_result')
15665 
    if self.success is not None:
15666 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
15667 
      oprot.writeBool(self.success)
15668 
      oprot.writeFieldEnd()
15669 
    if self.ex is not None:
15670 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
15671 
      self.ex.write(oprot)
15672 
      oprot.writeFieldEnd()
15673 
    oprot.writeFieldStop()
15674 
    oprot.writeStructEnd()
15675 
 
15676 
  def validate(self):
15677 
    return
15678 
 
15679 
 
15680 
  def __repr__(self):
15681 
    L = ['%s=%r' % (key, value)
15682 
      for key, value in self.__dict__.iteritems()]
15683 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15684 
 
15685 
  def __eq__(self, other):
15686 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15687 
 
15688 
  def __ne__(self, other):
15689 
    return not (self == other)
15690 
 
15691 
class markOrderReturnRequestAuthorized_args:
15692 
  """
15693 
  Attributes:
15694 
   - orderId
15695 
   - isAuthorized
15696 
  """
15697 
 
15698 
  thrift_spec = (
15699 
    None, # 0
15700 
    (1, TType.I64, 'orderId', None, None, ), # 1
15701 
    (2, TType.BOOL, 'isAuthorized', None, None, ), # 2
15702 
  )
15703 
 
15704 
  def __init__(self, orderId=None, isAuthorized=None,):
15705 
    self.orderId = orderId
15706 
    self.isAuthorized = isAuthorized
15707 
 
15708 
  def read(self, iprot):
15709 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15710 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15711 
      return
15712 
    iprot.readStructBegin()
15713 
    while True:
15714 
      (fname, ftype, fid) = iprot.readFieldBegin()
15715 
      if ftype == TType.STOP:
15716 
        break
15717 
      if fid == 1:
15718 
        if ftype == TType.I64:
15719 
          self.orderId = iprot.readI64();
15720 
        else:
15721 
          iprot.skip(ftype)
15722 
      elif fid == 2:
15723 
        if ftype == TType.BOOL:
15724 
          self.isAuthorized = iprot.readBool();
15725 
        else:
15726 
          iprot.skip(ftype)
15727 
      else:
15728 
        iprot.skip(ftype)
15729 
      iprot.readFieldEnd()
15730 
    iprot.readStructEnd()
15731 
 
15732 
  def write(self, oprot):
15733 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15734 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15735 
      return
15736 
    oprot.writeStructBegin('markOrderReturnRequestAuthorized_args')
15737 
    if self.orderId is not None:
15738 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
15739 
      oprot.writeI64(self.orderId)
15740 
      oprot.writeFieldEnd()
15741 
    if self.isAuthorized is not None:
15742 
      oprot.writeFieldBegin('isAuthorized', TType.BOOL, 2)
15743 
      oprot.writeBool(self.isAuthorized)
15744 
      oprot.writeFieldEnd()
15745 
    oprot.writeFieldStop()
15746 
    oprot.writeStructEnd()
15747 
 
15748 
  def validate(self):
15749 
    return
15750 
 
15751 
 
15752 
  def __repr__(self):
15753 
    L = ['%s=%r' % (key, value)
15754 
      for key, value in self.__dict__.iteritems()]
15755 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15756 
 
15757 
  def __eq__(self, other):
15758 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15759 
 
15760 
  def __ne__(self, other):
15761 
    return not (self == other)
15762 
 
15763 
class markOrderReturnRequestAuthorized_result:
15764 
  """
15765 
  Attributes:
15766 
   - success
15767 
   - ex
15768 
  """
15769 
 
15770 
  thrift_spec = (
15771 
    (0, TType.BOOL, 'success', None, None, ), # 0
15772 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
15773 
  )
15774 
 
15775 
  def __init__(self, success=None, ex=None,):
15776 
    self.success = success
15777 
    self.ex = ex
15778 
 
15779 
  def read(self, iprot):
15780 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15781 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15782 
      return
15783 
    iprot.readStructBegin()
15784 
    while True:
15785 
      (fname, ftype, fid) = iprot.readFieldBegin()
15786 
      if ftype == TType.STOP:
15787 
        break
15788 
      if fid == 0:
15789 
        if ftype == TType.BOOL:
15790 
          self.success = iprot.readBool();
15791 
        else:
15792 
          iprot.skip(ftype)
15793 
      elif fid == 1:
15794 
        if ftype == TType.STRUCT:
15795 
          self.ex = TransactionServiceException()
15796 
          self.ex.read(iprot)
15797 
        else:
15798 
          iprot.skip(ftype)
15799 
      else:
15800 
        iprot.skip(ftype)
15801 
      iprot.readFieldEnd()
15802 
    iprot.readStructEnd()
15803 
 
15804 
  def write(self, oprot):
15805 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15806 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15807 
      return
15808 
    oprot.writeStructBegin('markOrderReturnRequestAuthorized_result')
15809 
    if self.success is not None:
15810 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
15811 
      oprot.writeBool(self.success)
15812 
      oprot.writeFieldEnd()
15813 
    if self.ex is not None:
15814 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
15815 
      self.ex.write(oprot)
15816 
      oprot.writeFieldEnd()
15817 
    oprot.writeFieldStop()
15818 
    oprot.writeStructEnd()
15819 
 
15820 
  def validate(self):
15821 
    return
15822 
 
15823 
 
15824 
  def __repr__(self):
15825 
    L = ['%s=%r' % (key, value)
15826 
      for key, value in self.__dict__.iteritems()]
15827 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15828 
 
15829 
  def __eq__(self, other):
15830 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15831 
 
15832 
  def __ne__(self, other):
15833 
    return not (self == other)
15834 
 
2536 chandransh 15835 
class requestPickupNumber_args:
15836 
  """
15837 
  Attributes:
15838 
   - orderId
4579 rajveer 15839 
   - providerId
2536 chandransh 15840 
  """
15841 
 
15842 
  thrift_spec = (
15843 
    None, # 0
15844 
    (1, TType.I64, 'orderId', None, None, ), # 1
4579 rajveer 15845 
    (2, TType.I64, 'providerId', None, None, ), # 2
2536 chandransh 15846 
  )
15847 
 
4579 rajveer 15848 
  def __init__(self, orderId=None, providerId=None,):
2536 chandransh 15849 
    self.orderId = orderId
4579 rajveer 15850 
    self.providerId = providerId
2536 chandransh 15851 
 
15852 
  def read(self, iprot):
15853 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15854 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15855 
      return
15856 
    iprot.readStructBegin()
15857 
    while True:
15858 
      (fname, ftype, fid) = iprot.readFieldBegin()
15859 
      if ftype == TType.STOP:
15860 
        break
15861 
      if fid == 1:
15862 
        if ftype == TType.I64:
15863 
          self.orderId = iprot.readI64();
15864 
        else:
15865 
          iprot.skip(ftype)
4579 rajveer 15866 
      elif fid == 2:
15867 
        if ftype == TType.I64:
15868 
          self.providerId = iprot.readI64();
15869 
        else:
15870 
          iprot.skip(ftype)
2536 chandransh 15871 
      else:
15872 
        iprot.skip(ftype)
15873 
      iprot.readFieldEnd()
15874 
    iprot.readStructEnd()
15875 
 
15876 
  def write(self, oprot):
15877 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15878 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15879 
      return
15880 
    oprot.writeStructBegin('requestPickupNumber_args')
3431 rajveer 15881 
    if self.orderId is not None:
2536 chandransh 15882 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
15883 
      oprot.writeI64(self.orderId)
15884 
      oprot.writeFieldEnd()
4579 rajveer 15885 
    if self.providerId is not None:
15886 
      oprot.writeFieldBegin('providerId', TType.I64, 2)
15887 
      oprot.writeI64(self.providerId)
15888 
      oprot.writeFieldEnd()
2536 chandransh 15889 
    oprot.writeFieldStop()
15890 
    oprot.writeStructEnd()
15891 
 
3431 rajveer 15892 
  def validate(self):
15893 
    return
15894 
 
15895 
 
2536 chandransh 15896 
  def __repr__(self):
15897 
    L = ['%s=%r' % (key, value)
15898 
      for key, value in self.__dict__.iteritems()]
15899 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15900 
 
15901 
  def __eq__(self, other):
15902 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15903 
 
15904 
  def __ne__(self, other):
15905 
    return not (self == other)
15906 
 
15907 
class requestPickupNumber_result:
15908 
  """
15909 
  Attributes:
15910 
   - success
15911 
   - ex
15912 
  """
15913 
 
15914 
  thrift_spec = (
15915 
    (0, TType.BOOL, 'success', None, None, ), # 0
15916 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
15917 
  )
15918 
 
15919 
  def __init__(self, success=None, ex=None,):
15920 
    self.success = success
15921 
    self.ex = ex
15922 
 
15923 
  def read(self, iprot):
15924 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15925 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15926 
      return
15927 
    iprot.readStructBegin()
15928 
    while True:
15929 
      (fname, ftype, fid) = iprot.readFieldBegin()
15930 
      if ftype == TType.STOP:
15931 
        break
15932 
      if fid == 0:
15933 
        if ftype == TType.BOOL:
15934 
          self.success = iprot.readBool();
15935 
        else:
15936 
          iprot.skip(ftype)
15937 
      elif fid == 1:
15938 
        if ftype == TType.STRUCT:
15939 
          self.ex = TransactionServiceException()
15940 
          self.ex.read(iprot)
15941 
        else:
15942 
          iprot.skip(ftype)
15943 
      else:
15944 
        iprot.skip(ftype)
15945 
      iprot.readFieldEnd()
15946 
    iprot.readStructEnd()
15947 
 
15948 
  def write(self, oprot):
15949 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15950 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15951 
      return
15952 
    oprot.writeStructBegin('requestPickupNumber_result')
3431 rajveer 15953 
    if self.success is not None:
2536 chandransh 15954 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
15955 
      oprot.writeBool(self.success)
15956 
      oprot.writeFieldEnd()
3431 rajveer 15957 
    if self.ex is not None:
2536 chandransh 15958 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
15959 
      self.ex.write(oprot)
15960 
      oprot.writeFieldEnd()
15961 
    oprot.writeFieldStop()
15962 
    oprot.writeStructEnd()
15963 
 
3431 rajveer 15964 
  def validate(self):
15965 
    return
15966 
 
15967 
 
2536 chandransh 15968 
  def __repr__(self):
15969 
    L = ['%s=%r' % (key, value)
15970 
      for key, value in self.__dict__.iteritems()]
15971 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15972 
 
15973 
  def __eq__(self, other):
15974 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15975 
 
15976 
  def __ne__(self, other):
15977 
    return not (self == other)
15978 
 
15979 
class authorizePickup_args:
15980 
  """
15981 
  Attributes:
15982 
   - orderId
15983 
   - pickupNumber
4602 rajveer 15984 
   - providerId
2536 chandransh 15985 
  """
15986 
 
15987 
  thrift_spec = (
15988 
    None, # 0
15989 
    (1, TType.I64, 'orderId', None, None, ), # 1
15990 
    (2, TType.STRING, 'pickupNumber', None, None, ), # 2
4602 rajveer 15991 
    (3, TType.I64, 'providerId', None, None, ), # 3
2536 chandransh 15992 
  )
15993 
 
4602 rajveer 15994 
  def __init__(self, orderId=None, pickupNumber=None, providerId=None,):
2536 chandransh 15995 
    self.orderId = orderId
15996 
    self.pickupNumber = pickupNumber
4602 rajveer 15997 
    self.providerId = providerId
2536 chandransh 15998 
 
15999 
  def read(self, iprot):
16000 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16001 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16002 
      return
16003 
    iprot.readStructBegin()
16004 
    while True:
16005 
      (fname, ftype, fid) = iprot.readFieldBegin()
16006 
      if ftype == TType.STOP:
16007 
        break
16008 
      if fid == 1:
16009 
        if ftype == TType.I64:
16010 
          self.orderId = iprot.readI64();
16011 
        else:
16012 
          iprot.skip(ftype)
16013 
      elif fid == 2:
16014 
        if ftype == TType.STRING:
16015 
          self.pickupNumber = iprot.readString();
16016 
        else:
16017 
          iprot.skip(ftype)
4602 rajveer 16018 
      elif fid == 3:
16019 
        if ftype == TType.I64:
16020 
          self.providerId = iprot.readI64();
16021 
        else:
16022 
          iprot.skip(ftype)
2536 chandransh 16023 
      else:
16024 
        iprot.skip(ftype)
16025 
      iprot.readFieldEnd()
16026 
    iprot.readStructEnd()
16027 
 
16028 
  def write(self, oprot):
16029 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16030 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16031 
      return
16032 
    oprot.writeStructBegin('authorizePickup_args')
3431 rajveer 16033 
    if self.orderId is not None:
2536 chandransh 16034 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
16035 
      oprot.writeI64(self.orderId)
16036 
      oprot.writeFieldEnd()
3431 rajveer 16037 
    if self.pickupNumber is not None:
2536 chandransh 16038 
      oprot.writeFieldBegin('pickupNumber', TType.STRING, 2)
16039 
      oprot.writeString(self.pickupNumber)
16040 
      oprot.writeFieldEnd()
4602 rajveer 16041 
    if self.providerId is not None:
16042 
      oprot.writeFieldBegin('providerId', TType.I64, 3)
16043 
      oprot.writeI64(self.providerId)
16044 
      oprot.writeFieldEnd()
2536 chandransh 16045 
    oprot.writeFieldStop()
16046 
    oprot.writeStructEnd()
16047 
 
3431 rajveer 16048 
  def validate(self):
16049 
    return
16050 
 
16051 
 
2536 chandransh 16052 
  def __repr__(self):
16053 
    L = ['%s=%r' % (key, value)
16054 
      for key, value in self.__dict__.iteritems()]
16055 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16056 
 
16057 
  def __eq__(self, other):
16058 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16059 
 
16060 
  def __ne__(self, other):
16061 
    return not (self == other)
16062 
 
16063 
class authorizePickup_result:
16064 
  """
16065 
  Attributes:
16066 
   - success
16067 
   - ex
16068 
  """
16069 
 
16070 
  thrift_spec = (
16071 
    (0, TType.BOOL, 'success', None, None, ), # 0
16072 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
16073 
  )
16074 
 
16075 
  def __init__(self, success=None, ex=None,):
16076 
    self.success = success
16077 
    self.ex = ex
16078 
 
16079 
  def read(self, iprot):
16080 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16081 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16082 
      return
16083 
    iprot.readStructBegin()
16084 
    while True:
16085 
      (fname, ftype, fid) = iprot.readFieldBegin()
16086 
      if ftype == TType.STOP:
16087 
        break
16088 
      if fid == 0:
16089 
        if ftype == TType.BOOL:
16090 
          self.success = iprot.readBool();
16091 
        else:
16092 
          iprot.skip(ftype)
16093 
      elif fid == 1:
16094 
        if ftype == TType.STRUCT:
16095 
          self.ex = TransactionServiceException()
16096 
          self.ex.read(iprot)
16097 
        else:
16098 
          iprot.skip(ftype)
16099 
      else:
16100 
        iprot.skip(ftype)
16101 
      iprot.readFieldEnd()
16102 
    iprot.readStructEnd()
16103 
 
16104 
  def write(self, oprot):
16105 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16106 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16107 
      return
16108 
    oprot.writeStructBegin('authorizePickup_result')
3431 rajveer 16109 
    if self.success is not None:
2536 chandransh 16110 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
16111 
      oprot.writeBool(self.success)
16112 
      oprot.writeFieldEnd()
3431 rajveer 16113 
    if self.ex is not None:
2536 chandransh 16114 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
16115 
      self.ex.write(oprot)
16116 
      oprot.writeFieldEnd()
16117 
    oprot.writeFieldStop()
16118 
    oprot.writeStructEnd()
16119 
 
3431 rajveer 16120 
  def validate(self):
16121 
    return
16122 
 
16123 
 
2536 chandransh 16124 
  def __repr__(self):
16125 
    L = ['%s=%r' % (key, value)
16126 
      for key, value in self.__dict__.iteritems()]
16127 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16128 
 
16129 
  def __eq__(self, other):
16130 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16131 
 
16132 
  def __ne__(self, other):
16133 
    return not (self == other)
16134 
 
2764 chandransh 16135 
class markDoasAsPickedUp_args:
16136 
  """
16137 
  Attributes:
16138 
   - providerId
16139 
   - pickupDetails
16140 
  """
16141 
 
16142 
  thrift_spec = (
16143 
    None, # 0
16144 
    (1, TType.I64, 'providerId', None, None, ), # 1
16145 
    (2, TType.MAP, 'pickupDetails', (TType.STRING,None,TType.STRING,None), None, ), # 2
16146 
  )
16147 
 
16148 
  def __init__(self, providerId=None, pickupDetails=None,):
16149 
    self.providerId = providerId
16150 
    self.pickupDetails = pickupDetails
16151 
 
16152 
  def read(self, iprot):
16153 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16154 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16155 
      return
16156 
    iprot.readStructBegin()
16157 
    while True:
16158 
      (fname, ftype, fid) = iprot.readFieldBegin()
16159 
      if ftype == TType.STOP:
16160 
        break
16161 
      if fid == 1:
16162 
        if ftype == TType.I64:
16163 
          self.providerId = iprot.readI64();
16164 
        else:
16165 
          iprot.skip(ftype)
16166 
      elif fid == 2:
16167 
        if ftype == TType.MAP:
16168 
          self.pickupDetails = {}
5713 rajveer 16169 
          (_ktype365, _vtype366, _size364 ) = iprot.readMapBegin()
16170 
          for _i368 in xrange(_size364):
16171 
            _key369 = iprot.readString();
16172 
            _val370 = iprot.readString();
16173 
            self.pickupDetails[_key369] = _val370
2764 chandransh 16174 
          iprot.readMapEnd()
16175 
        else:
16176 
          iprot.skip(ftype)
16177 
      else:
16178 
        iprot.skip(ftype)
16179 
      iprot.readFieldEnd()
16180 
    iprot.readStructEnd()
16181 
 
16182 
  def write(self, oprot):
16183 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16184 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16185 
      return
16186 
    oprot.writeStructBegin('markDoasAsPickedUp_args')
3431 rajveer 16187 
    if self.providerId is not None:
2764 chandransh 16188 
      oprot.writeFieldBegin('providerId', TType.I64, 1)
16189 
      oprot.writeI64(self.providerId)
16190 
      oprot.writeFieldEnd()
3431 rajveer 16191 
    if self.pickupDetails is not None:
2764 chandransh 16192 
      oprot.writeFieldBegin('pickupDetails', TType.MAP, 2)
16193 
      oprot.writeMapBegin(TType.STRING, TType.STRING, len(self.pickupDetails))
5713 rajveer 16194 
      for kiter371,viter372 in self.pickupDetails.items():
16195 
        oprot.writeString(kiter371)
16196 
        oprot.writeString(viter372)
2764 chandransh 16197 
      oprot.writeMapEnd()
16198 
      oprot.writeFieldEnd()
16199 
    oprot.writeFieldStop()
16200 
    oprot.writeStructEnd()
16201 
 
3431 rajveer 16202 
  def validate(self):
16203 
    return
16204 
 
16205 
 
2764 chandransh 16206 
  def __repr__(self):
16207 
    L = ['%s=%r' % (key, value)
16208 
      for key, value in self.__dict__.iteritems()]
16209 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16210 
 
16211 
  def __eq__(self, other):
16212 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16213 
 
16214 
  def __ne__(self, other):
16215 
    return not (self == other)
16216 
 
16217 
class markDoasAsPickedUp_result:
4910 phani.kuma 16218 
 
16219 
  thrift_spec = (
16220 
  )
16221 
 
16222 
  def read(self, iprot):
16223 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16224 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16225 
      return
16226 
    iprot.readStructBegin()
16227 
    while True:
16228 
      (fname, ftype, fid) = iprot.readFieldBegin()
16229 
      if ftype == TType.STOP:
16230 
        break
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('markDoasAsPickedUp_result')
16241 
    oprot.writeFieldStop()
16242 
    oprot.writeStructEnd()
16243 
 
16244 
  def validate(self):
16245 
    return
16246 
 
16247 
 
16248 
  def __repr__(self):
16249 
    L = ['%s=%r' % (key, value)
16250 
      for key, value in self.__dict__.iteritems()]
16251 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16252 
 
16253 
  def __eq__(self, other):
16254 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16255 
 
16256 
  def __ne__(self, other):
16257 
    return not (self == other)
16258 
 
16259 
class getDoasNotPickedUp_args:
2764 chandransh 16260 
  """
16261 
  Attributes:
4910 phani.kuma 16262 
   - providerId
16263 
  """
16264 
 
16265 
  thrift_spec = (
16266 
    None, # 0
16267 
    (1, TType.I64, 'providerId', None, None, ), # 1
16268 
  )
16269 
 
16270 
  def __init__(self, providerId=None,):
16271 
    self.providerId = providerId
16272 
 
16273 
  def read(self, iprot):
16274 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16275 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16276 
      return
16277 
    iprot.readStructBegin()
16278 
    while True:
16279 
      (fname, ftype, fid) = iprot.readFieldBegin()
16280 
      if ftype == TType.STOP:
16281 
        break
16282 
      if fid == 1:
16283 
        if ftype == TType.I64:
16284 
          self.providerId = iprot.readI64();
16285 
        else:
16286 
          iprot.skip(ftype)
16287 
      else:
16288 
        iprot.skip(ftype)
16289 
      iprot.readFieldEnd()
16290 
    iprot.readStructEnd()
16291 
 
16292 
  def write(self, oprot):
16293 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16294 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16295 
      return
16296 
    oprot.writeStructBegin('getDoasNotPickedUp_args')
16297 
    if self.providerId is not None:
16298 
      oprot.writeFieldBegin('providerId', TType.I64, 1)
16299 
      oprot.writeI64(self.providerId)
16300 
      oprot.writeFieldEnd()
16301 
    oprot.writeFieldStop()
16302 
    oprot.writeStructEnd()
16303 
 
16304 
  def validate(self):
16305 
    return
16306 
 
16307 
 
16308 
  def __repr__(self):
16309 
    L = ['%s=%r' % (key, value)
16310 
      for key, value in self.__dict__.iteritems()]
16311 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16312 
 
16313 
  def __eq__(self, other):
16314 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16315 
 
16316 
  def __ne__(self, other):
16317 
    return not (self == other)
16318 
 
16319 
class getDoasNotPickedUp_result:
16320 
  """
16321 
  Attributes:
2764 chandransh 16322 
   - success
16323 
  """
16324 
 
16325 
  thrift_spec = (
16326 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
16327 
  )
16328 
 
16329 
  def __init__(self, success=None,):
16330 
    self.success = success
16331 
 
16332 
  def read(self, iprot):
16333 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16334 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16335 
      return
16336 
    iprot.readStructBegin()
16337 
    while True:
16338 
      (fname, ftype, fid) = iprot.readFieldBegin()
16339 
      if ftype == TType.STOP:
16340 
        break
16341 
      if fid == 0:
16342 
        if ftype == TType.LIST:
16343 
          self.success = []
5713 rajveer 16344 
          (_etype376, _size373) = iprot.readListBegin()
16345 
          for _i377 in xrange(_size373):
16346 
            _elem378 = Order()
16347 
            _elem378.read(iprot)
16348 
            self.success.append(_elem378)
2764 chandransh 16349 
          iprot.readListEnd()
16350 
        else:
16351 
          iprot.skip(ftype)
16352 
      else:
16353 
        iprot.skip(ftype)
16354 
      iprot.readFieldEnd()
16355 
    iprot.readStructEnd()
16356 
 
16357 
  def write(self, oprot):
16358 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16359 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16360 
      return
4910 phani.kuma 16361 
    oprot.writeStructBegin('getDoasNotPickedUp_result')
3431 rajveer 16362 
    if self.success is not None:
2764 chandransh 16363 
      oprot.writeFieldBegin('success', TType.LIST, 0)
16364 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
5713 rajveer 16365 
      for iter379 in self.success:
16366 
        iter379.write(oprot)
2764 chandransh 16367 
      oprot.writeListEnd()
16368 
      oprot.writeFieldEnd()
16369 
    oprot.writeFieldStop()
16370 
    oprot.writeStructEnd()
16371 
 
3431 rajveer 16372 
  def validate(self):
16373 
    return
16374 
 
16375 
 
2764 chandransh 16376 
  def __repr__(self):
16377 
    L = ['%s=%r' % (key, value)
16378 
      for key, value in self.__dict__.iteritems()]
16379 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16380 
 
16381 
  def __eq__(self, other):
16382 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16383 
 
16384 
  def __ne__(self, other):
16385 
    return not (self == other)
16386 
 
4741 phani.kuma 16387 
class markReturnOrdersAsPickedUp_args:
16388 
  """
16389 
  Attributes:
16390 
   - providerId
16391 
   - pickupDetails
16392 
  """
16393 
 
16394 
  thrift_spec = (
16395 
    None, # 0
16396 
    (1, TType.I64, 'providerId', None, None, ), # 1
16397 
    (2, TType.MAP, 'pickupDetails', (TType.STRING,None,TType.STRING,None), None, ), # 2
16398 
  )
16399 
 
16400 
  def __init__(self, providerId=None, pickupDetails=None,):
16401 
    self.providerId = providerId
16402 
    self.pickupDetails = pickupDetails
16403 
 
16404 
  def read(self, iprot):
16405 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16406 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16407 
      return
16408 
    iprot.readStructBegin()
16409 
    while True:
16410 
      (fname, ftype, fid) = iprot.readFieldBegin()
16411 
      if ftype == TType.STOP:
16412 
        break
16413 
      if fid == 1:
16414 
        if ftype == TType.I64:
16415 
          self.providerId = iprot.readI64();
16416 
        else:
16417 
          iprot.skip(ftype)
16418 
      elif fid == 2:
16419 
        if ftype == TType.MAP:
16420 
          self.pickupDetails = {}
5713 rajveer 16421 
          (_ktype381, _vtype382, _size380 ) = iprot.readMapBegin()
16422 
          for _i384 in xrange(_size380):
16423 
            _key385 = iprot.readString();
16424 
            _val386 = iprot.readString();
16425 
            self.pickupDetails[_key385] = _val386
4741 phani.kuma 16426 
          iprot.readMapEnd()
16427 
        else:
16428 
          iprot.skip(ftype)
16429 
      else:
16430 
        iprot.skip(ftype)
16431 
      iprot.readFieldEnd()
16432 
    iprot.readStructEnd()
16433 
 
16434 
  def write(self, oprot):
16435 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16436 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16437 
      return
16438 
    oprot.writeStructBegin('markReturnOrdersAsPickedUp_args')
16439 
    if self.providerId is not None:
16440 
      oprot.writeFieldBegin('providerId', TType.I64, 1)
16441 
      oprot.writeI64(self.providerId)
16442 
      oprot.writeFieldEnd()
16443 
    if self.pickupDetails is not None:
16444 
      oprot.writeFieldBegin('pickupDetails', TType.MAP, 2)
16445 
      oprot.writeMapBegin(TType.STRING, TType.STRING, len(self.pickupDetails))
5713 rajveer 16446 
      for kiter387,viter388 in self.pickupDetails.items():
16447 
        oprot.writeString(kiter387)
16448 
        oprot.writeString(viter388)
4741 phani.kuma 16449 
      oprot.writeMapEnd()
16450 
      oprot.writeFieldEnd()
16451 
    oprot.writeFieldStop()
16452 
    oprot.writeStructEnd()
16453 
 
16454 
  def validate(self):
16455 
    return
16456 
 
16457 
 
16458 
  def __repr__(self):
16459 
    L = ['%s=%r' % (key, value)
16460 
      for key, value in self.__dict__.iteritems()]
16461 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16462 
 
16463 
  def __eq__(self, other):
16464 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16465 
 
16466 
  def __ne__(self, other):
16467 
    return not (self == other)
16468 
 
16469 
class markReturnOrdersAsPickedUp_result:
4910 phani.kuma 16470 
 
16471 
  thrift_spec = (
16472 
  )
16473 
 
16474 
  def read(self, iprot):
16475 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16476 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16477 
      return
16478 
    iprot.readStructBegin()
16479 
    while True:
16480 
      (fname, ftype, fid) = iprot.readFieldBegin()
16481 
      if ftype == TType.STOP:
16482 
        break
16483 
      else:
16484 
        iprot.skip(ftype)
16485 
      iprot.readFieldEnd()
16486 
    iprot.readStructEnd()
16487 
 
16488 
  def write(self, oprot):
16489 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16490 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16491 
      return
16492 
    oprot.writeStructBegin('markReturnOrdersAsPickedUp_result')
16493 
    oprot.writeFieldStop()
16494 
    oprot.writeStructEnd()
16495 
 
16496 
  def validate(self):
16497 
    return
16498 
 
16499 
 
16500 
  def __repr__(self):
16501 
    L = ['%s=%r' % (key, value)
16502 
      for key, value in self.__dict__.iteritems()]
16503 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16504 
 
16505 
  def __eq__(self, other):
16506 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16507 
 
16508 
  def __ne__(self, other):
16509 
    return not (self == other)
16510 
 
16511 
class getReturnOrdersNotPickedUp_args:
4741 phani.kuma 16512 
  """
16513 
  Attributes:
4910 phani.kuma 16514 
   - providerId
16515 
  """
16516 
 
16517 
  thrift_spec = (
16518 
    None, # 0
16519 
    (1, TType.I64, 'providerId', None, None, ), # 1
16520 
  )
16521 
 
16522 
  def __init__(self, providerId=None,):
16523 
    self.providerId = providerId
16524 
 
16525 
  def read(self, iprot):
16526 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16527 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16528 
      return
16529 
    iprot.readStructBegin()
16530 
    while True:
16531 
      (fname, ftype, fid) = iprot.readFieldBegin()
16532 
      if ftype == TType.STOP:
16533 
        break
16534 
      if fid == 1:
16535 
        if ftype == TType.I64:
16536 
          self.providerId = iprot.readI64();
16537 
        else:
16538 
          iprot.skip(ftype)
16539 
      else:
16540 
        iprot.skip(ftype)
16541 
      iprot.readFieldEnd()
16542 
    iprot.readStructEnd()
16543 
 
16544 
  def write(self, oprot):
16545 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16546 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16547 
      return
16548 
    oprot.writeStructBegin('getReturnOrdersNotPickedUp_args')
16549 
    if self.providerId is not None:
16550 
      oprot.writeFieldBegin('providerId', TType.I64, 1)
16551 
      oprot.writeI64(self.providerId)
16552 
      oprot.writeFieldEnd()
16553 
    oprot.writeFieldStop()
16554 
    oprot.writeStructEnd()
16555 
 
16556 
  def validate(self):
16557 
    return
16558 
 
16559 
 
16560 
  def __repr__(self):
16561 
    L = ['%s=%r' % (key, value)
16562 
      for key, value in self.__dict__.iteritems()]
16563 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16564 
 
16565 
  def __eq__(self, other):
16566 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16567 
 
16568 
  def __ne__(self, other):
16569 
    return not (self == other)
16570 
 
16571 
class getReturnOrdersNotPickedUp_result:
16572 
  """
16573 
  Attributes:
4741 phani.kuma 16574 
   - success
16575 
  """
16576 
 
16577 
  thrift_spec = (
16578 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
16579 
  )
16580 
 
16581 
  def __init__(self, success=None,):
16582 
    self.success = success
16583 
 
16584 
  def read(self, iprot):
16585 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16586 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16587 
      return
16588 
    iprot.readStructBegin()
16589 
    while True:
16590 
      (fname, ftype, fid) = iprot.readFieldBegin()
16591 
      if ftype == TType.STOP:
16592 
        break
16593 
      if fid == 0:
16594 
        if ftype == TType.LIST:
16595 
          self.success = []
5713 rajveer 16596 
          (_etype392, _size389) = iprot.readListBegin()
16597 
          for _i393 in xrange(_size389):
16598 
            _elem394 = Order()
16599 
            _elem394.read(iprot)
16600 
            self.success.append(_elem394)
4741 phani.kuma 16601 
          iprot.readListEnd()
16602 
        else:
16603 
          iprot.skip(ftype)
16604 
      else:
16605 
        iprot.skip(ftype)
16606 
      iprot.readFieldEnd()
16607 
    iprot.readStructEnd()
16608 
 
16609 
  def write(self, oprot):
16610 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16611 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16612 
      return
4910 phani.kuma 16613 
    oprot.writeStructBegin('getReturnOrdersNotPickedUp_result')
4741 phani.kuma 16614 
    if self.success is not None:
16615 
      oprot.writeFieldBegin('success', TType.LIST, 0)
16616 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
5713 rajveer 16617 
      for iter395 in self.success:
16618 
        iter395.write(oprot)
4741 phani.kuma 16619 
      oprot.writeListEnd()
16620 
      oprot.writeFieldEnd()
16621 
    oprot.writeFieldStop()
16622 
    oprot.writeStructEnd()
16623 
 
16624 
  def validate(self):
16625 
    return
16626 
 
16627 
 
16628 
  def __repr__(self):
16629 
    L = ['%s=%r' % (key, value)
16630 
      for key, value in self.__dict__.iteritems()]
16631 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16632 
 
16633 
  def __eq__(self, other):
16634 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16635 
 
16636 
  def __ne__(self, other):
16637 
    return not (self == other)
16638 
 
2616 chandransh 16639 
class receiveReturn_args:
2591 chandransh 16640 
  """
16641 
  Attributes:
16642 
   - orderId
4479 rajveer 16643 
   - receiveCondition
2591 chandransh 16644 
  """
2536 chandransh 16645 
 
2591 chandransh 16646 
  thrift_spec = (
16647 
    None, # 0
16648 
    (1, TType.I64, 'orderId', None, None, ), # 1
4479 rajveer 16649 
    (2, TType.I64, 'receiveCondition', None, None, ), # 2
2591 chandransh 16650 
  )
16651 
 
4479 rajveer 16652 
  def __init__(self, orderId=None, receiveCondition=None,):
2591 chandransh 16653 
    self.orderId = orderId
4479 rajveer 16654 
    self.receiveCondition = receiveCondition
2591 chandransh 16655 
 
16656 
  def read(self, iprot):
16657 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16658 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16659 
      return
16660 
    iprot.readStructBegin()
16661 
    while True:
16662 
      (fname, ftype, fid) = iprot.readFieldBegin()
16663 
      if ftype == TType.STOP:
16664 
        break
16665 
      if fid == 1:
16666 
        if ftype == TType.I64:
16667 
          self.orderId = iprot.readI64();
16668 
        else:
16669 
          iprot.skip(ftype)
4479 rajveer 16670 
      elif fid == 2:
16671 
        if ftype == TType.I64:
16672 
          self.receiveCondition = iprot.readI64();
16673 
        else:
16674 
          iprot.skip(ftype)
2591 chandransh 16675 
      else:
16676 
        iprot.skip(ftype)
16677 
      iprot.readFieldEnd()
16678 
    iprot.readStructEnd()
16679 
 
16680 
  def write(self, oprot):
16681 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16682 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16683 
      return
2616 chandransh 16684 
    oprot.writeStructBegin('receiveReturn_args')
3431 rajveer 16685 
    if self.orderId is not None:
2591 chandransh 16686 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
16687 
      oprot.writeI64(self.orderId)
16688 
      oprot.writeFieldEnd()
4479 rajveer 16689 
    if self.receiveCondition is not None:
16690 
      oprot.writeFieldBegin('receiveCondition', TType.I64, 2)
16691 
      oprot.writeI64(self.receiveCondition)
16692 
      oprot.writeFieldEnd()
2591 chandransh 16693 
    oprot.writeFieldStop()
16694 
    oprot.writeStructEnd()
16695 
 
3431 rajveer 16696 
  def validate(self):
16697 
    return
16698 
 
16699 
 
2591 chandransh 16700 
  def __repr__(self):
16701 
    L = ['%s=%r' % (key, value)
16702 
      for key, value in self.__dict__.iteritems()]
16703 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16704 
 
16705 
  def __eq__(self, other):
16706 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16707 
 
16708 
  def __ne__(self, other):
16709 
    return not (self == other)
16710 
 
2616 chandransh 16711 
class receiveReturn_result:
2591 chandransh 16712 
  """
16713 
  Attributes:
16714 
   - success
16715 
   - ex
16716 
  """
16717 
 
16718 
  thrift_spec = (
16719 
    (0, TType.BOOL, 'success', None, None, ), # 0
16720 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
16721 
  )
16722 
 
16723 
  def __init__(self, success=None, ex=None,):
16724 
    self.success = success
16725 
    self.ex = ex
16726 
 
16727 
  def read(self, iprot):
16728 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16729 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16730 
      return
16731 
    iprot.readStructBegin()
16732 
    while True:
16733 
      (fname, ftype, fid) = iprot.readFieldBegin()
16734 
      if ftype == TType.STOP:
16735 
        break
16736 
      if fid == 0:
16737 
        if ftype == TType.BOOL:
16738 
          self.success = iprot.readBool();
16739 
        else:
16740 
          iprot.skip(ftype)
16741 
      elif fid == 1:
16742 
        if ftype == TType.STRUCT:
16743 
          self.ex = TransactionServiceException()
16744 
          self.ex.read(iprot)
16745 
        else:
16746 
          iprot.skip(ftype)
16747 
      else:
16748 
        iprot.skip(ftype)
16749 
      iprot.readFieldEnd()
16750 
    iprot.readStructEnd()
16751 
 
16752 
  def write(self, oprot):
16753 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16754 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16755 
      return
2616 chandransh 16756 
    oprot.writeStructBegin('receiveReturn_result')
3431 rajveer 16757 
    if self.success is not None:
2591 chandransh 16758 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
16759 
      oprot.writeBool(self.success)
16760 
      oprot.writeFieldEnd()
3431 rajveer 16761 
    if self.ex is not None:
2591 chandransh 16762 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
16763 
      self.ex.write(oprot)
16764 
      oprot.writeFieldEnd()
16765 
    oprot.writeFieldStop()
16766 
    oprot.writeStructEnd()
16767 
 
3431 rajveer 16768 
  def validate(self):
16769 
    return
16770 
 
16771 
 
2591 chandransh 16772 
  def __repr__(self):
16773 
    L = ['%s=%r' % (key, value)
16774 
      for key, value in self.__dict__.iteritems()]
16775 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16776 
 
16777 
  def __eq__(self, other):
16778 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16779 
 
16780 
  def __ne__(self, other):
16781 
    return not (self == other)
16782 
 
16783 
class validateDoa_args:
16784 
  """
16785 
  Attributes:
16786 
   - orderId
16787 
   - isValid
16788 
  """
16789 
 
16790 
  thrift_spec = (
16791 
    None, # 0
16792 
    (1, TType.I64, 'orderId', None, None, ), # 1
16793 
    (2, TType.BOOL, 'isValid', None, None, ), # 2
16794 
  )
16795 
 
16796 
  def __init__(self, orderId=None, isValid=None,):
16797 
    self.orderId = orderId
16798 
    self.isValid = isValid
16799 
 
16800 
  def read(self, iprot):
16801 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16802 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16803 
      return
16804 
    iprot.readStructBegin()
16805 
    while True:
16806 
      (fname, ftype, fid) = iprot.readFieldBegin()
16807 
      if ftype == TType.STOP:
16808 
        break
16809 
      if fid == 1:
16810 
        if ftype == TType.I64:
16811 
          self.orderId = iprot.readI64();
16812 
        else:
16813 
          iprot.skip(ftype)
16814 
      elif fid == 2:
16815 
        if ftype == TType.BOOL:
16816 
          self.isValid = iprot.readBool();
16817 
        else:
16818 
          iprot.skip(ftype)
16819 
      else:
16820 
        iprot.skip(ftype)
16821 
      iprot.readFieldEnd()
16822 
    iprot.readStructEnd()
16823 
 
16824 
  def write(self, oprot):
16825 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16826 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16827 
      return
16828 
    oprot.writeStructBegin('validateDoa_args')
3431 rajveer 16829 
    if self.orderId is not None:
2591 chandransh 16830 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
16831 
      oprot.writeI64(self.orderId)
16832 
      oprot.writeFieldEnd()
3431 rajveer 16833 
    if self.isValid is not None:
2591 chandransh 16834 
      oprot.writeFieldBegin('isValid', TType.BOOL, 2)
16835 
      oprot.writeBool(self.isValid)
16836 
      oprot.writeFieldEnd()
16837 
    oprot.writeFieldStop()
16838 
    oprot.writeStructEnd()
16839 
 
3431 rajveer 16840 
  def validate(self):
16841 
    return
16842 
 
16843 
 
2591 chandransh 16844 
  def __repr__(self):
16845 
    L = ['%s=%r' % (key, value)
16846 
      for key, value in self.__dict__.iteritems()]
16847 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16848 
 
16849 
  def __eq__(self, other):
16850 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16851 
 
16852 
  def __ne__(self, other):
16853 
    return not (self == other)
16854 
 
16855 
class validateDoa_result:
16856 
  """
16857 
  Attributes:
16858 
   - success
16859 
   - ex
16860 
  """
16861 
 
16862 
  thrift_spec = (
16863 
    (0, TType.BOOL, 'success', None, None, ), # 0
16864 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
16865 
  )
16866 
 
16867 
  def __init__(self, success=None, ex=None,):
16868 
    self.success = success
16869 
    self.ex = ex
16870 
 
16871 
  def read(self, iprot):
16872 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16873 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16874 
      return
16875 
    iprot.readStructBegin()
16876 
    while True:
16877 
      (fname, ftype, fid) = iprot.readFieldBegin()
16878 
      if ftype == TType.STOP:
16879 
        break
16880 
      if fid == 0:
16881 
        if ftype == TType.BOOL:
16882 
          self.success = iprot.readBool();
16883 
        else:
16884 
          iprot.skip(ftype)
16885 
      elif fid == 1:
16886 
        if ftype == TType.STRUCT:
16887 
          self.ex = TransactionServiceException()
16888 
          self.ex.read(iprot)
16889 
        else:
16890 
          iprot.skip(ftype)
16891 
      else:
16892 
        iprot.skip(ftype)
16893 
      iprot.readFieldEnd()
16894 
    iprot.readStructEnd()
16895 
 
16896 
  def write(self, oprot):
16897 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16898 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16899 
      return
16900 
    oprot.writeStructBegin('validateDoa_result')
3431 rajveer 16901 
    if self.success is not None:
2591 chandransh 16902 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
16903 
      oprot.writeBool(self.success)
16904 
      oprot.writeFieldEnd()
3431 rajveer 16905 
    if self.ex is not None:
2591 chandransh 16906 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
16907 
      self.ex.write(oprot)
16908 
      oprot.writeFieldEnd()
16909 
    oprot.writeFieldStop()
16910 
    oprot.writeStructEnd()
16911 
 
3431 rajveer 16912 
  def validate(self):
16913 
    return
16914 
 
16915 
 
2591 chandransh 16916 
  def __repr__(self):
16917 
    L = ['%s=%r' % (key, value)
16918 
      for key, value in self.__dict__.iteritems()]
16919 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16920 
 
16921 
  def __eq__(self, other):
16922 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16923 
 
16924 
  def __ne__(self, other):
16925 
    return not (self == other)
16926 
 
4495 rajveer 16927 
class validateReturnProduct_args:
16928 
  """
16929 
  Attributes:
16930 
   - orderId
16931 
   - isUsable
16932 
  """
16933 
 
16934 
  thrift_spec = (
16935 
    None, # 0
16936 
    (1, TType.I64, 'orderId', None, None, ), # 1
16937 
    (2, TType.BOOL, 'isUsable', None, None, ), # 2
16938 
  )
16939 
 
16940 
  def __init__(self, orderId=None, isUsable=None,):
16941 
    self.orderId = orderId
16942 
    self.isUsable = isUsable
16943 
 
16944 
  def read(self, iprot):
16945 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16946 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16947 
      return
16948 
    iprot.readStructBegin()
16949 
    while True:
16950 
      (fname, ftype, fid) = iprot.readFieldBegin()
16951 
      if ftype == TType.STOP:
16952 
        break
16953 
      if fid == 1:
16954 
        if ftype == TType.I64:
16955 
          self.orderId = iprot.readI64();
16956 
        else:
16957 
          iprot.skip(ftype)
16958 
      elif fid == 2:
16959 
        if ftype == TType.BOOL:
16960 
          self.isUsable = iprot.readBool();
16961 
        else:
16962 
          iprot.skip(ftype)
16963 
      else:
16964 
        iprot.skip(ftype)
16965 
      iprot.readFieldEnd()
16966 
    iprot.readStructEnd()
16967 
 
16968 
  def write(self, oprot):
16969 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16970 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16971 
      return
16972 
    oprot.writeStructBegin('validateReturnProduct_args')
16973 
    if self.orderId is not None:
16974 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
16975 
      oprot.writeI64(self.orderId)
16976 
      oprot.writeFieldEnd()
16977 
    if self.isUsable is not None:
16978 
      oprot.writeFieldBegin('isUsable', TType.BOOL, 2)
16979 
      oprot.writeBool(self.isUsable)
16980 
      oprot.writeFieldEnd()
16981 
    oprot.writeFieldStop()
16982 
    oprot.writeStructEnd()
16983 
 
16984 
  def validate(self):
16985 
    return
16986 
 
16987 
 
16988 
  def __repr__(self):
16989 
    L = ['%s=%r' % (key, value)
16990 
      for key, value in self.__dict__.iteritems()]
16991 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16992 
 
16993 
  def __eq__(self, other):
16994 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16995 
 
16996 
  def __ne__(self, other):
16997 
    return not (self == other)
16998 
 
16999 
class validateReturnProduct_result:
17000 
  """
17001 
  Attributes:
17002 
   - success
17003 
   - ex
17004 
  """
17005 
 
17006 
  thrift_spec = (
17007 
    (0, TType.BOOL, 'success', None, None, ), # 0
17008 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
17009 
  )
17010 
 
17011 
  def __init__(self, success=None, ex=None,):
17012 
    self.success = success
17013 
    self.ex = ex
17014 
 
17015 
  def read(self, iprot):
17016 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
17017 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
17018 
      return
17019 
    iprot.readStructBegin()
17020 
    while True:
17021 
      (fname, ftype, fid) = iprot.readFieldBegin()
17022 
      if ftype == TType.STOP:
17023 
        break
17024 
      if fid == 0:
17025 
        if ftype == TType.BOOL:
17026 
          self.success = iprot.readBool();
17027 
        else:
17028 
          iprot.skip(ftype)
17029 
      elif fid == 1:
17030 
        if ftype == TType.STRUCT:
17031 
          self.ex = TransactionServiceException()
17032 
          self.ex.read(iprot)
17033 
        else:
17034 
          iprot.skip(ftype)
17035 
      else:
17036 
        iprot.skip(ftype)
17037 
      iprot.readFieldEnd()
17038 
    iprot.readStructEnd()
17039 
 
17040 
  def write(self, oprot):
17041 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
17042 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
17043 
      return
17044 
    oprot.writeStructBegin('validateReturnProduct_result')
17045 
    if self.success is not None:
17046 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
17047 
      oprot.writeBool(self.success)
17048 
      oprot.writeFieldEnd()
17049 
    if self.ex is not None:
17050 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
17051 
      self.ex.write(oprot)
17052 
      oprot.writeFieldEnd()
17053 
    oprot.writeFieldStop()
17054 
    oprot.writeStructEnd()
17055 
 
17056 
  def validate(self):
17057 
    return
17058 
 
17059 
 
17060 
  def __repr__(self):
17061 
    L = ['%s=%r' % (key, value)
17062 
      for key, value in self.__dict__.iteritems()]
17063 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
17064 
 
17065 
  def __eq__(self, other):
17066 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
17067 
 
17068 
  def __ne__(self, other):
17069 
    return not (self == other)
17070 
 
2616 chandransh 17071 
class reshipOrder_args:
17072 
  """
17073 
  Attributes:
17074 
   - orderId
17075 
  """
2591 chandransh 17076 
 
2616 chandransh 17077 
  thrift_spec = (
17078 
    None, # 0
17079 
    (1, TType.I64, 'orderId', None, None, ), # 1
17080 
  )
17081 
 
17082 
  def __init__(self, orderId=None,):
17083 
    self.orderId = orderId
17084 
 
17085 
  def read(self, iprot):
17086 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
17087 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
17088 
      return
17089 
    iprot.readStructBegin()
17090 
    while True:
17091 
      (fname, ftype, fid) = iprot.readFieldBegin()
17092 
      if ftype == TType.STOP:
17093 
        break
17094 
      if fid == 1:
17095 
        if ftype == TType.I64:
17096 
          self.orderId = iprot.readI64();
17097 
        else:
17098 
          iprot.skip(ftype)
17099 
      else:
17100 
        iprot.skip(ftype)
17101 
      iprot.readFieldEnd()
17102 
    iprot.readStructEnd()
17103 
 
17104 
  def write(self, oprot):
17105 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
17106 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
17107 
      return
17108 
    oprot.writeStructBegin('reshipOrder_args')
3431 rajveer 17109 
    if self.orderId is not None:
2616 chandransh 17110 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
17111 
      oprot.writeI64(self.orderId)
17112 
      oprot.writeFieldEnd()
17113 
    oprot.writeFieldStop()
17114 
    oprot.writeStructEnd()
17115 
 
3431 rajveer 17116 
  def validate(self):
17117 
    return
17118 
 
17119 
 
2616 chandransh 17120 
  def __repr__(self):
17121 
    L = ['%s=%r' % (key, value)
17122 
      for key, value in self.__dict__.iteritems()]
17123 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
17124 
 
17125 
  def __eq__(self, other):
17126 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
17127 
 
17128 
  def __ne__(self, other):
17129 
    return not (self == other)
17130 
 
17131 
class reshipOrder_result:
17132 
  """
17133 
  Attributes:
17134 
   - success
17135 
   - ex
17136 
  """
17137 
 
17138 
  thrift_spec = (
17139 
    (0, TType.I64, 'success', None, None, ), # 0
17140 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
17141 
  )
17142 
 
17143 
  def __init__(self, success=None, ex=None,):
17144 
    self.success = success
17145 
    self.ex = ex
17146 
 
17147 
  def read(self, iprot):
17148 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
17149 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
17150 
      return
17151 
    iprot.readStructBegin()
17152 
    while True:
17153 
      (fname, ftype, fid) = iprot.readFieldBegin()
17154 
      if ftype == TType.STOP:
17155 
        break
17156 
      if fid == 0:
17157 
        if ftype == TType.I64:
17158 
          self.success = iprot.readI64();
17159 
        else:
17160 
          iprot.skip(ftype)
17161 
      elif fid == 1:
17162 
        if ftype == TType.STRUCT:
17163 
          self.ex = TransactionServiceException()
17164 
          self.ex.read(iprot)
17165 
        else:
17166 
          iprot.skip(ftype)
17167 
      else:
17168 
        iprot.skip(ftype)
17169 
      iprot.readFieldEnd()
17170 
    iprot.readStructEnd()
17171 
 
17172 
  def write(self, oprot):
17173 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
17174 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
17175 
      return
17176 
    oprot.writeStructBegin('reshipOrder_result')
3431 rajveer 17177 
    if self.success is not None:
2616 chandransh 17178 
      oprot.writeFieldBegin('success', TType.I64, 0)
17179 
      oprot.writeI64(self.success)
17180 
      oprot.writeFieldEnd()
3431 rajveer 17181 
    if self.ex is not None:
2616 chandransh 17182 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
17183 
      self.ex.write(oprot)
17184 
      oprot.writeFieldEnd()
17185 
    oprot.writeFieldStop()
17186 
    oprot.writeStructEnd()
17187 
 
3431 rajveer 17188 
  def validate(self):
17189 
    return
17190 
 
17191 
 
2616 chandransh 17192 
  def __repr__(self):
17193 
    L = ['%s=%r' % (key, value)
17194 
      for key, value in self.__dict__.iteritems()]
17195 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
17196 
 
17197 
  def __eq__(self, other):
17198 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
17199 
 
17200 
  def __ne__(self, other):
17201 
    return not (self == other)
17202 
 
17203 
class refundOrder_args:
17204 
  """
17205 
  Attributes:
17206 
   - orderId
3226 chandransh 17207 
   - refundedBy
17208 
   - reason
2616 chandransh 17209 
  """
17210 
 
17211 
  thrift_spec = (
17212 
    None, # 0
17213 
    (1, TType.I64, 'orderId', None, None, ), # 1
3226 chandransh 17214 
    (2, TType.STRING, 'refundedBy', None, None, ), # 2
17215 
    (3, TType.STRING, 'reason', None, None, ), # 3
2616 chandransh 17216 
  )
17217 
 
3226 chandransh 17218 
  def __init__(self, orderId=None, refundedBy=None, reason=None,):
2616 chandransh 17219 
    self.orderId = orderId
3226 chandransh 17220 
    self.refundedBy = refundedBy
17221 
    self.reason = reason
2616 chandransh 17222 
 
17223 
  def read(self, iprot):
17224 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
17225 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
17226 
      return
17227 
    iprot.readStructBegin()
17228 
    while True:
17229 
      (fname, ftype, fid) = iprot.readFieldBegin()
17230 
      if ftype == TType.STOP:
17231 
        break
17232 
      if fid == 1:
17233 
        if ftype == TType.I64:
17234 
          self.orderId = iprot.readI64();
17235 
        else:
17236 
          iprot.skip(ftype)
3226 chandransh 17237 
      elif fid == 2:
17238 
        if ftype == TType.STRING:
17239 
          self.refundedBy = iprot.readString();
17240 
        else:
17241 
          iprot.skip(ftype)
17242 
      elif fid == 3:
17243 
        if ftype == TType.STRING:
17244 
          self.reason = iprot.readString();
17245 
        else:
17246 
          iprot.skip(ftype)
2616 chandransh 17247 
      else:
17248 
        iprot.skip(ftype)
17249 
      iprot.readFieldEnd()
17250 
    iprot.readStructEnd()
17251 
 
17252 
  def write(self, oprot):
17253 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
17254 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
17255 
      return
17256 
    oprot.writeStructBegin('refundOrder_args')
3431 rajveer 17257 
    if self.orderId is not None:
2616 chandransh 17258 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
17259 
      oprot.writeI64(self.orderId)
17260 
      oprot.writeFieldEnd()
3431 rajveer 17261 
    if self.refundedBy is not None:
3226 chandransh 17262 
      oprot.writeFieldBegin('refundedBy', TType.STRING, 2)
17263 
      oprot.writeString(self.refundedBy)
17264 
      oprot.writeFieldEnd()
3431 rajveer 17265 
    if self.reason is not None:
3226 chandransh 17266 
      oprot.writeFieldBegin('reason', TType.STRING, 3)
17267 
      oprot.writeString(self.reason)
17268 
      oprot.writeFieldEnd()
2616 chandransh 17269 
    oprot.writeFieldStop()
17270 
    oprot.writeStructEnd()
17271 
 
3431 rajveer 17272 
  def validate(self):
17273 
    return
17274 
 
17275 
 
2616 chandransh 17276 
  def __repr__(self):
17277 
    L = ['%s=%r' % (key, value)
17278 
      for key, value in self.__dict__.iteritems()]
17279 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
17280 
 
17281 
  def __eq__(self, other):
17282 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
17283 
 
17284 
  def __ne__(self, other):
17285 
    return not (self == other)
17286 
 
17287 
class refundOrder_result:
17288 
  """
17289 
  Attributes:
17290 
   - success
17291 
   - ex
17292 
  """
17293 
 
17294 
  thrift_spec = (
17295 
    (0, TType.BOOL, 'success', None, None, ), # 0
17296 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
17297 
  )
17298 
 
17299 
  def __init__(self, success=None, ex=None,):
17300 
    self.success = success
17301 
    self.ex = ex
17302 
 
17303 
  def read(self, iprot):
17304 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
17305 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
17306 
      return
17307 
    iprot.readStructBegin()
17308 
    while True:
17309 
      (fname, ftype, fid) = iprot.readFieldBegin()
17310 
      if ftype == TType.STOP:
17311 
        break
17312 
      if fid == 0:
17313 
        if ftype == TType.BOOL:
17314 
          self.success = iprot.readBool();
17315 
        else:
17316 
          iprot.skip(ftype)
17317 
      elif fid == 1:
17318 
        if ftype == TType.STRUCT:
17319 
          self.ex = TransactionServiceException()
17320 
          self.ex.read(iprot)
17321 
        else:
17322 
          iprot.skip(ftype)
17323 
      else:
17324 
        iprot.skip(ftype)
17325 
      iprot.readFieldEnd()
17326 
    iprot.readStructEnd()
17327 
 
17328 
  def write(self, oprot):
17329 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
17330 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
17331 
      return
17332 
    oprot.writeStructBegin('refundOrder_result')
3431 rajveer 17333 
    if self.success is not None:
2616 chandransh 17334 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
17335 
      oprot.writeBool(self.success)
17336 
      oprot.writeFieldEnd()
3431 rajveer 17337 
    if self.ex is not None:
2616 chandransh 17338 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
17339 
      self.ex.write(oprot)
17340 
      oprot.writeFieldEnd()
17341 
    oprot.writeFieldStop()
17342 
    oprot.writeStructEnd()
17343 
 
3431 rajveer 17344 
  def validate(self):
17345 
    return
17346 
 
17347 
 
2616 chandransh 17348 
  def __repr__(self):
17349 
    L = ['%s=%r' % (key, value)
17350 
      for key, value in self.__dict__.iteritems()]
17351 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
17352 
 
17353 
  def __eq__(self, other):
17354 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
17355 
 
17356 
  def __ne__(self, other):
17357 
    return not (self == other)
17358 
 
2690 chandransh 17359 
class getReturnOrders_args:
17360 
  """
17361 
  Attributes:
17362 
   - warehouseId
17363 
   - fromDate
17364 
   - toDate
17365 
  """
2616 chandransh 17366 
 
2690 chandransh 17367 
  thrift_spec = (
17368 
    None, # 0
17369 
    (1, TType.I64, 'warehouseId', None, None, ), # 1
17370 
    (2, TType.I64, 'fromDate', None, None, ), # 2
17371 
    (3, TType.I64, 'toDate', None, None, ), # 3
17372 
  )
17373 
 
17374 
  def __init__(self, warehouseId=None, fromDate=None, toDate=None,):
17375 
    self.warehouseId = warehouseId
17376 
    self.fromDate = fromDate
17377 
    self.toDate = toDate
17378 
 
17379 
  def read(self, iprot):
17380 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
17381 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
17382 
      return
17383 
    iprot.readStructBegin()
17384 
    while True:
17385 
      (fname, ftype, fid) = iprot.readFieldBegin()
17386 
      if ftype == TType.STOP:
17387 
        break
17388 
      if fid == 1:
17389 
        if ftype == TType.I64:
17390 
          self.warehouseId = iprot.readI64();
17391 
        else:
17392 
          iprot.skip(ftype)
17393 
      elif fid == 2:
17394 
        if ftype == TType.I64:
17395 
          self.fromDate = iprot.readI64();
17396 
        else:
17397 
          iprot.skip(ftype)
17398 
      elif fid == 3:
17399 
        if ftype == TType.I64:
17400 
          self.toDate = iprot.readI64();
17401 
        else:
17402 
          iprot.skip(ftype)
17403 
      else:
17404 
        iprot.skip(ftype)
17405 
      iprot.readFieldEnd()
17406 
    iprot.readStructEnd()
17407 
 
17408 
  def write(self, oprot):
17409 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
17410 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
17411 
      return
17412 
    oprot.writeStructBegin('getReturnOrders_args')
3431 rajveer 17413 
    if self.warehouseId is not None:
2690 chandransh 17414 
      oprot.writeFieldBegin('warehouseId', TType.I64, 1)
17415 
      oprot.writeI64(self.warehouseId)
17416 
      oprot.writeFieldEnd()
3431 rajveer 17417 
    if self.fromDate is not None:
2690 chandransh 17418 
      oprot.writeFieldBegin('fromDate', TType.I64, 2)
17419 
      oprot.writeI64(self.fromDate)
17420 
      oprot.writeFieldEnd()
3431 rajveer 17421 
    if self.toDate is not None:
2690 chandransh 17422 
      oprot.writeFieldBegin('toDate', TType.I64, 3)
17423 
      oprot.writeI64(self.toDate)
17424 
      oprot.writeFieldEnd()
17425 
    oprot.writeFieldStop()
17426 
    oprot.writeStructEnd()
17427 
 
3431 rajveer 17428 
  def validate(self):
17429 
    return
17430 
 
17431 
 
2690 chandransh 17432 
  def __repr__(self):
17433 
    L = ['%s=%r' % (key, value)
17434 
      for key, value in self.__dict__.iteritems()]
17435 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
17436 
 
17437 
  def __eq__(self, other):
17438 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
17439 
 
17440 
  def __ne__(self, other):
17441 
    return not (self == other)
17442 
 
17443 
class getReturnOrders_result:
17444 
  """
17445 
  Attributes:
17446 
   - success
17447 
  """
17448 
 
17449 
  thrift_spec = (
17450 
    (0, TType.LIST, 'success', (TType.STRUCT,(ReturnOrder, ReturnOrder.thrift_spec)), None, ), # 0
17451 
  )
17452 
 
17453 
  def __init__(self, success=None,):
17454 
    self.success = success
17455 
 
17456 
  def read(self, iprot):
17457 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
17458 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
17459 
      return
17460 
    iprot.readStructBegin()
17461 
    while True:
17462 
      (fname, ftype, fid) = iprot.readFieldBegin()
17463 
      if ftype == TType.STOP:
17464 
        break
17465 
      if fid == 0:
17466 
        if ftype == TType.LIST:
17467 
          self.success = []
5713 rajveer 17468 
          (_etype399, _size396) = iprot.readListBegin()
17469 
          for _i400 in xrange(_size396):
17470 
            _elem401 = ReturnOrder()
17471 
            _elem401.read(iprot)
17472 
            self.success.append(_elem401)
2690 chandransh 17473 
          iprot.readListEnd()
17474 
        else:
17475 
          iprot.skip(ftype)
17476 
      else:
17477 
        iprot.skip(ftype)
17478 
      iprot.readFieldEnd()
17479 
    iprot.readStructEnd()
17480 
 
17481 
  def write(self, oprot):
17482 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
17483 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
17484 
      return
17485 
    oprot.writeStructBegin('getReturnOrders_result')
3431 rajveer 17486 
    if self.success is not None:
2690 chandransh 17487 
      oprot.writeFieldBegin('success', TType.LIST, 0)
17488 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
5713 rajveer 17489 
      for iter402 in self.success:
17490 
        iter402.write(oprot)
2690 chandransh 17491 
      oprot.writeListEnd()
17492 
      oprot.writeFieldEnd()
17493 
    oprot.writeFieldStop()
17494 
    oprot.writeStructEnd()
17495 
 
3431 rajveer 17496 
  def validate(self):
17497 
    return
17498 
 
17499 
 
2690 chandransh 17500 
  def __repr__(self):
17501 
    L = ['%s=%r' % (key, value)
17502 
      for key, value in self.__dict__.iteritems()]
17503 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
17504 
 
17505 
  def __eq__(self, other):
17506 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
17507 
 
17508 
  def __ne__(self, other):
17509 
    return not (self == other)
17510 
 
5481 phani.kuma 17511 
class getAllReturnOrders_args:
17512 
  """
17513 
  Attributes:
17514 
   - onlyNotProcessed
17515 
   - fromDate
17516 
   - toDate
17517 
  """
17518 
 
17519 
  thrift_spec = (
17520 
    None, # 0
17521 
    (1, TType.BOOL, 'onlyNotProcessed', None, None, ), # 1
17522 
    (2, TType.I64, 'fromDate', None, None, ), # 2
17523 
    (3, TType.I64, 'toDate', None, None, ), # 3
17524 
  )
17525 
 
17526 
  def __init__(self, onlyNotProcessed=None, fromDate=None, toDate=None,):
17527 
    self.onlyNotProcessed = onlyNotProcessed
17528 
    self.fromDate = fromDate
17529 
    self.toDate = toDate
17530 
 
17531 
  def read(self, iprot):
17532 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
17533 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
17534 
      return
17535 
    iprot.readStructBegin()
17536 
    while True:
17537 
      (fname, ftype, fid) = iprot.readFieldBegin()
17538 
      if ftype == TType.STOP:
17539 
        break
17540 
      if fid == 1:
17541 
        if ftype == TType.BOOL:
17542 
          self.onlyNotProcessed = iprot.readBool();
17543 
        else:
17544 
          iprot.skip(ftype)
17545 
      elif fid == 2:
17546 
        if ftype == TType.I64:
17547 
          self.fromDate = iprot.readI64();
17548 
        else:
17549 
          iprot.skip(ftype)
17550 
      elif fid == 3:
17551 
        if ftype == TType.I64:
17552 
          self.toDate = iprot.readI64();
17553 
        else:
17554 
          iprot.skip(ftype)
17555 
      else:
17556 
        iprot.skip(ftype)
17557 
      iprot.readFieldEnd()
17558 
    iprot.readStructEnd()
17559 
 
17560 
  def write(self, oprot):
17561 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
17562 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
17563 
      return
17564 
    oprot.writeStructBegin('getAllReturnOrders_args')
17565 
    if self.onlyNotProcessed is not None:
17566 
      oprot.writeFieldBegin('onlyNotProcessed', TType.BOOL, 1)
17567 
      oprot.writeBool(self.onlyNotProcessed)
17568 
      oprot.writeFieldEnd()
17569 
    if self.fromDate is not None:
17570 
      oprot.writeFieldBegin('fromDate', TType.I64, 2)
17571 
      oprot.writeI64(self.fromDate)
17572 
      oprot.writeFieldEnd()
17573 
    if self.toDate is not None:
17574 
      oprot.writeFieldBegin('toDate', TType.I64, 3)
17575 
      oprot.writeI64(self.toDate)
17576 
      oprot.writeFieldEnd()
17577 
    oprot.writeFieldStop()
17578 
    oprot.writeStructEnd()
17579 
 
17580 
  def validate(self):
17581 
    return
17582 
 
17583 
 
17584 
  def __repr__(self):
17585 
    L = ['%s=%r' % (key, value)
17586 
      for key, value in self.__dict__.iteritems()]
17587 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
17588 
 
17589 
  def __eq__(self, other):
17590 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
17591 
 
17592 
  def __ne__(self, other):
17593 
    return not (self == other)
17594 
 
17595 
class getAllReturnOrders_result:
17596 
  """
17597 
  Attributes:
17598 
   - success
17599 
  """
17600 
 
17601 
  thrift_spec = (
17602 
    (0, TType.LIST, 'success', (TType.STRUCT,(ReturnOrder, ReturnOrder.thrift_spec)), None, ), # 0
17603 
  )
17604 
 
17605 
  def __init__(self, success=None,):
17606 
    self.success = success
17607 
 
17608 
  def read(self, iprot):
17609 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
17610 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
17611 
      return
17612 
    iprot.readStructBegin()
17613 
    while True:
17614 
      (fname, ftype, fid) = iprot.readFieldBegin()
17615 
      if ftype == TType.STOP:
17616 
        break
17617 
      if fid == 0:
17618 
        if ftype == TType.LIST:
17619 
          self.success = []
5713 rajveer 17620 
          (_etype406, _size403) = iprot.readListBegin()
17621 
          for _i407 in xrange(_size403):
17622 
            _elem408 = ReturnOrder()
17623 
            _elem408.read(iprot)
17624 
            self.success.append(_elem408)
5481 phani.kuma 17625 
          iprot.readListEnd()
17626 
        else:
17627 
          iprot.skip(ftype)
17628 
      else:
17629 
        iprot.skip(ftype)
17630 
      iprot.readFieldEnd()
17631 
    iprot.readStructEnd()
17632 
 
17633 
  def write(self, oprot):
17634 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
17635 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
17636 
      return
17637 
    oprot.writeStructBegin('getAllReturnOrders_result')
17638 
    if self.success is not None:
17639 
      oprot.writeFieldBegin('success', TType.LIST, 0)
17640 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
5713 rajveer 17641 
      for iter409 in self.success:
17642 
        iter409.write(oprot)
5481 phani.kuma 17643 
      oprot.writeListEnd()
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 
 
2700 chandransh 17663 
class getReturnOrder_args:
17664 
  """
17665 
  Attributes:
17666 
   - id
17667 
  """
17668 
 
17669 
  thrift_spec = (
17670 
    None, # 0
17671 
    (1, TType.I64, 'id', None, None, ), # 1
17672 
  )
17673 
 
17674 
  def __init__(self, id=None,):
17675 
    self.id = id
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.id = 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('getReturnOrder_args')
3431 rajveer 17701 
    if self.id is not None:
2700 chandransh 17702 
      oprot.writeFieldBegin('id', TType.I64, 1)
17703 
      oprot.writeI64(self.id)
17704 
      oprot.writeFieldEnd()
17705 
    oprot.writeFieldStop()
17706 
    oprot.writeStructEnd()
17707 
 
3431 rajveer 17708 
  def validate(self):
17709 
    return
17710 
 
17711 
 
2700 chandransh 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 getReturnOrder_result:
17724 
  """
17725 
  Attributes:
17726 
   - success
17727 
   - ex
17728 
  """
17729 
 
17730 
  thrift_spec = (
17731 
    (0, TType.STRUCT, 'success', (ReturnOrder, ReturnOrder.thrift_spec), None, ), # 0
17732 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
17733 
  )
17734 
 
17735 
  def __init__(self, success=None, ex=None,):
17736 
    self.success = success
17737 
    self.ex = ex
17738 
 
17739 
  def read(self, iprot):
17740 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
17741 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
17742 
      return
17743 
    iprot.readStructBegin()
17744 
    while True:
17745 
      (fname, ftype, fid) = iprot.readFieldBegin()
17746 
      if ftype == TType.STOP:
17747 
        break
17748 
      if fid == 0:
17749 
        if ftype == TType.STRUCT:
17750 
          self.success = ReturnOrder()
17751 
          self.success.read(iprot)
17752 
        else:
17753 
          iprot.skip(ftype)
17754 
      elif fid == 1:
17755 
        if ftype == TType.STRUCT:
17756 
          self.ex = TransactionServiceException()
17757 
          self.ex.read(iprot)
17758 
        else:
17759 
          iprot.skip(ftype)
17760 
      else:
17761 
        iprot.skip(ftype)
17762 
      iprot.readFieldEnd()
17763 
    iprot.readStructEnd()
17764 
 
17765 
  def write(self, oprot):
17766 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
17767 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
17768 
      return
17769 
    oprot.writeStructBegin('getReturnOrder_result')
3431 rajveer 17770 
    if self.success is not None:
2700 chandransh 17771 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
17772 
      self.success.write(oprot)
17773 
      oprot.writeFieldEnd()
3431 rajveer 17774 
    if self.ex is not None:
2700 chandransh 17775 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
17776 
      self.ex.write(oprot)
17777 
      oprot.writeFieldEnd()
17778 
    oprot.writeFieldStop()
17779 
    oprot.writeStructEnd()
17780 
 
3431 rajveer 17781 
  def validate(self):
17782 
    return
17783 
 
17784 
 
2700 chandransh 17785 
  def __repr__(self):
17786 
    L = ['%s=%r' % (key, value)
17787 
      for key, value in self.__dict__.iteritems()]
17788 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
17789 
 
17790 
  def __eq__(self, other):
17791 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
17792 
 
17793 
  def __ne__(self, other):
17794 
    return not (self == other)
17795 
 
2690 chandransh 17796 
class processReturn_args:
17797 
  """
17798 
  Attributes:
17799 
   - returnOrderId
17800 
  """
17801 
 
17802 
  thrift_spec = (
17803 
    None, # 0
17804 
    (1, TType.I64, 'returnOrderId', None, None, ), # 1
17805 
  )
17806 
 
17807 
  def __init__(self, returnOrderId=None,):
17808 
    self.returnOrderId = returnOrderId
17809 
 
17810 
  def read(self, iprot):
17811 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
17812 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
17813 
      return
17814 
    iprot.readStructBegin()
17815 
    while True:
17816 
      (fname, ftype, fid) = iprot.readFieldBegin()
17817 
      if ftype == TType.STOP:
17818 
        break
17819 
      if fid == 1:
17820 
        if ftype == TType.I64:
17821 
          self.returnOrderId = iprot.readI64();
17822 
        else:
17823 
          iprot.skip(ftype)
17824 
      else:
17825 
        iprot.skip(ftype)
17826 
      iprot.readFieldEnd()
17827 
    iprot.readStructEnd()
17828 
 
17829 
  def write(self, oprot):
17830 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
17831 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
17832 
      return
17833 
    oprot.writeStructBegin('processReturn_args')
3431 rajveer 17834 
    if self.returnOrderId is not None:
2690 chandransh 17835 
      oprot.writeFieldBegin('returnOrderId', TType.I64, 1)
17836 
      oprot.writeI64(self.returnOrderId)
17837 
      oprot.writeFieldEnd()
17838 
    oprot.writeFieldStop()
17839 
    oprot.writeStructEnd()
17840 
 
3431 rajveer 17841 
  def validate(self):
17842 
    return
17843 
 
17844 
 
2690 chandransh 17845 
  def __repr__(self):
17846 
    L = ['%s=%r' % (key, value)
17847 
      for key, value in self.__dict__.iteritems()]
17848 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
17849 
 
17850 
  def __eq__(self, other):
17851 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
17852 
 
17853 
  def __ne__(self, other):
17854 
    return not (self == other)
17855 
 
17856 
class processReturn_result:
17857 
  """
17858 
  Attributes:
17859 
   - ex
17860 
  """
17861 
 
17862 
  thrift_spec = (
17863 
    None, # 0
17864 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
17865 
  )
17866 
 
17867 
  def __init__(self, ex=None,):
17868 
    self.ex = ex
17869 
 
17870 
  def read(self, iprot):
17871 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
17872 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
17873 
      return
17874 
    iprot.readStructBegin()
17875 
    while True:
17876 
      (fname, ftype, fid) = iprot.readFieldBegin()
17877 
      if ftype == TType.STOP:
17878 
        break
17879 
      if fid == 1:
17880 
        if ftype == TType.STRUCT:
17881 
          self.ex = TransactionServiceException()
17882 
          self.ex.read(iprot)
17883 
        else:
17884 
          iprot.skip(ftype)
17885 
      else:
17886 
        iprot.skip(ftype)
17887 
      iprot.readFieldEnd()
17888 
    iprot.readStructEnd()
17889 
 
17890 
  def write(self, oprot):
17891 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
17892 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
17893 
      return
17894 
    oprot.writeStructBegin('processReturn_result')
3431 rajveer 17895 
    if self.ex is not None:
2690 chandransh 17896 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
17897 
      self.ex.write(oprot)
17898 
      oprot.writeFieldEnd()
17899 
    oprot.writeFieldStop()
17900 
    oprot.writeStructEnd()
17901 
 
3431 rajveer 17902 
  def validate(self):
17903 
    return
17904 
 
17905 
 
2690 chandransh 17906 
  def __repr__(self):
17907 
    L = ['%s=%r' % (key, value)
17908 
      for key, value in self.__dict__.iteritems()]
17909 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
17910 
 
17911 
  def __eq__(self, other):
17912 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
17913 
 
17914 
  def __ne__(self, other):
17915 
    return not (self == other)
17916 
 
3451 chandransh 17917 
class updateWeight_args:
17918 
  """
17919 
  Attributes:
17920 
   - orderId
17921 
   - weight
17922 
  """
17923 
 
17924 
  thrift_spec = (
17925 
    None, # 0
17926 
    (1, TType.I64, 'orderId', None, None, ), # 1
17927 
    (2, TType.DOUBLE, 'weight', None, None, ), # 2
17928 
  )
17929 
 
17930 
  def __init__(self, orderId=None, weight=None,):
17931 
    self.orderId = orderId
17932 
    self.weight = weight
17933 
 
17934 
  def read(self, iprot):
17935 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
17936 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
17937 
      return
17938 
    iprot.readStructBegin()
17939 
    while True:
17940 
      (fname, ftype, fid) = iprot.readFieldBegin()
17941 
      if ftype == TType.STOP:
17942 
        break
17943 
      if fid == 1:
17944 
        if ftype == TType.I64:
17945 
          self.orderId = iprot.readI64();
17946 
        else:
17947 
          iprot.skip(ftype)
17948 
      elif fid == 2:
17949 
        if ftype == TType.DOUBLE:
17950 
          self.weight = iprot.readDouble();
17951 
        else:
17952 
          iprot.skip(ftype)
17953 
      else:
17954 
        iprot.skip(ftype)
17955 
      iprot.readFieldEnd()
17956 
    iprot.readStructEnd()
17957 
 
17958 
  def write(self, oprot):
17959 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
17960 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
17961 
      return
17962 
    oprot.writeStructBegin('updateWeight_args')
17963 
    if self.orderId is not None:
17964 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
17965 
      oprot.writeI64(self.orderId)
17966 
      oprot.writeFieldEnd()
17967 
    if self.weight is not None:
17968 
      oprot.writeFieldBegin('weight', TType.DOUBLE, 2)
17969 
      oprot.writeDouble(self.weight)
17970 
      oprot.writeFieldEnd()
17971 
    oprot.writeFieldStop()
17972 
    oprot.writeStructEnd()
17973 
 
17974 
  def validate(self):
17975 
    return
17976 
 
17977 
 
17978 
  def __repr__(self):
17979 
    L = ['%s=%r' % (key, value)
17980 
      for key, value in self.__dict__.iteritems()]
17981 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
17982 
 
17983 
  def __eq__(self, other):
17984 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
17985 
 
17986 
  def __ne__(self, other):
17987 
    return not (self == other)
17988 
 
17989 
class updateWeight_result:
17990 
  """
17991 
  Attributes:
17992 
   - success
17993 
   - ex
17994 
  """
17995 
 
17996 
  thrift_spec = (
17997 
    (0, TType.STRUCT, 'success', (Order, Order.thrift_spec), None, ), # 0
17998 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
17999 
  )
18000 
 
18001 
  def __init__(self, success=None, ex=None,):
18002 
    self.success = success
18003 
    self.ex = ex
18004 
 
18005 
  def read(self, iprot):
18006 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
18007 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
18008 
      return
18009 
    iprot.readStructBegin()
18010 
    while True:
18011 
      (fname, ftype, fid) = iprot.readFieldBegin()
18012 
      if ftype == TType.STOP:
18013 
        break
18014 
      if fid == 0:
18015 
        if ftype == TType.STRUCT:
18016 
          self.success = Order()
18017 
          self.success.read(iprot)
18018 
        else:
18019 
          iprot.skip(ftype)
18020 
      elif fid == 1:
18021 
        if ftype == TType.STRUCT:
18022 
          self.ex = TransactionServiceException()
18023 
          self.ex.read(iprot)
18024 
        else:
18025 
          iprot.skip(ftype)
18026 
      else:
18027 
        iprot.skip(ftype)
18028 
      iprot.readFieldEnd()
18029 
    iprot.readStructEnd()
18030 
 
18031 
  def write(self, oprot):
18032 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
18033 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
18034 
      return
18035 
    oprot.writeStructBegin('updateWeight_result')
18036 
    if self.success is not None:
18037 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
18038 
      self.success.write(oprot)
18039 
      oprot.writeFieldEnd()
18040 
    if self.ex is not None:
18041 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
18042 
      self.ex.write(oprot)
18043 
      oprot.writeFieldEnd()
18044 
    oprot.writeFieldStop()
18045 
    oprot.writeStructEnd()
18046 
 
18047 
  def validate(self):
18048 
    return
18049 
 
18050 
 
18051 
  def __repr__(self):
18052 
    L = ['%s=%r' % (key, value)
18053 
      for key, value in self.__dict__.iteritems()]
18054 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
18055 
 
18056 
  def __eq__(self, other):
18057 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
18058 
 
18059 
  def __ne__(self, other):
18060 
    return not (self == other)
3469 chandransh 18061 
 
18062 
class changeItem_args:
18063 
  """
18064 
  Attributes:
18065 
   - orderId
18066 
   - itemId
18067 
  """
18068 
 
18069 
  thrift_spec = (
18070 
    None, # 0
18071 
    (1, TType.I64, 'orderId', None, None, ), # 1
18072 
    (2, TType.I64, 'itemId', None, None, ), # 2
18073 
  )
18074 
 
18075 
  def __init__(self, orderId=None, itemId=None,):
18076 
    self.orderId = orderId
18077 
    self.itemId = itemId
18078 
 
18079 
  def read(self, iprot):
18080 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
18081 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
18082 
      return
18083 
    iprot.readStructBegin()
18084 
    while True:
18085 
      (fname, ftype, fid) = iprot.readFieldBegin()
18086 
      if ftype == TType.STOP:
18087 
        break
18088 
      if fid == 1:
18089 
        if ftype == TType.I64:
18090 
          self.orderId = iprot.readI64();
18091 
        else:
18092 
          iprot.skip(ftype)
18093 
      elif fid == 2:
18094 
        if ftype == TType.I64:
18095 
          self.itemId = iprot.readI64();
18096 
        else:
18097 
          iprot.skip(ftype)
18098 
      else:
18099 
        iprot.skip(ftype)
18100 
      iprot.readFieldEnd()
18101 
    iprot.readStructEnd()
18102 
 
18103 
  def write(self, oprot):
18104 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
18105 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
18106 
      return
18107 
    oprot.writeStructBegin('changeItem_args')
18108 
    if self.orderId is not None:
18109 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
18110 
      oprot.writeI64(self.orderId)
18111 
      oprot.writeFieldEnd()
18112 
    if self.itemId is not None:
18113 
      oprot.writeFieldBegin('itemId', TType.I64, 2)
18114 
      oprot.writeI64(self.itemId)
18115 
      oprot.writeFieldEnd()
18116 
    oprot.writeFieldStop()
18117 
    oprot.writeStructEnd()
18118 
 
18119 
  def validate(self):
18120 
    return
18121 
 
18122 
 
18123 
  def __repr__(self):
18124 
    L = ['%s=%r' % (key, value)
18125 
      for key, value in self.__dict__.iteritems()]
18126 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
18127 
 
18128 
  def __eq__(self, other):
18129 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
18130 
 
18131 
  def __ne__(self, other):
18132 
    return not (self == other)
18133 
 
18134 
class changeItem_result:
18135 
  """
18136 
  Attributes:
18137 
   - success
18138 
   - ex
18139 
  """
18140 
 
18141 
  thrift_spec = (
18142 
    (0, TType.STRUCT, 'success', (Order, Order.thrift_spec), None, ), # 0
18143 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
18144 
  )
18145 
 
18146 
  def __init__(self, success=None, ex=None,):
18147 
    self.success = success
18148 
    self.ex = ex
18149 
 
18150 
  def read(self, iprot):
18151 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
18152 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
18153 
      return
18154 
    iprot.readStructBegin()
18155 
    while True:
18156 
      (fname, ftype, fid) = iprot.readFieldBegin()
18157 
      if ftype == TType.STOP:
18158 
        break
18159 
      if fid == 0:
18160 
        if ftype == TType.STRUCT:
18161 
          self.success = Order()
18162 
          self.success.read(iprot)
18163 
        else:
18164 
          iprot.skip(ftype)
18165 
      elif fid == 1:
18166 
        if ftype == TType.STRUCT:
18167 
          self.ex = TransactionServiceException()
18168 
          self.ex.read(iprot)
18169 
        else:
18170 
          iprot.skip(ftype)
18171 
      else:
18172 
        iprot.skip(ftype)
18173 
      iprot.readFieldEnd()
18174 
    iprot.readStructEnd()
18175 
 
18176 
  def write(self, oprot):
18177 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
18178 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
18179 
      return
18180 
    oprot.writeStructBegin('changeItem_result')
18181 
    if self.success is not None:
18182 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
18183 
      self.success.write(oprot)
18184 
      oprot.writeFieldEnd()
18185 
    if self.ex is not None:
18186 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
18187 
      self.ex.write(oprot)
18188 
      oprot.writeFieldEnd()
18189 
    oprot.writeFieldStop()
18190 
    oprot.writeStructEnd()
18191 
 
18192 
  def validate(self):
18193 
    return
18194 
 
18195 
 
18196 
  def __repr__(self):
18197 
    L = ['%s=%r' % (key, value)
18198 
      for key, value in self.__dict__.iteritems()]
18199 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
18200 
 
18201 
  def __eq__(self, other):
18202 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
18203 
 
18204 
  def __ne__(self, other):
18205 
    return not (self == other)
18206 
 
18207 
class shiftToWarehouse_args:
18208 
  """
18209 
  Attributes:
18210 
   - orderId
18211 
   - warehouseId
18212 
  """
18213 
 
18214 
  thrift_spec = (
18215 
    None, # 0
18216 
    (1, TType.I64, 'orderId', None, None, ), # 1
18217 
    (2, TType.I64, 'warehouseId', None, None, ), # 2
18218 
  )
18219 
 
18220 
  def __init__(self, orderId=None, warehouseId=None,):
18221 
    self.orderId = orderId
18222 
    self.warehouseId = warehouseId
18223 
 
18224 
  def read(self, iprot):
18225 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
18226 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
18227 
      return
18228 
    iprot.readStructBegin()
18229 
    while True:
18230 
      (fname, ftype, fid) = iprot.readFieldBegin()
18231 
      if ftype == TType.STOP:
18232 
        break
18233 
      if fid == 1:
18234 
        if ftype == TType.I64:
18235 
          self.orderId = iprot.readI64();
18236 
        else:
18237 
          iprot.skip(ftype)
18238 
      elif fid == 2:
18239 
        if ftype == TType.I64:
18240 
          self.warehouseId = iprot.readI64();
18241 
        else:
18242 
          iprot.skip(ftype)
18243 
      else:
18244 
        iprot.skip(ftype)
18245 
      iprot.readFieldEnd()
18246 
    iprot.readStructEnd()
18247 
 
18248 
  def write(self, oprot):
18249 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
18250 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
18251 
      return
18252 
    oprot.writeStructBegin('shiftToWarehouse_args')
18253 
    if self.orderId is not None:
18254 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
18255 
      oprot.writeI64(self.orderId)
18256 
      oprot.writeFieldEnd()
18257 
    if self.warehouseId is not None:
18258 
      oprot.writeFieldBegin('warehouseId', TType.I64, 2)
18259 
      oprot.writeI64(self.warehouseId)
18260 
      oprot.writeFieldEnd()
18261 
    oprot.writeFieldStop()
18262 
    oprot.writeStructEnd()
18263 
 
18264 
  def validate(self):
18265 
    return
18266 
 
18267 
 
18268 
  def __repr__(self):
18269 
    L = ['%s=%r' % (key, value)
18270 
      for key, value in self.__dict__.iteritems()]
18271 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
18272 
 
18273 
  def __eq__(self, other):
18274 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
18275 
 
18276 
  def __ne__(self, other):
18277 
    return not (self == other)
18278 
 
18279 
class shiftToWarehouse_result:
18280 
  """
18281 
  Attributes:
18282 
   - success
18283 
   - ex
18284 
  """
18285 
 
18286 
  thrift_spec = (
18287 
    (0, TType.STRUCT, 'success', (Order, Order.thrift_spec), None, ), # 0
18288 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
18289 
  )
18290 
 
18291 
  def __init__(self, success=None, ex=None,):
18292 
    self.success = success
18293 
    self.ex = ex
18294 
 
18295 
  def read(self, iprot):
18296 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
18297 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
18298 
      return
18299 
    iprot.readStructBegin()
18300 
    while True:
18301 
      (fname, ftype, fid) = iprot.readFieldBegin()
18302 
      if ftype == TType.STOP:
18303 
        break
18304 
      if fid == 0:
18305 
        if ftype == TType.STRUCT:
18306 
          self.success = Order()
18307 
          self.success.read(iprot)
18308 
        else:
18309 
          iprot.skip(ftype)
18310 
      elif fid == 1:
18311 
        if ftype == TType.STRUCT:
18312 
          self.ex = TransactionServiceException()
18313 
          self.ex.read(iprot)
18314 
        else:
18315 
          iprot.skip(ftype)
18316 
      else:
18317 
        iprot.skip(ftype)
18318 
      iprot.readFieldEnd()
18319 
    iprot.readStructEnd()
18320 
 
18321 
  def write(self, oprot):
18322 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
18323 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
18324 
      return
18325 
    oprot.writeStructBegin('shiftToWarehouse_result')
18326 
    if self.success is not None:
18327 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
18328 
      self.success.write(oprot)
18329 
      oprot.writeFieldEnd()
18330 
    if self.ex is not None:
18331 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
18332 
      self.ex.write(oprot)
18333 
      oprot.writeFieldEnd()
18334 
    oprot.writeFieldStop()
18335 
    oprot.writeStructEnd()
18336 
 
18337 
  def validate(self):
18338 
    return
18339 
 
18340 
 
18341 
  def __repr__(self):
18342 
    L = ['%s=%r' % (key, value)
18343 
      for key, value in self.__dict__.iteritems()]
18344 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
18345 
 
18346 
  def __eq__(self, other):
18347 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
18348 
 
18349 
  def __ne__(self, other):
18350 
    return not (self == other)
3553 chandransh 18351 
 
18352 
class addDelayReason_args:
18353 
  """
18354 
  Attributes:
18355 
   - orderId
18356 
   - delayReason
3986 chandransh 18357 
   - furtherDelay
4647 rajveer 18358 
   - delayReasonText
3553 chandransh 18359 
  """
18360 
 
18361 
  thrift_spec = (
18362 
    None, # 0
18363 
    (1, TType.I64, 'orderId', None, None, ), # 1
18364 
    (2, TType.I32, 'delayReason', None, None, ), # 2
3986 chandransh 18365 
    (3, TType.I64, 'furtherDelay', None, None, ), # 3
4647 rajveer 18366 
    (4, TType.STRING, 'delayReasonText', None, None, ), # 4
3553 chandransh 18367 
  )
18368 
 
4647 rajveer 18369 
  def __init__(self, orderId=None, delayReason=None, furtherDelay=None, delayReasonText=None,):
3553 chandransh 18370 
    self.orderId = orderId
18371 
    self.delayReason = delayReason
3986 chandransh 18372 
    self.furtherDelay = furtherDelay
4647 rajveer 18373 
    self.delayReasonText = delayReasonText
3553 chandransh 18374 
 
18375 
  def read(self, iprot):
18376 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
18377 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
18378 
      return
18379 
    iprot.readStructBegin()
18380 
    while True:
18381 
      (fname, ftype, fid) = iprot.readFieldBegin()
18382 
      if ftype == TType.STOP:
18383 
        break
18384 
      if fid == 1:
18385 
        if ftype == TType.I64:
18386 
          self.orderId = iprot.readI64();
18387 
        else:
18388 
          iprot.skip(ftype)
18389 
      elif fid == 2:
18390 
        if ftype == TType.I32:
18391 
          self.delayReason = iprot.readI32();
18392 
        else:
18393 
          iprot.skip(ftype)
3986 chandransh 18394 
      elif fid == 3:
18395 
        if ftype == TType.I64:
18396 
          self.furtherDelay = iprot.readI64();
18397 
        else:
18398 
          iprot.skip(ftype)
4647 rajveer 18399 
      elif fid == 4:
18400 
        if ftype == TType.STRING:
18401 
          self.delayReasonText = iprot.readString();
18402 
        else:
18403 
          iprot.skip(ftype)
3553 chandransh 18404 
      else:
18405 
        iprot.skip(ftype)
18406 
      iprot.readFieldEnd()
18407 
    iprot.readStructEnd()
18408 
 
18409 
  def write(self, oprot):
18410 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
18411 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
18412 
      return
18413 
    oprot.writeStructBegin('addDelayReason_args')
18414 
    if self.orderId is not None:
18415 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
18416 
      oprot.writeI64(self.orderId)
18417 
      oprot.writeFieldEnd()
18418 
    if self.delayReason is not None:
18419 
      oprot.writeFieldBegin('delayReason', TType.I32, 2)
18420 
      oprot.writeI32(self.delayReason)
18421 
      oprot.writeFieldEnd()
3986 chandransh 18422 
    if self.furtherDelay is not None:
18423 
      oprot.writeFieldBegin('furtherDelay', TType.I64, 3)
18424 
      oprot.writeI64(self.furtherDelay)
18425 
      oprot.writeFieldEnd()
4647 rajveer 18426 
    if self.delayReasonText is not None:
18427 
      oprot.writeFieldBegin('delayReasonText', TType.STRING, 4)
18428 
      oprot.writeString(self.delayReasonText)
18429 
      oprot.writeFieldEnd()
3553 chandransh 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)
18447 
 
18448 
class addDelayReason_result:
18449 
  """
18450 
  Attributes:
18451 
   - success
18452 
   - ex
18453 
  """
18454 
 
18455 
  thrift_spec = (
18456 
    (0, TType.BOOL, 'success', None, None, ), # 0
18457 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
18458 
  )
18459 
 
18460 
  def __init__(self, success=None, ex=None,):
18461 
    self.success = success
18462 
    self.ex = ex
18463 
 
18464 
  def read(self, iprot):
18465 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
18466 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
18467 
      return
18468 
    iprot.readStructBegin()
18469 
    while True:
18470 
      (fname, ftype, fid) = iprot.readFieldBegin()
18471 
      if ftype == TType.STOP:
18472 
        break
18473 
      if fid == 0:
18474 
        if ftype == TType.BOOL:
18475 
          self.success = iprot.readBool();
18476 
        else:
18477 
          iprot.skip(ftype)
18478 
      elif fid == 1:
18479 
        if ftype == TType.STRUCT:
18480 
          self.ex = TransactionServiceException()
18481 
          self.ex.read(iprot)
18482 
        else:
18483 
          iprot.skip(ftype)
18484 
      else:
18485 
        iprot.skip(ftype)
18486 
      iprot.readFieldEnd()
18487 
    iprot.readStructEnd()
18488 
 
18489 
  def write(self, oprot):
18490 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
18491 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
18492 
      return
18493 
    oprot.writeStructBegin('addDelayReason_result')
18494 
    if self.success is not None:
18495 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
18496 
      oprot.writeBool(self.success)
18497 
      oprot.writeFieldEnd()
18498 
    if self.ex is not None:
18499 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
18500 
      self.ex.write(oprot)
18501 
      oprot.writeFieldEnd()
18502 
    oprot.writeFieldStop()
18503 
    oprot.writeStructEnd()
18504 
 
18505 
  def validate(self):
18506 
    return
18507 
 
18508 
 
18509 
  def __repr__(self):
18510 
    L = ['%s=%r' % (key, value)
18511 
      for key, value in self.__dict__.iteritems()]
18512 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
18513 
 
18514 
  def __eq__(self, other):
18515 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
18516 
 
18517 
  def __ne__(self, other):
18518 
    return not (self == other)
3956 chandransh 18519 
 
18520 
class reconcileCodCollection_args:
18521 
  """
18522 
  Attributes:
18523 
   - collectedAmountMap
18524 
   - xferBy
18525 
   - xferTxnId
18526 
   - xferDate
18527 
  """
18528 
 
18529 
  thrift_spec = (
18530 
    None, # 0
18531 
    (1, TType.MAP, 'collectedAmountMap', (TType.STRING,None,TType.DOUBLE,None), None, ), # 1
18532 
    (2, TType.STRING, 'xferBy', None, None, ), # 2
18533 
    (3, TType.STRING, 'xferTxnId', None, None, ), # 3
18534 
    (4, TType.I64, 'xferDate', None, None, ), # 4
18535 
  )
18536 
 
18537 
  def __init__(self, collectedAmountMap=None, xferBy=None, xferTxnId=None, xferDate=None,):
18538 
    self.collectedAmountMap = collectedAmountMap
18539 
    self.xferBy = xferBy
18540 
    self.xferTxnId = xferTxnId
18541 
    self.xferDate = xferDate
18542 
 
18543 
  def read(self, iprot):
18544 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
18545 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
18546 
      return
18547 
    iprot.readStructBegin()
18548 
    while True:
18549 
      (fname, ftype, fid) = iprot.readFieldBegin()
18550 
      if ftype == TType.STOP:
18551 
        break
18552 
      if fid == 1:
18553 
        if ftype == TType.MAP:
18554 
          self.collectedAmountMap = {}
5713 rajveer 18555 
          (_ktype411, _vtype412, _size410 ) = iprot.readMapBegin()
18556 
          for _i414 in xrange(_size410):
18557 
            _key415 = iprot.readString();
18558 
            _val416 = iprot.readDouble();
18559 
            self.collectedAmountMap[_key415] = _val416
3956 chandransh 18560 
          iprot.readMapEnd()
18561 
        else:
18562 
          iprot.skip(ftype)
18563 
      elif fid == 2:
18564 
        if ftype == TType.STRING:
18565 
          self.xferBy = iprot.readString();
18566 
        else:
18567 
          iprot.skip(ftype)
18568 
      elif fid == 3:
18569 
        if ftype == TType.STRING:
18570 
          self.xferTxnId = iprot.readString();
18571 
        else:
18572 
          iprot.skip(ftype)
18573 
      elif fid == 4:
18574 
        if ftype == TType.I64:
18575 
          self.xferDate = iprot.readI64();
18576 
        else:
18577 
          iprot.skip(ftype)
18578 
      else:
18579 
        iprot.skip(ftype)
18580 
      iprot.readFieldEnd()
18581 
    iprot.readStructEnd()
18582 
 
18583 
  def write(self, oprot):
18584 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
18585 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
18586 
      return
18587 
    oprot.writeStructBegin('reconcileCodCollection_args')
18588 
    if self.collectedAmountMap is not None:
18589 
      oprot.writeFieldBegin('collectedAmountMap', TType.MAP, 1)
18590 
      oprot.writeMapBegin(TType.STRING, TType.DOUBLE, len(self.collectedAmountMap))
5713 rajveer 18591 
      for kiter417,viter418 in self.collectedAmountMap.items():
18592 
        oprot.writeString(kiter417)
18593 
        oprot.writeDouble(viter418)
3956 chandransh 18594 
      oprot.writeMapEnd()
18595 
      oprot.writeFieldEnd()
18596 
    if self.xferBy is not None:
18597 
      oprot.writeFieldBegin('xferBy', TType.STRING, 2)
18598 
      oprot.writeString(self.xferBy)
18599 
      oprot.writeFieldEnd()
18600 
    if self.xferTxnId is not None:
18601 
      oprot.writeFieldBegin('xferTxnId', TType.STRING, 3)
18602 
      oprot.writeString(self.xferTxnId)
18603 
      oprot.writeFieldEnd()
18604 
    if self.xferDate is not None:
18605 
      oprot.writeFieldBegin('xferDate', TType.I64, 4)
18606 
      oprot.writeI64(self.xferDate)
18607 
      oprot.writeFieldEnd()
18608 
    oprot.writeFieldStop()
18609 
    oprot.writeStructEnd()
18610 
 
18611 
  def validate(self):
18612 
    return
18613 
 
18614 
 
18615 
  def __repr__(self):
18616 
    L = ['%s=%r' % (key, value)
18617 
      for key, value in self.__dict__.iteritems()]
18618 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
18619 
 
18620 
  def __eq__(self, other):
18621 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
18622 
 
18623 
  def __ne__(self, other):
18624 
    return not (self == other)
18625 
 
18626 
class reconcileCodCollection_result:
18627 
  """
18628 
  Attributes:
18629 
   - success
18630 
   - ex
18631 
  """
18632 
 
18633 
  thrift_spec = (
18634 
    (0, TType.MAP, 'success', (TType.STRING,None,TType.STRING,None), None, ), # 0
18635 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
18636 
  )
18637 
 
18638 
  def __init__(self, success=None, ex=None,):
18639 
    self.success = success
18640 
    self.ex = ex
18641 
 
18642 
  def read(self, iprot):
18643 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
18644 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
18645 
      return
18646 
    iprot.readStructBegin()
18647 
    while True:
18648 
      (fname, ftype, fid) = iprot.readFieldBegin()
18649 
      if ftype == TType.STOP:
18650 
        break
18651 
      if fid == 0:
18652 
        if ftype == TType.MAP:
18653 
          self.success = {}
5713 rajveer 18654 
          (_ktype420, _vtype421, _size419 ) = iprot.readMapBegin()
18655 
          for _i423 in xrange(_size419):
18656 
            _key424 = iprot.readString();
18657 
            _val425 = iprot.readString();
18658 
            self.success[_key424] = _val425
3956 chandransh 18659 
          iprot.readMapEnd()
18660 
        else:
18661 
          iprot.skip(ftype)
18662 
      elif fid == 1:
18663 
        if ftype == TType.STRUCT:
18664 
          self.ex = TransactionServiceException()
18665 
          self.ex.read(iprot)
18666 
        else:
18667 
          iprot.skip(ftype)
18668 
      else:
18669 
        iprot.skip(ftype)
18670 
      iprot.readFieldEnd()
18671 
    iprot.readStructEnd()
18672 
 
18673 
  def write(self, oprot):
18674 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
18675 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
18676 
      return
18677 
    oprot.writeStructBegin('reconcileCodCollection_result')
18678 
    if self.success is not None:
18679 
      oprot.writeFieldBegin('success', TType.MAP, 0)
18680 
      oprot.writeMapBegin(TType.STRING, TType.STRING, len(self.success))
5713 rajveer 18681 
      for kiter426,viter427 in self.success.items():
18682 
        oprot.writeString(kiter426)
18683 
        oprot.writeString(viter427)
3956 chandransh 18684 
      oprot.writeMapEnd()
18685 
      oprot.writeFieldEnd()
18686 
    if self.ex is not None:
18687 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
18688 
      self.ex.write(oprot)
18689 
      oprot.writeFieldEnd()
18690 
    oprot.writeFieldStop()
18691 
    oprot.writeStructEnd()
18692 
 
18693 
  def validate(self):
18694 
    return
18695 
 
18696 
 
18697 
  def __repr__(self):
18698 
    L = ['%s=%r' % (key, value)
18699 
      for key, value in self.__dict__.iteritems()]
18700 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
18701 
 
18702 
  def __eq__(self, other):
18703 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
18704 
 
18705 
  def __ne__(self, other):
18706 
    return not (self == other)
4008 mandeep.dh 18707 
 
18708 
class getTransactionsRequiringExtraProcessing_args:
18709 
  """
18710 
  Attributes:
18711 
   - category
18712 
  """
18713 
 
18714 
  thrift_spec = (
18715 
    None, # 0
18716 
    (1, TType.I32, 'category', None, None, ), # 1
18717 
  )
18718 
 
18719 
  def __init__(self, category=None,):
18720 
    self.category = category
18721 
 
18722 
  def read(self, iprot):
18723 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
18724 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
18725 
      return
18726 
    iprot.readStructBegin()
18727 
    while True:
18728 
      (fname, ftype, fid) = iprot.readFieldBegin()
18729 
      if ftype == TType.STOP:
18730 
        break
18731 
      if fid == 1:
18732 
        if ftype == TType.I32:
18733 
          self.category = iprot.readI32();
18734 
        else:
18735 
          iprot.skip(ftype)
18736 
      else:
18737 
        iprot.skip(ftype)
18738 
      iprot.readFieldEnd()
18739 
    iprot.readStructEnd()
18740 
 
18741 
  def write(self, oprot):
18742 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
18743 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
18744 
      return
18745 
    oprot.writeStructBegin('getTransactionsRequiringExtraProcessing_args')
18746 
    if self.category is not None:
18747 
      oprot.writeFieldBegin('category', TType.I32, 1)
18748 
      oprot.writeI32(self.category)
18749 
      oprot.writeFieldEnd()
18750 
    oprot.writeFieldStop()
18751 
    oprot.writeStructEnd()
18752 
 
18753 
  def validate(self):
18754 
    return
18755 
 
18756 
 
18757 
  def __repr__(self):
18758 
    L = ['%s=%r' % (key, value)
18759 
      for key, value in self.__dict__.iteritems()]
18760 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
18761 
 
18762 
  def __eq__(self, other):
18763 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
18764 
 
18765 
  def __ne__(self, other):
18766 
    return not (self == other)
18767 
 
18768 
class getTransactionsRequiringExtraProcessing_result:
18769 
  """
18770 
  Attributes:
18771 
   - success
18772 
  """
18773 
 
18774 
  thrift_spec = (
18775 
    (0, TType.LIST, 'success', (TType.I64,None), None, ), # 0
18776 
  )
18777 
 
18778 
  def __init__(self, success=None,):
18779 
    self.success = success
18780 
 
18781 
  def read(self, iprot):
18782 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
18783 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
18784 
      return
18785 
    iprot.readStructBegin()
18786 
    while True:
18787 
      (fname, ftype, fid) = iprot.readFieldBegin()
18788 
      if ftype == TType.STOP:
18789 
        break
18790 
      if fid == 0:
18791 
        if ftype == TType.LIST:
18792 
          self.success = []
5713 rajveer 18793 
          (_etype431, _size428) = iprot.readListBegin()
18794 
          for _i432 in xrange(_size428):
18795 
            _elem433 = iprot.readI64();
18796 
            self.success.append(_elem433)
4008 mandeep.dh 18797 
          iprot.readListEnd()
18798 
        else:
18799 
          iprot.skip(ftype)
18800 
      else:
18801 
        iprot.skip(ftype)
18802 
      iprot.readFieldEnd()
18803 
    iprot.readStructEnd()
18804 
 
18805 
  def write(self, oprot):
18806 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
18807 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
18808 
      return
18809 
    oprot.writeStructBegin('getTransactionsRequiringExtraProcessing_result')
18810 
    if self.success is not None:
18811 
      oprot.writeFieldBegin('success', TType.LIST, 0)
18812 
      oprot.writeListBegin(TType.I64, len(self.success))
5713 rajveer 18813 
      for iter434 in self.success:
18814 
        oprot.writeI64(iter434)
4008 mandeep.dh 18815 
      oprot.writeListEnd()
18816 
      oprot.writeFieldEnd()
18817 
    oprot.writeFieldStop()
18818 
    oprot.writeStructEnd()
18819 
 
18820 
  def validate(self):
18821 
    return
18822 
 
18823 
 
18824 
  def __repr__(self):
18825 
    L = ['%s=%r' % (key, value)
18826 
      for key, value in self.__dict__.iteritems()]
18827 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
18828 
 
18829 
  def __eq__(self, other):
18830 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
18831 
 
18832 
  def __ne__(self, other):
18833 
    return not (self == other)
18834 
 
18835 
class markTransactionAsProcessed_args:
18836 
  """
18837 
  Attributes:
18838 
   - transactionId
18839 
   - category
18840 
  """
18841 
 
18842 
  thrift_spec = (
18843 
    None, # 0
18844 
    (1, TType.I64, 'transactionId', None, None, ), # 1
18845 
    (2, TType.I32, 'category', None, None, ), # 2
18846 
  )
18847 
 
18848 
  def __init__(self, transactionId=None, category=None,):
18849 
    self.transactionId = transactionId
18850 
    self.category = category
18851 
 
18852 
  def read(self, iprot):
18853 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
18854 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
18855 
      return
18856 
    iprot.readStructBegin()
18857 
    while True:
18858 
      (fname, ftype, fid) = iprot.readFieldBegin()
18859 
      if ftype == TType.STOP:
18860 
        break
18861 
      if fid == 1:
18862 
        if ftype == TType.I64:
18863 
          self.transactionId = iprot.readI64();
18864 
        else:
18865 
          iprot.skip(ftype)
18866 
      elif fid == 2:
18867 
        if ftype == TType.I32:
18868 
          self.category = iprot.readI32();
18869 
        else:
18870 
          iprot.skip(ftype)
18871 
      else:
18872 
        iprot.skip(ftype)
18873 
      iprot.readFieldEnd()
18874 
    iprot.readStructEnd()
18875 
 
18876 
  def write(self, oprot):
18877 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
18878 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
18879 
      return
18880 
    oprot.writeStructBegin('markTransactionAsProcessed_args')
18881 
    if self.transactionId is not None:
18882 
      oprot.writeFieldBegin('transactionId', TType.I64, 1)
18883 
      oprot.writeI64(self.transactionId)
18884 
      oprot.writeFieldEnd()
18885 
    if self.category is not None:
18886 
      oprot.writeFieldBegin('category', TType.I32, 2)
18887 
      oprot.writeI32(self.category)
18888 
      oprot.writeFieldEnd()
18889 
    oprot.writeFieldStop()
18890 
    oprot.writeStructEnd()
18891 
 
18892 
  def validate(self):
18893 
    return
18894 
 
18895 
 
18896 
  def __repr__(self):
18897 
    L = ['%s=%r' % (key, value)
18898 
      for key, value in self.__dict__.iteritems()]
18899 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
18900 
 
18901 
  def __eq__(self, other):
18902 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
18903 
 
18904 
  def __ne__(self, other):
18905 
    return not (self == other)
18906 
 
18907 
class markTransactionAsProcessed_result:
18908 
 
18909 
  thrift_spec = (
18910 
  )
18911 
 
18912 
  def read(self, iprot):
18913 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
18914 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
18915 
      return
18916 
    iprot.readStructBegin()
18917 
    while True:
18918 
      (fname, ftype, fid) = iprot.readFieldBegin()
18919 
      if ftype == TType.STOP:
18920 
        break
18921 
      else:
18922 
        iprot.skip(ftype)
18923 
      iprot.readFieldEnd()
18924 
    iprot.readStructEnd()
18925 
 
18926 
  def write(self, oprot):
18927 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
18928 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
18929 
      return
18930 
    oprot.writeStructBegin('markTransactionAsProcessed_result')
18931 
    oprot.writeFieldStop()
18932 
    oprot.writeStructEnd()
18933 
 
18934 
  def validate(self):
18935 
    return
18936 
 
18937 
 
18938 
  def __repr__(self):
18939 
    L = ['%s=%r' % (key, value)
18940 
      for key, value in self.__dict__.iteritems()]
18941 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
18942 
 
18943 
  def __eq__(self, other):
18944 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
18945 
 
18946 
  def __ne__(self, other):
18947 
    return not (self == other)
4018 chandransh 18948 
 
18949 
class getItemWiseRiskyOrdersCount_args:
18950 
 
18951 
  thrift_spec = (
18952 
  )
18953 
 
18954 
  def read(self, iprot):
18955 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
18956 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
18957 
      return
18958 
    iprot.readStructBegin()
18959 
    while True:
18960 
      (fname, ftype, fid) = iprot.readFieldBegin()
18961 
      if ftype == TType.STOP:
18962 
        break
18963 
      else:
18964 
        iprot.skip(ftype)
18965 
      iprot.readFieldEnd()
18966 
    iprot.readStructEnd()
18967 
 
18968 
  def write(self, oprot):
18969 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
18970 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
18971 
      return
18972 
    oprot.writeStructBegin('getItemWiseRiskyOrdersCount_args')
18973 
    oprot.writeFieldStop()
18974 
    oprot.writeStructEnd()
18975 
 
18976 
  def validate(self):
18977 
    return
18978 
 
18979 
 
18980 
  def __repr__(self):
18981 
    L = ['%s=%r' % (key, value)
18982 
      for key, value in self.__dict__.iteritems()]
18983 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
18984 
 
18985 
  def __eq__(self, other):
18986 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
18987 
 
18988 
  def __ne__(self, other):
18989 
    return not (self == other)
18990 
 
18991 
class getItemWiseRiskyOrdersCount_result:
18992 
  """
18993 
  Attributes:
18994 
   - success
18995 
  """
18996 
 
18997 
  thrift_spec = (
18998 
    (0, TType.MAP, 'success', (TType.I64,None,TType.I64,None), None, ), # 0
18999 
  )
19000 
 
19001 
  def __init__(self, success=None,):
19002 
    self.success = success
19003 
 
19004 
  def read(self, iprot):
19005 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
19006 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
19007 
      return
19008 
    iprot.readStructBegin()
19009 
    while True:
19010 
      (fname, ftype, fid) = iprot.readFieldBegin()
19011 
      if ftype == TType.STOP:
19012 
        break
19013 
      if fid == 0:
19014 
        if ftype == TType.MAP:
19015 
          self.success = {}
5713 rajveer 19016 
          (_ktype436, _vtype437, _size435 ) = iprot.readMapBegin()
19017 
          for _i439 in xrange(_size435):
19018 
            _key440 = iprot.readI64();
19019 
            _val441 = iprot.readI64();
19020 
            self.success[_key440] = _val441
4018 chandransh 19021 
          iprot.readMapEnd()
19022 
        else:
19023 
          iprot.skip(ftype)
19024 
      else:
19025 
        iprot.skip(ftype)
19026 
      iprot.readFieldEnd()
19027 
    iprot.readStructEnd()
19028 
 
19029 
  def write(self, oprot):
19030 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
19031 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
19032 
      return
19033 
    oprot.writeStructBegin('getItemWiseRiskyOrdersCount_result')
19034 
    if self.success is not None:
19035 
      oprot.writeFieldBegin('success', TType.MAP, 0)
19036 
      oprot.writeMapBegin(TType.I64, TType.I64, len(self.success))
5713 rajveer 19037 
      for kiter442,viter443 in self.success.items():
19038 
        oprot.writeI64(kiter442)
19039 
        oprot.writeI64(viter443)
4018 chandransh 19040 
      oprot.writeMapEnd()
19041 
      oprot.writeFieldEnd()
19042 
    oprot.writeFieldStop()
19043 
    oprot.writeStructEnd()
19044 
 
19045 
  def validate(self):
19046 
    return
19047 
 
19048 
 
19049 
  def __repr__(self):
19050 
    L = ['%s=%r' % (key, value)
19051 
      for key, value in self.__dict__.iteritems()]
19052 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
19053 
 
19054 
  def __eq__(self, other):
19055 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
19056 
 
19057 
  def __ne__(self, other):
19058 
    return not (self == other)
4247 rajveer 19059 
 
4295 varun.gupt 19060 
class getOrdersForItemIds_args:
19061 
  """
19062 
  Attributes:
19063 
   - itemIds
19064 
  """
19065 
 
19066 
  thrift_spec = (
19067 
    None, # 0
19068 
    (1, TType.LIST, 'itemIds', (TType.I64,None), None, ), # 1
19069 
  )
19070 
 
19071 
  def __init__(self, itemIds=None,):
19072 
    self.itemIds = itemIds
19073 
 
19074 
  def read(self, iprot):
19075 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
19076 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
19077 
      return
19078 
    iprot.readStructBegin()
19079 
    while True:
19080 
      (fname, ftype, fid) = iprot.readFieldBegin()
19081 
      if ftype == TType.STOP:
19082 
        break
19083 
      if fid == 1:
19084 
        if ftype == TType.LIST:
19085 
          self.itemIds = []
5713 rajveer 19086 
          (_etype447, _size444) = iprot.readListBegin()
19087 
          for _i448 in xrange(_size444):
19088 
            _elem449 = iprot.readI64();
19089 
            self.itemIds.append(_elem449)
4295 varun.gupt 19090 
          iprot.readListEnd()
19091 
        else:
19092 
          iprot.skip(ftype)
19093 
      else:
19094 
        iprot.skip(ftype)
19095 
      iprot.readFieldEnd()
19096 
    iprot.readStructEnd()
19097 
 
19098 
  def write(self, oprot):
19099 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
19100 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
19101 
      return
19102 
    oprot.writeStructBegin('getOrdersForItemIds_args')
19103 
    if self.itemIds is not None:
19104 
      oprot.writeFieldBegin('itemIds', TType.LIST, 1)
19105 
      oprot.writeListBegin(TType.I64, len(self.itemIds))
5713 rajveer 19106 
      for iter450 in self.itemIds:
19107 
        oprot.writeI64(iter450)
4295 varun.gupt 19108 
      oprot.writeListEnd()
19109 
      oprot.writeFieldEnd()
19110 
    oprot.writeFieldStop()
19111 
    oprot.writeStructEnd()
19112 
 
19113 
  def validate(self):
19114 
    return
19115 
 
19116 
 
19117 
  def __repr__(self):
19118 
    L = ['%s=%r' % (key, value)
19119 
      for key, value in self.__dict__.iteritems()]
19120 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
19121 
 
19122 
  def __eq__(self, other):
19123 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
19124 
 
19125 
  def __ne__(self, other):
19126 
    return not (self == other)
19127 
 
19128 
class getOrdersForItemIds_result:
19129 
  """
19130 
  Attributes:
19131 
   - success
19132 
  """
19133 
 
19134 
  thrift_spec = (
19135 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
19136 
  )
19137 
 
19138 
  def __init__(self, success=None,):
19139 
    self.success = success
19140 
 
19141 
  def read(self, iprot):
19142 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
19143 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
19144 
      return
19145 
    iprot.readStructBegin()
19146 
    while True:
19147 
      (fname, ftype, fid) = iprot.readFieldBegin()
19148 
      if ftype == TType.STOP:
19149 
        break
19150 
      if fid == 0:
19151 
        if ftype == TType.LIST:
19152 
          self.success = []
5713 rajveer 19153 
          (_etype454, _size451) = iprot.readListBegin()
19154 
          for _i455 in xrange(_size451):
19155 
            _elem456 = Order()
19156 
            _elem456.read(iprot)
19157 
            self.success.append(_elem456)
4295 varun.gupt 19158 
          iprot.readListEnd()
19159 
        else:
19160 
          iprot.skip(ftype)
19161 
      else:
19162 
        iprot.skip(ftype)
19163 
      iprot.readFieldEnd()
19164 
    iprot.readStructEnd()
19165 
 
19166 
  def write(self, oprot):
19167 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
19168 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
19169 
      return
19170 
    oprot.writeStructBegin('getOrdersForItemIds_result')
19171 
    if self.success is not None:
19172 
      oprot.writeFieldBegin('success', TType.LIST, 0)
19173 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
5713 rajveer 19174 
      for iter457 in self.success:
19175 
        iter457.write(oprot)
4295 varun.gupt 19176 
      oprot.writeListEnd()
19177 
      oprot.writeFieldEnd()
19178 
    oprot.writeFieldStop()
19179 
    oprot.writeStructEnd()
19180 
 
19181 
  def validate(self):
19182 
    return
19183 
 
19184 
 
19185 
  def __repr__(self):
19186 
    L = ['%s=%r' % (key, value)
19187 
      for key, value in self.__dict__.iteritems()]
19188 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
19189 
 
19190 
  def __eq__(self, other):
19191 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
19192 
 
19193 
  def __ne__(self, other):
19194 
    return not (self == other)
19195 
 
4247 rajveer 19196 
class markOrderCancellationRequestReceived_args:
19197 
  """
19198 
  Attributes:
19199 
   - orderId
19200 
  """
19201 
 
19202 
  thrift_spec = (
19203 
    None, # 0
19204 
    (1, TType.I64, 'orderId', None, None, ), # 1
19205 
  )
19206 
 
19207 
  def __init__(self, orderId=None,):
19208 
    self.orderId = orderId
19209 
 
19210 
  def read(self, iprot):
19211 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
19212 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
19213 
      return
19214 
    iprot.readStructBegin()
19215 
    while True:
19216 
      (fname, ftype, fid) = iprot.readFieldBegin()
19217 
      if ftype == TType.STOP:
19218 
        break
19219 
      if fid == 1:
19220 
        if ftype == TType.I64:
19221 
          self.orderId = iprot.readI64();
19222 
        else:
19223 
          iprot.skip(ftype)
19224 
      else:
19225 
        iprot.skip(ftype)
19226 
      iprot.readFieldEnd()
19227 
    iprot.readStructEnd()
19228 
 
19229 
  def write(self, oprot):
19230 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
19231 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
19232 
      return
19233 
    oprot.writeStructBegin('markOrderCancellationRequestReceived_args')
19234 
    if self.orderId is not None:
19235 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
19236 
      oprot.writeI64(self.orderId)
19237 
      oprot.writeFieldEnd()
19238 
    oprot.writeFieldStop()
19239 
    oprot.writeStructEnd()
19240 
 
19241 
  def validate(self):
19242 
    return
19243 
 
19244 
 
19245 
  def __repr__(self):
19246 
    L = ['%s=%r' % (key, value)
19247 
      for key, value in self.__dict__.iteritems()]
19248 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
19249 
 
19250 
  def __eq__(self, other):
19251 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
19252 
 
19253 
  def __ne__(self, other):
19254 
    return not (self == other)
19255 
 
19256 
class markOrderCancellationRequestReceived_result:
19257 
  """
19258 
  Attributes:
19259 
   - ex
19260 
  """
19261 
 
19262 
  thrift_spec = (
19263 
    None, # 0
19264 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
19265 
  )
19266 
 
19267 
  def __init__(self, ex=None,):
19268 
    self.ex = ex
19269 
 
19270 
  def read(self, iprot):
19271 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
19272 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
19273 
      return
19274 
    iprot.readStructBegin()
19275 
    while True:
19276 
      (fname, ftype, fid) = iprot.readFieldBegin()
19277 
      if ftype == TType.STOP:
19278 
        break
19279 
      if fid == 1:
19280 
        if ftype == TType.STRUCT:
19281 
          self.ex = TransactionServiceException()
19282 
          self.ex.read(iprot)
19283 
        else:
19284 
          iprot.skip(ftype)
19285 
      else:
19286 
        iprot.skip(ftype)
19287 
      iprot.readFieldEnd()
19288 
    iprot.readStructEnd()
19289 
 
19290 
  def write(self, oprot):
19291 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
19292 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
19293 
      return
19294 
    oprot.writeStructBegin('markOrderCancellationRequestReceived_result')
19295 
    if self.ex is not None:
19296 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
19297 
      self.ex.write(oprot)
19298 
      oprot.writeFieldEnd()
19299 
    oprot.writeFieldStop()
19300 
    oprot.writeStructEnd()
19301 
 
19302 
  def validate(self):
19303 
    return
19304 
 
19305 
 
19306 
  def __repr__(self):
19307 
    L = ['%s=%r' % (key, value)
19308 
      for key, value in self.__dict__.iteritems()]
19309 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
19310 
 
19311 
  def __eq__(self, other):
19312 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
19313 
 
19314 
  def __ne__(self, other):
19315 
    return not (self == other)
19316 
 
19317 
class markOrderCancellationRequestConfirmed_args:
19318 
  """
19319 
  Attributes:
19320 
   - orderId
19321 
  """
19322 
 
19323 
  thrift_spec = (
19324 
    None, # 0
19325 
    (1, TType.I64, 'orderId', None, None, ), # 1
19326 
  )
19327 
 
19328 
  def __init__(self, orderId=None,):
19329 
    self.orderId = orderId
19330 
 
19331 
  def read(self, iprot):
19332 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
19333 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
19334 
      return
19335 
    iprot.readStructBegin()
19336 
    while True:
19337 
      (fname, ftype, fid) = iprot.readFieldBegin()
19338 
      if ftype == TType.STOP:
19339 
        break
19340 
      if fid == 1:
19341 
        if ftype == TType.I64:
19342 
          self.orderId = iprot.readI64();
19343 
        else:
19344 
          iprot.skip(ftype)
19345 
      else:
19346 
        iprot.skip(ftype)
19347 
      iprot.readFieldEnd()
19348 
    iprot.readStructEnd()
19349 
 
19350 
  def write(self, oprot):
19351 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
19352 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
19353 
      return
19354 
    oprot.writeStructBegin('markOrderCancellationRequestConfirmed_args')
19355 
    if self.orderId is not None:
19356 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
19357 
      oprot.writeI64(self.orderId)
19358 
      oprot.writeFieldEnd()
19359 
    oprot.writeFieldStop()
19360 
    oprot.writeStructEnd()
19361 
 
19362 
  def validate(self):
19363 
    return
19364 
 
19365 
 
19366 
  def __repr__(self):
19367 
    L = ['%s=%r' % (key, value)
19368 
      for key, value in self.__dict__.iteritems()]
19369 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
19370 
 
19371 
  def __eq__(self, other):
19372 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
19373 
 
19374 
  def __ne__(self, other):
19375 
    return not (self == other)
19376 
 
19377 
class markOrderCancellationRequestConfirmed_result:
19378 
  """
19379 
  Attributes:
19380 
   - ex
19381 
  """
19382 
 
19383 
  thrift_spec = (
19384 
    None, # 0
19385 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
19386 
  )
19387 
 
19388 
  def __init__(self, ex=None,):
19389 
    self.ex = ex
19390 
 
19391 
  def read(self, iprot):
19392 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
19393 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
19394 
      return
19395 
    iprot.readStructBegin()
19396 
    while True:
19397 
      (fname, ftype, fid) = iprot.readFieldBegin()
19398 
      if ftype == TType.STOP:
19399 
        break
19400 
      if fid == 1:
19401 
        if ftype == TType.STRUCT:
19402 
          self.ex = TransactionServiceException()
19403 
          self.ex.read(iprot)
19404 
        else:
19405 
          iprot.skip(ftype)
19406 
      else:
19407 
        iprot.skip(ftype)
19408 
      iprot.readFieldEnd()
19409 
    iprot.readStructEnd()
19410 
 
19411 
  def write(self, oprot):
19412 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
19413 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
19414 
      return
19415 
    oprot.writeStructBegin('markOrderCancellationRequestConfirmed_result')
19416 
    if self.ex is not None:
19417 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
19418 
      self.ex.write(oprot)
19419 
      oprot.writeFieldEnd()
19420 
    oprot.writeFieldStop()
19421 
    oprot.writeStructEnd()
19422 
 
19423 
  def validate(self):
19424 
    return
19425 
 
19426 
 
19427 
  def __repr__(self):
19428 
    L = ['%s=%r' % (key, value)
19429 
      for key, value in self.__dict__.iteritems()]
19430 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
19431 
 
19432 
  def __eq__(self, other):
19433 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
19434 
 
19435 
  def __ne__(self, other):
19436 
    return not (self == other)
19437 
 
19438 
class markOrderCancellationRequestDenied_args:
19439 
  """
19440 
  Attributes:
19441 
   - orderId
19442 
  """
19443 
 
19444 
  thrift_spec = (
19445 
    None, # 0
19446 
    (1, TType.I64, 'orderId', None, None, ), # 1
19447 
  )
19448 
 
19449 
  def __init__(self, orderId=None,):
19450 
    self.orderId = orderId
19451 
 
19452 
  def read(self, iprot):
19453 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
19454 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
19455 
      return
19456 
    iprot.readStructBegin()
19457 
    while True:
19458 
      (fname, ftype, fid) = iprot.readFieldBegin()
19459 
      if ftype == TType.STOP:
19460 
        break
19461 
      if fid == 1:
19462 
        if ftype == TType.I64:
19463 
          self.orderId = iprot.readI64();
19464 
        else:
19465 
          iprot.skip(ftype)
19466 
      else:
19467 
        iprot.skip(ftype)
19468 
      iprot.readFieldEnd()
19469 
    iprot.readStructEnd()
19470 
 
19471 
  def write(self, oprot):
19472 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
19473 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
19474 
      return
19475 
    oprot.writeStructBegin('markOrderCancellationRequestDenied_args')
19476 
    if self.orderId is not None:
19477 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
19478 
      oprot.writeI64(self.orderId)
19479 
      oprot.writeFieldEnd()
19480 
    oprot.writeFieldStop()
19481 
    oprot.writeStructEnd()
19482 
 
19483 
  def validate(self):
19484 
    return
19485 
 
19486 
 
19487 
  def __repr__(self):
19488 
    L = ['%s=%r' % (key, value)
19489 
      for key, value in self.__dict__.iteritems()]
19490 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
19491 
 
19492 
  def __eq__(self, other):
19493 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
19494 
 
19495 
  def __ne__(self, other):
19496 
    return not (self == other)
19497 
 
19498 
class markOrderCancellationRequestDenied_result:
19499 
  """
19500 
  Attributes:
19501 
   - ex
19502 
  """
19503 
 
19504 
  thrift_spec = (
19505 
    None, # 0
19506 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
19507 
  )
19508 
 
19509 
  def __init__(self, ex=None,):
19510 
    self.ex = ex
19511 
 
19512 
  def read(self, iprot):
19513 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
19514 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
19515 
      return
19516 
    iprot.readStructBegin()
19517 
    while True:
19518 
      (fname, ftype, fid) = iprot.readFieldBegin()
19519 
      if ftype == TType.STOP:
19520 
        break
19521 
      if fid == 1:
19522 
        if ftype == TType.STRUCT:
19523 
          self.ex = TransactionServiceException()
19524 
          self.ex.read(iprot)
19525 
        else:
19526 
          iprot.skip(ftype)
19527 
      else:
19528 
        iprot.skip(ftype)
19529 
      iprot.readFieldEnd()
19530 
    iprot.readStructEnd()
19531 
 
19532 
  def write(self, oprot):
19533 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
19534 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
19535 
      return
19536 
    oprot.writeStructBegin('markOrderCancellationRequestDenied_result')
19537 
    if self.ex is not None:
19538 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
19539 
      self.ex.write(oprot)
19540 
      oprot.writeFieldEnd()
19541 
    oprot.writeFieldStop()
19542 
    oprot.writeStructEnd()
19543 
 
19544 
  def validate(self):
19545 
    return
19546 
 
19547 
 
19548 
  def __repr__(self):
19549 
    L = ['%s=%r' % (key, value)
19550 
      for key, value in self.__dict__.iteritems()]
19551 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
19552 
 
19553 
  def __eq__(self, other):
19554 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
19555 
 
19556 
  def __ne__(self, other):
19557 
    return not (self == other)
19558 
 
4258 rajveer 19559 
class markTransactionAsPaymentFlagRemoved_args:
4247 rajveer 19560 
  """
19561 
  Attributes:
4258 rajveer 19562 
   - transactionId
4247 rajveer 19563 
  """
19564 
 
19565 
  thrift_spec = (
19566 
    None, # 0
4258 rajveer 19567 
    (1, TType.I64, 'transactionId', None, None, ), # 1
4247 rajveer 19568 
  )
19569 
 
4258 rajveer 19570 
  def __init__(self, transactionId=None,):
19571 
    self.transactionId = transactionId
4247 rajveer 19572 
 
19573 
  def read(self, iprot):
19574 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
19575 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
19576 
      return
19577 
    iprot.readStructBegin()
19578 
    while True:
19579 
      (fname, ftype, fid) = iprot.readFieldBegin()
19580 
      if ftype == TType.STOP:
19581 
        break
19582 
      if fid == 1:
19583 
        if ftype == TType.I64:
4258 rajveer 19584 
          self.transactionId = iprot.readI64();
4247 rajveer 19585 
        else:
19586 
          iprot.skip(ftype)
19587 
      else:
19588 
        iprot.skip(ftype)
19589 
      iprot.readFieldEnd()
19590 
    iprot.readStructEnd()
19591 
 
19592 
  def write(self, oprot):
19593 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
19594 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
19595 
      return
4258 rajveer 19596 
    oprot.writeStructBegin('markTransactionAsPaymentFlagRemoved_args')
19597 
    if self.transactionId is not None:
19598 
      oprot.writeFieldBegin('transactionId', TType.I64, 1)
19599 
      oprot.writeI64(self.transactionId)
4247 rajveer 19600 
      oprot.writeFieldEnd()
19601 
    oprot.writeFieldStop()
19602 
    oprot.writeStructEnd()
19603 
 
19604 
  def validate(self):
19605 
    return
19606 
 
19607 
 
19608 
  def __repr__(self):
19609 
    L = ['%s=%r' % (key, value)
19610 
      for key, value in self.__dict__.iteritems()]
19611 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
19612 
 
19613 
  def __eq__(self, other):
19614 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
19615 
 
19616 
  def __ne__(self, other):
19617 
    return not (self == other)
19618 
 
4258 rajveer 19619 
class markTransactionAsPaymentFlagRemoved_result:
4247 rajveer 19620 
  """
19621 
  Attributes:
19622 
   - ex
19623 
  """
19624 
 
19625 
  thrift_spec = (
19626 
    None, # 0
19627 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
19628 
  )
19629 
 
19630 
  def __init__(self, ex=None,):
19631 
    self.ex = ex
19632 
 
19633 
  def read(self, iprot):
19634 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
19635 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
19636 
      return
19637 
    iprot.readStructBegin()
19638 
    while True:
19639 
      (fname, ftype, fid) = iprot.readFieldBegin()
19640 
      if ftype == TType.STOP:
19641 
        break
19642 
      if fid == 1:
19643 
        if ftype == TType.STRUCT:
19644 
          self.ex = TransactionServiceException()
19645 
          self.ex.read(iprot)
19646 
        else:
19647 
          iprot.skip(ftype)
19648 
      else:
19649 
        iprot.skip(ftype)
19650 
      iprot.readFieldEnd()
19651 
    iprot.readStructEnd()
19652 
 
19653 
  def write(self, oprot):
19654 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
19655 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
19656 
      return
4258 rajveer 19657 
    oprot.writeStructBegin('markTransactionAsPaymentFlagRemoved_result')
4247 rajveer 19658 
    if self.ex is not None:
19659 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
19660 
      self.ex.write(oprot)
19661 
      oprot.writeFieldEnd()
19662 
    oprot.writeFieldStop()
19663 
    oprot.writeStructEnd()
19664 
 
19665 
  def validate(self):
19666 
    return
19667 
 
19668 
 
19669 
  def __repr__(self):
19670 
    L = ['%s=%r' % (key, value)
19671 
      for key, value in self.__dict__.iteritems()]
19672 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
19673 
 
19674 
  def __eq__(self, other):
19675 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
19676 
 
19677 
  def __ne__(self, other):
19678 
    return not (self == other)
4259 anupam.sin 19679 
 
19680 
class refundTransaction_args:
19681 
  """
19682 
  Attributes:
19683 
   - transactionId
19684 
   - refundedBy
19685 
   - reason
19686 
  """
19687 
 
19688 
  thrift_spec = (
19689 
    None, # 0
19690 
    (1, TType.I64, 'transactionId', None, None, ), # 1
19691 
    (2, TType.STRING, 'refundedBy', None, None, ), # 2
19692 
    (3, TType.STRING, 'reason', None, None, ), # 3
19693 
  )
19694 
 
19695 
  def __init__(self, transactionId=None, refundedBy=None, reason=None,):
19696 
    self.transactionId = transactionId
19697 
    self.refundedBy = refundedBy
19698 
    self.reason = reason
19699 
 
19700 
  def read(self, iprot):
19701 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
19702 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
19703 
      return
19704 
    iprot.readStructBegin()
19705 
    while True:
19706 
      (fname, ftype, fid) = iprot.readFieldBegin()
19707 
      if ftype == TType.STOP:
19708 
        break
19709 
      if fid == 1:
19710 
        if ftype == TType.I64:
19711 
          self.transactionId = iprot.readI64();
19712 
        else:
19713 
          iprot.skip(ftype)
19714 
      elif fid == 2:
19715 
        if ftype == TType.STRING:
19716 
          self.refundedBy = iprot.readString();
19717 
        else:
19718 
          iprot.skip(ftype)
19719 
      elif fid == 3:
19720 
        if ftype == TType.STRING:
19721 
          self.reason = iprot.readString();
19722 
        else:
19723 
          iprot.skip(ftype)
19724 
      else:
19725 
        iprot.skip(ftype)
19726 
      iprot.readFieldEnd()
19727 
    iprot.readStructEnd()
19728 
 
19729 
  def write(self, oprot):
19730 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
19731 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
19732 
      return
19733 
    oprot.writeStructBegin('refundTransaction_args')
19734 
    if self.transactionId is not None:
19735 
      oprot.writeFieldBegin('transactionId', TType.I64, 1)
19736 
      oprot.writeI64(self.transactionId)
19737 
      oprot.writeFieldEnd()
19738 
    if self.refundedBy is not None:
19739 
      oprot.writeFieldBegin('refundedBy', TType.STRING, 2)
19740 
      oprot.writeString(self.refundedBy)
19741 
      oprot.writeFieldEnd()
19742 
    if self.reason is not None:
19743 
      oprot.writeFieldBegin('reason', TType.STRING, 3)
19744 
      oprot.writeString(self.reason)
19745 
      oprot.writeFieldEnd()
19746 
    oprot.writeFieldStop()
19747 
    oprot.writeStructEnd()
19748 
 
19749 
  def validate(self):
19750 
    return
19751 
 
19752 
 
19753 
  def __repr__(self):
19754 
    L = ['%s=%r' % (key, value)
19755 
      for key, value in self.__dict__.iteritems()]
19756 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
19757 
 
19758 
  def __eq__(self, other):
19759 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
19760 
 
19761 
  def __ne__(self, other):
19762 
    return not (self == other)
19763 
 
19764 
class refundTransaction_result:
19765 
  """
19766 
  Attributes:
19767 
   - ex
19768 
  """
19769 
 
19770 
  thrift_spec = (
19771 
    None, # 0
19772 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
19773 
  )
19774 
 
19775 
  def __init__(self, ex=None,):
19776 
    self.ex = ex
19777 
 
19778 
  def read(self, iprot):
19779 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
19780 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
19781 
      return
19782 
    iprot.readStructBegin()
19783 
    while True:
19784 
      (fname, ftype, fid) = iprot.readFieldBegin()
19785 
      if ftype == TType.STOP:
19786 
        break
19787 
      if fid == 1:
19788 
        if ftype == TType.STRUCT:
19789 
          self.ex = TransactionServiceException()
19790 
          self.ex.read(iprot)
19791 
        else:
19792 
          iprot.skip(ftype)
19793 
      else:
19794 
        iprot.skip(ftype)
19795 
      iprot.readFieldEnd()
19796 
    iprot.readStructEnd()
19797 
 
19798 
  def write(self, oprot):
19799 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
19800 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
19801 
      return
19802 
    oprot.writeStructBegin('refundTransaction_result')
19803 
    if self.ex is not None:
19804 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
19805 
      self.ex.write(oprot)
19806 
      oprot.writeFieldEnd()
19807 
    oprot.writeFieldStop()
19808 
    oprot.writeStructEnd()
19809 
 
19810 
  def validate(self):
19811 
    return
19812 
 
19813 
 
19814 
  def __repr__(self):
19815 
    L = ['%s=%r' % (key, value)
19816 
      for key, value in self.__dict__.iteritems()]
19817 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
19818 
 
19819 
  def __eq__(self, other):
19820 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
19821 
 
19822 
  def __ne__(self, other):
19823 
    return not (self == other)
4285 rajveer 19824 
 
4324 mandeep.dh 19825 
class updateShipmentAddress_args:
19826 
  """
19827 
  Attributes:
19828 
   - orderId
19829 
   - addressId
19830 
  """
19831 
 
19832 
  thrift_spec = (
19833 
    None, # 0
19834 
    (1, TType.I64, 'orderId', None, None, ), # 1
19835 
    (2, TType.I64, 'addressId', None, None, ), # 2
19836 
  )
19837 
 
19838 
  def __init__(self, orderId=None, addressId=None,):
19839 
    self.orderId = orderId
19840 
    self.addressId = addressId
19841 
 
19842 
  def read(self, iprot):
19843 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
19844 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
19845 
      return
19846 
    iprot.readStructBegin()
19847 
    while True:
19848 
      (fname, ftype, fid) = iprot.readFieldBegin()
19849 
      if ftype == TType.STOP:
19850 
        break
19851 
      if fid == 1:
19852 
        if ftype == TType.I64:
19853 
          self.orderId = iprot.readI64();
19854 
        else:
19855 
          iprot.skip(ftype)
19856 
      elif fid == 2:
19857 
        if ftype == TType.I64:
19858 
          self.addressId = iprot.readI64();
19859 
        else:
19860 
          iprot.skip(ftype)
19861 
      else:
19862 
        iprot.skip(ftype)
19863 
      iprot.readFieldEnd()
19864 
    iprot.readStructEnd()
19865 
 
19866 
  def write(self, oprot):
19867 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
19868 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
19869 
      return
19870 
    oprot.writeStructBegin('updateShipmentAddress_args')
19871 
    if self.orderId is not None:
19872 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
19873 
      oprot.writeI64(self.orderId)
19874 
      oprot.writeFieldEnd()
19875 
    if self.addressId is not None:
19876 
      oprot.writeFieldBegin('addressId', TType.I64, 2)
19877 
      oprot.writeI64(self.addressId)
19878 
      oprot.writeFieldEnd()
19879 
    oprot.writeFieldStop()
19880 
    oprot.writeStructEnd()
19881 
 
19882 
  def validate(self):
19883 
    return
19884 
 
19885 
 
19886 
  def __repr__(self):
19887 
    L = ['%s=%r' % (key, value)
19888 
      for key, value in self.__dict__.iteritems()]
19889 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
19890 
 
19891 
  def __eq__(self, other):
19892 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
19893 
 
19894 
  def __ne__(self, other):
19895 
    return not (self == other)
19896 
 
19897 
class updateShipmentAddress_result:
19898 
  """
19899 
  Attributes:
19900 
   - ex
19901 
  """
19902 
 
19903 
  thrift_spec = (
19904 
    None, # 0
19905 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
19906 
  )
19907 
 
19908 
  def __init__(self, ex=None,):
19909 
    self.ex = ex
19910 
 
19911 
  def read(self, iprot):
19912 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
19913 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
19914 
      return
19915 
    iprot.readStructBegin()
19916 
    while True:
19917 
      (fname, ftype, fid) = iprot.readFieldBegin()
19918 
      if ftype == TType.STOP:
19919 
        break
19920 
      if 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('updateShipmentAddress_result')
19936 
    if self.ex is not None:
19937 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
19938 
      self.ex.write(oprot)
19939 
      oprot.writeFieldEnd()
19940 
    oprot.writeFieldStop()
19941 
    oprot.writeStructEnd()
19942 
 
19943 
  def validate(self):
19944 
    return
19945 
 
19946 
 
19947 
  def __repr__(self):
19948 
    L = ['%s=%r' % (key, value)
19949 
      for key, value in self.__dict__.iteritems()]
19950 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
19951 
 
19952 
  def __eq__(self, other):
19953 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
19954 
 
19955 
  def __ne__(self, other):
19956 
    return not (self == other)
19957 
 
4285 rajveer 19958 
class acceptOrdersForItemId_args:
19959 
  """
19960 
  Attributes:
19961 
   - itemId
19962 
   - inventory
19963 
  """
19964 
 
19965 
  thrift_spec = (
19966 
    None, # 0
19967 
    (1, TType.I64, 'itemId', None, None, ), # 1
19968 
    (2, TType.I64, 'inventory', None, None, ), # 2
19969 
  )
19970 
 
19971 
  def __init__(self, itemId=None, inventory=None,):
19972 
    self.itemId = itemId
19973 
    self.inventory = inventory
19974 
 
19975 
  def read(self, iprot):
19976 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
19977 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
19978 
      return
19979 
    iprot.readStructBegin()
19980 
    while True:
19981 
      (fname, ftype, fid) = iprot.readFieldBegin()
19982 
      if ftype == TType.STOP:
19983 
        break
19984 
      if fid == 1:
19985 
        if ftype == TType.I64:
19986 
          self.itemId = iprot.readI64();
19987 
        else:
19988 
          iprot.skip(ftype)
19989 
      elif fid == 2:
19990 
        if ftype == TType.I64:
19991 
          self.inventory = iprot.readI64();
19992 
        else:
19993 
          iprot.skip(ftype)
19994 
      else:
19995 
        iprot.skip(ftype)
19996 
      iprot.readFieldEnd()
19997 
    iprot.readStructEnd()
19998 
 
19999 
  def write(self, oprot):
20000 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
20001 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
20002 
      return
20003 
    oprot.writeStructBegin('acceptOrdersForItemId_args')
20004 
    if self.itemId is not None:
20005 
      oprot.writeFieldBegin('itemId', TType.I64, 1)
20006 
      oprot.writeI64(self.itemId)
20007 
      oprot.writeFieldEnd()
20008 
    if self.inventory is not None:
20009 
      oprot.writeFieldBegin('inventory', TType.I64, 2)
20010 
      oprot.writeI64(self.inventory)
20011 
      oprot.writeFieldEnd()
20012 
    oprot.writeFieldStop()
20013 
    oprot.writeStructEnd()
20014 
 
20015 
  def validate(self):
20016 
    return
20017 
 
20018 
 
20019 
  def __repr__(self):
20020 
    L = ['%s=%r' % (key, value)
20021 
      for key, value in self.__dict__.iteritems()]
20022 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
20023 
 
20024 
  def __eq__(self, other):
20025 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
20026 
 
20027 
  def __ne__(self, other):
20028 
    return not (self == other)
20029 
 
20030 
class acceptOrdersForItemId_result:
20031 
  """
20032 
  Attributes:
20033 
   - success
20034 
   - ex
20035 
  """
20036 
 
20037 
  thrift_spec = (
20038 
    (0, TType.BOOL, 'success', None, None, ), # 0
20039 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
20040 
  )
20041 
 
20042 
  def __init__(self, success=None, ex=None,):
20043 
    self.success = success
20044 
    self.ex = ex
20045 
 
20046 
  def read(self, iprot):
20047 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
20048 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
20049 
      return
20050 
    iprot.readStructBegin()
20051 
    while True:
20052 
      (fname, ftype, fid) = iprot.readFieldBegin()
20053 
      if ftype == TType.STOP:
20054 
        break
20055 
      if fid == 0:
20056 
        if ftype == TType.BOOL:
20057 
          self.success = iprot.readBool();
20058 
        else:
20059 
          iprot.skip(ftype)
20060 
      elif fid == 1:
20061 
        if ftype == TType.STRUCT:
20062 
          self.ex = TransactionServiceException()
20063 
          self.ex.read(iprot)
20064 
        else:
20065 
          iprot.skip(ftype)
20066 
      else:
20067 
        iprot.skip(ftype)
20068 
      iprot.readFieldEnd()
20069 
    iprot.readStructEnd()
20070 
 
20071 
  def write(self, oprot):
20072 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
20073 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
20074 
      return
20075 
    oprot.writeStructBegin('acceptOrdersForItemId_result')
20076 
    if self.success is not None:
20077 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
20078 
      oprot.writeBool(self.success)
20079 
      oprot.writeFieldEnd()
20080 
    if self.ex is not None:
20081 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
20082 
      self.ex.write(oprot)
20083 
      oprot.writeFieldEnd()
20084 
    oprot.writeFieldStop()
20085 
    oprot.writeStructEnd()
20086 
 
20087 
  def validate(self):
20088 
    return
20089 
 
20090 
 
20091 
  def __repr__(self):
20092 
    L = ['%s=%r' % (key, value)
20093 
      for key, value in self.__dict__.iteritems()]
20094 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
20095 
 
20096 
  def __eq__(self, other):
20097 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
20098 
 
20099 
  def __ne__(self, other):
20100 
    return not (self == other)
4303 rajveer 20101 
 
20102 
class markOrdersAsPORaised_args:
20103 
  """
20104 
  Attributes:
20105 
   - vendorId
20106 
   - itemId
20107 
   - quantity
20108 
   - estimate
4369 rajveer 20109 
   - isReminder
4303 rajveer 20110 
  """
20111 
 
20112 
  thrift_spec = (
20113 
    None, # 0
20114 
    (1, TType.I64, 'vendorId', None, None, ), # 1
20115 
    (2, TType.I64, 'itemId', None, None, ), # 2
20116 
    (3, TType.I64, 'quantity', None, None, ), # 3
20117 
    (4, TType.I64, 'estimate', None, None, ), # 4
4369 rajveer 20118 
    (5, TType.BOOL, 'isReminder', None, None, ), # 5
4303 rajveer 20119 
  )
20120 
 
4369 rajveer 20121 
  def __init__(self, vendorId=None, itemId=None, quantity=None, estimate=None, isReminder=None,):
4303 rajveer 20122 
    self.vendorId = vendorId
20123 
    self.itemId = itemId
20124 
    self.quantity = quantity
20125 
    self.estimate = estimate
4369 rajveer 20126 
    self.isReminder = isReminder
4303 rajveer 20127 
 
20128 
  def read(self, iprot):
20129 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
20130 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
20131 
      return
20132 
    iprot.readStructBegin()
20133 
    while True:
20134 
      (fname, ftype, fid) = iprot.readFieldBegin()
20135 
      if ftype == TType.STOP:
20136 
        break
20137 
      if fid == 1:
20138 
        if ftype == TType.I64:
20139 
          self.vendorId = iprot.readI64();
20140 
        else:
20141 
          iprot.skip(ftype)
20142 
      elif fid == 2:
20143 
        if ftype == TType.I64:
20144 
          self.itemId = iprot.readI64();
20145 
        else:
20146 
          iprot.skip(ftype)
20147 
      elif fid == 3:
20148 
        if ftype == TType.I64:
20149 
          self.quantity = iprot.readI64();
20150 
        else:
20151 
          iprot.skip(ftype)
20152 
      elif fid == 4:
20153 
        if ftype == TType.I64:
20154 
          self.estimate = iprot.readI64();
20155 
        else:
20156 
          iprot.skip(ftype)
4369 rajveer 20157 
      elif fid == 5:
20158 
        if ftype == TType.BOOL:
20159 
          self.isReminder = iprot.readBool();
20160 
        else:
20161 
          iprot.skip(ftype)
4303 rajveer 20162 
      else:
20163 
        iprot.skip(ftype)
20164 
      iprot.readFieldEnd()
20165 
    iprot.readStructEnd()
20166 
 
20167 
  def write(self, oprot):
20168 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
20169 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
20170 
      return
20171 
    oprot.writeStructBegin('markOrdersAsPORaised_args')
20172 
    if self.vendorId is not None:
20173 
      oprot.writeFieldBegin('vendorId', TType.I64, 1)
20174 
      oprot.writeI64(self.vendorId)
20175 
      oprot.writeFieldEnd()
20176 
    if self.itemId is not None:
20177 
      oprot.writeFieldBegin('itemId', TType.I64, 2)
20178 
      oprot.writeI64(self.itemId)
20179 
      oprot.writeFieldEnd()
20180 
    if self.quantity is not None:
20181 
      oprot.writeFieldBegin('quantity', TType.I64, 3)
20182 
      oprot.writeI64(self.quantity)
20183 
      oprot.writeFieldEnd()
20184 
    if self.estimate is not None:
20185 
      oprot.writeFieldBegin('estimate', TType.I64, 4)
20186 
      oprot.writeI64(self.estimate)
20187 
      oprot.writeFieldEnd()
4369 rajveer 20188 
    if self.isReminder is not None:
20189 
      oprot.writeFieldBegin('isReminder', TType.BOOL, 5)
20190 
      oprot.writeBool(self.isReminder)
20191 
      oprot.writeFieldEnd()
4303 rajveer 20192 
    oprot.writeFieldStop()
20193 
    oprot.writeStructEnd()
20194 
 
20195 
  def validate(self):
20196 
    return
20197 
 
20198 
 
20199 
  def __repr__(self):
20200 
    L = ['%s=%r' % (key, value)
20201 
      for key, value in self.__dict__.iteritems()]
20202 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
20203 
 
20204 
  def __eq__(self, other):
20205 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
20206 
 
20207 
  def __ne__(self, other):
20208 
    return not (self == other)
20209 
 
20210 
class markOrdersAsPORaised_result:
20211 
  """
20212 
  Attributes:
20213 
   - ex
20214 
  """
20215 
 
20216 
  thrift_spec = (
20217 
    None, # 0
20218 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
20219 
  )
20220 
 
20221 
  def __init__(self, ex=None,):
20222 
    self.ex = ex
20223 
 
20224 
  def read(self, iprot):
20225 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
20226 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
20227 
      return
20228 
    iprot.readStructBegin()
20229 
    while True:
20230 
      (fname, ftype, fid) = iprot.readFieldBegin()
20231 
      if ftype == TType.STOP:
20232 
        break
20233 
      if fid == 1:
20234 
        if ftype == TType.STRUCT:
20235 
          self.ex = TransactionServiceException()
20236 
          self.ex.read(iprot)
20237 
        else:
20238 
          iprot.skip(ftype)
20239 
      else:
20240 
        iprot.skip(ftype)
20241 
      iprot.readFieldEnd()
20242 
    iprot.readStructEnd()
20243 
 
20244 
  def write(self, oprot):
20245 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
20246 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
20247 
      return
20248 
    oprot.writeStructBegin('markOrdersAsPORaised_result')
20249 
    if self.ex is not None:
20250 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
20251 
      self.ex.write(oprot)
20252 
      oprot.writeFieldEnd()
20253 
    oprot.writeFieldStop()
20254 
    oprot.writeStructEnd()
20255 
 
20256 
  def validate(self):
20257 
    return
20258 
 
20259 
 
20260 
  def __repr__(self):
20261 
    L = ['%s=%r' % (key, value)
20262 
      for key, value in self.__dict__.iteritems()]
20263 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
20264 
 
20265 
  def __eq__(self, other):
20266 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
20267 
 
20268 
  def __ne__(self, other):
20269 
    return not (self == other)
20270 
 
20271 
class markOrdersAsReversalInitiated_args:
20272 
  """
20273 
  Attributes:
20274 
   - vendorId
20275 
   - itemId
20276 
   - quantity
20277 
   - estimate
4369 rajveer 20278 
   - isReminder
4303 rajveer 20279 
  """
20280 
 
20281 
  thrift_spec = (
20282 
    None, # 0
20283 
    (1, TType.I64, 'vendorId', None, None, ), # 1
20284 
    (2, TType.I64, 'itemId', None, None, ), # 2
20285 
    (3, TType.I64, 'quantity', None, None, ), # 3
20286 
    (4, TType.I64, 'estimate', None, None, ), # 4
4369 rajveer 20287 
    (5, TType.BOOL, 'isReminder', None, None, ), # 5
4303 rajveer 20288 
  )
20289 
 
4369 rajveer 20290 
  def __init__(self, vendorId=None, itemId=None, quantity=None, estimate=None, isReminder=None,):
4303 rajveer 20291 
    self.vendorId = vendorId
20292 
    self.itemId = itemId
20293 
    self.quantity = quantity
20294 
    self.estimate = estimate
4369 rajveer 20295 
    self.isReminder = isReminder
4303 rajveer 20296 
 
20297 
  def read(self, iprot):
20298 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
20299 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
20300 
      return
20301 
    iprot.readStructBegin()
20302 
    while True:
20303 
      (fname, ftype, fid) = iprot.readFieldBegin()
20304 
      if ftype == TType.STOP:
20305 
        break
20306 
      if fid == 1:
20307 
        if ftype == TType.I64:
20308 
          self.vendorId = iprot.readI64();
20309 
        else:
20310 
          iprot.skip(ftype)
20311 
      elif fid == 2:
20312 
        if ftype == TType.I64:
20313 
          self.itemId = iprot.readI64();
20314 
        else:
20315 
          iprot.skip(ftype)
20316 
      elif fid == 3:
20317 
        if ftype == TType.I64:
20318 
          self.quantity = iprot.readI64();
20319 
        else:
20320 
          iprot.skip(ftype)
20321 
      elif fid == 4:
20322 
        if ftype == TType.I64:
20323 
          self.estimate = iprot.readI64();
20324 
        else:
20325 
          iprot.skip(ftype)
4369 rajveer 20326 
      elif fid == 5:
20327 
        if ftype == TType.BOOL:
20328 
          self.isReminder = iprot.readBool();
20329 
        else:
20330 
          iprot.skip(ftype)
4303 rajveer 20331 
      else:
20332 
        iprot.skip(ftype)
20333 
      iprot.readFieldEnd()
20334 
    iprot.readStructEnd()
20335 
 
20336 
  def write(self, oprot):
20337 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
20338 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
20339 
      return
20340 
    oprot.writeStructBegin('markOrdersAsReversalInitiated_args')
20341 
    if self.vendorId is not None:
20342 
      oprot.writeFieldBegin('vendorId', TType.I64, 1)
20343 
      oprot.writeI64(self.vendorId)
20344 
      oprot.writeFieldEnd()
20345 
    if self.itemId is not None:
20346 
      oprot.writeFieldBegin('itemId', TType.I64, 2)
20347 
      oprot.writeI64(self.itemId)
20348 
      oprot.writeFieldEnd()
20349 
    if self.quantity is not None:
20350 
      oprot.writeFieldBegin('quantity', TType.I64, 3)
20351 
      oprot.writeI64(self.quantity)
20352 
      oprot.writeFieldEnd()
20353 
    if self.estimate is not None:
20354 
      oprot.writeFieldBegin('estimate', TType.I64, 4)
20355 
      oprot.writeI64(self.estimate)
20356 
      oprot.writeFieldEnd()
4369 rajveer 20357 
    if self.isReminder is not None:
20358 
      oprot.writeFieldBegin('isReminder', TType.BOOL, 5)
20359 
      oprot.writeBool(self.isReminder)
20360 
      oprot.writeFieldEnd()
4303 rajveer 20361 
    oprot.writeFieldStop()
20362 
    oprot.writeStructEnd()
20363 
 
20364 
  def validate(self):
20365 
    return
20366 
 
20367 
 
20368 
  def __repr__(self):
20369 
    L = ['%s=%r' % (key, value)
20370 
      for key, value in self.__dict__.iteritems()]
20371 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
20372 
 
20373 
  def __eq__(self, other):
20374 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
20375 
 
20376 
  def __ne__(self, other):
20377 
    return not (self == other)
20378 
 
20379 
class markOrdersAsReversalInitiated_result:
20380 
  """
20381 
  Attributes:
20382 
   - ex
20383 
  """
20384 
 
20385 
  thrift_spec = (
20386 
    None, # 0
20387 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
20388 
  )
20389 
 
20390 
  def __init__(self, ex=None,):
20391 
    self.ex = ex
20392 
 
20393 
  def read(self, iprot):
20394 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
20395 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
20396 
      return
20397 
    iprot.readStructBegin()
20398 
    while True:
20399 
      (fname, ftype, fid) = iprot.readFieldBegin()
20400 
      if ftype == TType.STOP:
20401 
        break
20402 
      if fid == 1:
20403 
        if ftype == TType.STRUCT:
20404 
          self.ex = TransactionServiceException()
20405 
          self.ex.read(iprot)
20406 
        else:
20407 
          iprot.skip(ftype)
20408 
      else:
20409 
        iprot.skip(ftype)
20410 
      iprot.readFieldEnd()
20411 
    iprot.readStructEnd()
20412 
 
20413 
  def write(self, oprot):
20414 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
20415 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
20416 
      return
20417 
    oprot.writeStructBegin('markOrdersAsReversalInitiated_result')
20418 
    if self.ex is not None:
20419 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
20420 
      self.ex.write(oprot)
20421 
      oprot.writeFieldEnd()
20422 
    oprot.writeFieldStop()
20423 
    oprot.writeStructEnd()
20424 
 
20425 
  def validate(self):
20426 
    return
20427 
 
20428 
 
20429 
  def __repr__(self):
20430 
    L = ['%s=%r' % (key, value)
20431 
      for key, value in self.__dict__.iteritems()]
20432 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
20433 
 
20434 
  def __eq__(self, other):
20435 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
20436 
 
20437 
  def __ne__(self, other):
20438 
    return not (self == other)
20439 
 
20440 
class markOrdersAsNotAvailabke_args:
20441 
  """
20442 
  Attributes:
20443 
   - vendorId
20444 
   - itemId
20445 
   - quantity
20446 
   - estimate
4369 rajveer 20447 
   - isReminder
4303 rajveer 20448 
  """
20449 
 
20450 
  thrift_spec = (
20451 
    None, # 0
20452 
    (1, TType.I64, 'vendorId', None, None, ), # 1
20453 
    (2, TType.I64, 'itemId', None, None, ), # 2
20454 
    (3, TType.I64, 'quantity', None, None, ), # 3
20455 
    (4, TType.I64, 'estimate', None, None, ), # 4
4369 rajveer 20456 
    (5, TType.BOOL, 'isReminder', None, None, ), # 5
4303 rajveer 20457 
  )
20458 
 
4369 rajveer 20459 
  def __init__(self, vendorId=None, itemId=None, quantity=None, estimate=None, isReminder=None,):
4303 rajveer 20460 
    self.vendorId = vendorId
20461 
    self.itemId = itemId
20462 
    self.quantity = quantity
20463 
    self.estimate = estimate
4369 rajveer 20464 
    self.isReminder = isReminder
4303 rajveer 20465 
 
20466 
  def read(self, iprot):
20467 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
20468 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
20469 
      return
20470 
    iprot.readStructBegin()
20471 
    while True:
20472 
      (fname, ftype, fid) = iprot.readFieldBegin()
20473 
      if ftype == TType.STOP:
20474 
        break
20475 
      if fid == 1:
20476 
        if ftype == TType.I64:
20477 
          self.vendorId = iprot.readI64();
20478 
        else:
20479 
          iprot.skip(ftype)
20480 
      elif fid == 2:
20481 
        if ftype == TType.I64:
20482 
          self.itemId = iprot.readI64();
20483 
        else:
20484 
          iprot.skip(ftype)
20485 
      elif fid == 3:
20486 
        if ftype == TType.I64:
20487 
          self.quantity = iprot.readI64();
20488 
        else:
20489 
          iprot.skip(ftype)
20490 
      elif fid == 4:
20491 
        if ftype == TType.I64:
20492 
          self.estimate = iprot.readI64();
20493 
        else:
20494 
          iprot.skip(ftype)
4369 rajveer 20495 
      elif fid == 5:
20496 
        if ftype == TType.BOOL:
20497 
          self.isReminder = iprot.readBool();
20498 
        else:
20499 
          iprot.skip(ftype)
4303 rajveer 20500 
      else:
20501 
        iprot.skip(ftype)
20502 
      iprot.readFieldEnd()
20503 
    iprot.readStructEnd()
20504 
 
20505 
  def write(self, oprot):
20506 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
20507 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
20508 
      return
20509 
    oprot.writeStructBegin('markOrdersAsNotAvailabke_args')
20510 
    if self.vendorId is not None:
20511 
      oprot.writeFieldBegin('vendorId', TType.I64, 1)
20512 
      oprot.writeI64(self.vendorId)
20513 
      oprot.writeFieldEnd()
20514 
    if self.itemId is not None:
20515 
      oprot.writeFieldBegin('itemId', TType.I64, 2)
20516 
      oprot.writeI64(self.itemId)
20517 
      oprot.writeFieldEnd()
20518 
    if self.quantity is not None:
20519 
      oprot.writeFieldBegin('quantity', TType.I64, 3)
20520 
      oprot.writeI64(self.quantity)
20521 
      oprot.writeFieldEnd()
20522 
    if self.estimate is not None:
20523 
      oprot.writeFieldBegin('estimate', TType.I64, 4)
20524 
      oprot.writeI64(self.estimate)
20525 
      oprot.writeFieldEnd()
4369 rajveer 20526 
    if self.isReminder is not None:
20527 
      oprot.writeFieldBegin('isReminder', TType.BOOL, 5)
20528 
      oprot.writeBool(self.isReminder)
20529 
      oprot.writeFieldEnd()
4303 rajveer 20530 
    oprot.writeFieldStop()
20531 
    oprot.writeStructEnd()
20532 
 
20533 
  def validate(self):
20534 
    return
20535 
 
20536 
 
20537 
  def __repr__(self):
20538 
    L = ['%s=%r' % (key, value)
20539 
      for key, value in self.__dict__.iteritems()]
20540 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
20541 
 
20542 
  def __eq__(self, other):
20543 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
20544 
 
20545 
  def __ne__(self, other):
20546 
    return not (self == other)
20547 
 
20548 
class markOrdersAsNotAvailabke_result:
20549 
  """
20550 
  Attributes:
20551 
   - ex
20552 
  """
20553 
 
20554 
  thrift_spec = (
20555 
    None, # 0
20556 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
20557 
  )
20558 
 
20559 
  def __init__(self, ex=None,):
20560 
    self.ex = ex
20561 
 
20562 
  def read(self, iprot):
20563 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
20564 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
20565 
      return
20566 
    iprot.readStructBegin()
20567 
    while True:
20568 
      (fname, ftype, fid) = iprot.readFieldBegin()
20569 
      if ftype == TType.STOP:
20570 
        break
20571 
      if fid == 1:
20572 
        if ftype == TType.STRUCT:
20573 
          self.ex = TransactionServiceException()
20574 
          self.ex.read(iprot)
20575 
        else:
20576 
          iprot.skip(ftype)
20577 
      else:
20578 
        iprot.skip(ftype)
20579 
      iprot.readFieldEnd()
20580 
    iprot.readStructEnd()
20581 
 
20582 
  def write(self, oprot):
20583 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
20584 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
20585 
      return
20586 
    oprot.writeStructBegin('markOrdersAsNotAvailabke_result')
20587 
    if self.ex is not None:
20588 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
20589 
      self.ex.write(oprot)
20590 
      oprot.writeFieldEnd()
20591 
    oprot.writeFieldStop()
20592 
    oprot.writeStructEnd()
20593 
 
20594 
  def validate(self):
20595 
    return
20596 
 
20597 
 
20598 
  def __repr__(self):
20599 
    L = ['%s=%r' % (key, value)
20600 
      for key, value in self.__dict__.iteritems()]
20601 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
20602 
 
20603 
  def __eq__(self, other):
20604 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
20605 
 
20606 
  def __ne__(self, other):
20607 
    return not (self == other)
4369 rajveer 20608 
 
20609 
class markOrdersAsTimeout_args:
20610 
  """
20611 
  Attributes:
20612 
   - vendorId
20613 
  """
20614 
 
20615 
  thrift_spec = (
20616 
    None, # 0
20617 
    (1, TType.I64, 'vendorId', None, None, ), # 1
20618 
  )
20619 
 
20620 
  def __init__(self, vendorId=None,):
20621 
    self.vendorId = vendorId
20622 
 
20623 
  def read(self, iprot):
20624 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
20625 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
20626 
      return
20627 
    iprot.readStructBegin()
20628 
    while True:
20629 
      (fname, ftype, fid) = iprot.readFieldBegin()
20630 
      if ftype == TType.STOP:
20631 
        break
20632 
      if fid == 1:
20633 
        if ftype == TType.I64:
20634 
          self.vendorId = iprot.readI64();
20635 
        else:
20636 
          iprot.skip(ftype)
20637 
      else:
20638 
        iprot.skip(ftype)
20639 
      iprot.readFieldEnd()
20640 
    iprot.readStructEnd()
20641 
 
20642 
  def write(self, oprot):
20643 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
20644 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
20645 
      return
20646 
    oprot.writeStructBegin('markOrdersAsTimeout_args')
20647 
    if self.vendorId is not None:
20648 
      oprot.writeFieldBegin('vendorId', TType.I64, 1)
20649 
      oprot.writeI64(self.vendorId)
20650 
      oprot.writeFieldEnd()
20651 
    oprot.writeFieldStop()
20652 
    oprot.writeStructEnd()
20653 
 
20654 
  def validate(self):
20655 
    return
20656 
 
20657 
 
20658 
  def __repr__(self):
20659 
    L = ['%s=%r' % (key, value)
20660 
      for key, value in self.__dict__.iteritems()]
20661 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
20662 
 
20663 
  def __eq__(self, other):
20664 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
20665 
 
20666 
  def __ne__(self, other):
20667 
    return not (self == other)
20668 
 
20669 
class markOrdersAsTimeout_result:
20670 
  """
20671 
  Attributes:
20672 
   - success
20673 
   - ex
20674 
  """
20675 
 
20676 
  thrift_spec = (
20677 
    (0, TType.MAP, 'success', (TType.I32,None,TType.STRUCT,(TimeoutSummary, TimeoutSummary.thrift_spec)), None, ), # 0
20678 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
20679 
  )
20680 
 
20681 
  def __init__(self, success=None, ex=None,):
20682 
    self.success = success
20683 
    self.ex = ex
20684 
 
20685 
  def read(self, iprot):
20686 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
20687 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
20688 
      return
20689 
    iprot.readStructBegin()
20690 
    while True:
20691 
      (fname, ftype, fid) = iprot.readFieldBegin()
20692 
      if ftype == TType.STOP:
20693 
        break
20694 
      if fid == 0:
20695 
        if ftype == TType.MAP:
20696 
          self.success = {}
5713 rajveer 20697 
          (_ktype459, _vtype460, _size458 ) = iprot.readMapBegin()
20698 
          for _i462 in xrange(_size458):
20699 
            _key463 = iprot.readI32();
20700 
            _val464 = TimeoutSummary()
20701 
            _val464.read(iprot)
20702 
            self.success[_key463] = _val464
4369 rajveer 20703 
          iprot.readMapEnd()
20704 
        else:
20705 
          iprot.skip(ftype)
20706 
      elif fid == 1:
20707 
        if ftype == TType.STRUCT:
20708 
          self.ex = TransactionServiceException()
20709 
          self.ex.read(iprot)
20710 
        else:
20711 
          iprot.skip(ftype)
20712 
      else:
20713 
        iprot.skip(ftype)
20714 
      iprot.readFieldEnd()
20715 
    iprot.readStructEnd()
20716 
 
20717 
  def write(self, oprot):
20718 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
20719 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
20720 
      return
20721 
    oprot.writeStructBegin('markOrdersAsTimeout_result')
20722 
    if self.success is not None:
20723 
      oprot.writeFieldBegin('success', TType.MAP, 0)
20724 
      oprot.writeMapBegin(TType.I32, TType.STRUCT, len(self.success))
5713 rajveer 20725 
      for kiter465,viter466 in self.success.items():
20726 
        oprot.writeI32(kiter465)
20727 
        viter466.write(oprot)
4369 rajveer 20728 
      oprot.writeMapEnd()
20729 
      oprot.writeFieldEnd()
20730 
    if self.ex is not None:
20731 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
20732 
      self.ex.write(oprot)
20733 
      oprot.writeFieldEnd()
20734 
    oprot.writeFieldStop()
20735 
    oprot.writeStructEnd()
20736 
 
20737 
  def validate(self):
20738 
    return
20739 
 
20740 
 
20741 
  def __repr__(self):
20742 
    L = ['%s=%r' % (key, value)
20743 
      for key, value in self.__dict__.iteritems()]
20744 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
20745 
 
20746 
  def __eq__(self, other):
20747 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
20748 
 
20749 
  def __ne__(self, other):
20750 
    return not (self == other)
4386 anupam.sin 20751 
 
4662 rajveer 20752 
class markOrderAsLostInTransit_args:
20753 
  """
20754 
  Attributes:
20755 
   - orderId
20756 
  """
20757 
 
20758 
  thrift_spec = (
20759 
    None, # 0
20760 
    (1, TType.I64, 'orderId', None, None, ), # 1
20761 
  )
20762 
 
20763 
  def __init__(self, orderId=None,):
20764 
    self.orderId = orderId
20765 
 
20766 
  def read(self, iprot):
20767 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
20768 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
20769 
      return
20770 
    iprot.readStructBegin()
20771 
    while True:
20772 
      (fname, ftype, fid) = iprot.readFieldBegin()
20773 
      if ftype == TType.STOP:
20774 
        break
20775 
      if fid == 1:
20776 
        if ftype == TType.I64:
20777 
          self.orderId = iprot.readI64();
20778 
        else:
20779 
          iprot.skip(ftype)
20780 
      else:
20781 
        iprot.skip(ftype)
20782 
      iprot.readFieldEnd()
20783 
    iprot.readStructEnd()
20784 
 
20785 
  def write(self, oprot):
20786 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
20787 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
20788 
      return
20789 
    oprot.writeStructBegin('markOrderAsLostInTransit_args')
20790 
    if self.orderId is not None:
20791 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
20792 
      oprot.writeI64(self.orderId)
20793 
      oprot.writeFieldEnd()
20794 
    oprot.writeFieldStop()
20795 
    oprot.writeStructEnd()
20796 
 
20797 
  def validate(self):
20798 
    return
20799 
 
20800 
 
20801 
  def __repr__(self):
20802 
    L = ['%s=%r' % (key, value)
20803 
      for key, value in self.__dict__.iteritems()]
20804 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
20805 
 
20806 
  def __eq__(self, other):
20807 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
20808 
 
20809 
  def __ne__(self, other):
20810 
    return not (self == other)
20811 
 
20812 
class markOrderAsLostInTransit_result:
20813 
  """
20814 
  Attributes:
20815 
   - success
20816 
   - ex
20817 
  """
20818 
 
20819 
  thrift_spec = (
20820 
    (0, TType.BOOL, 'success', None, None, ), # 0
20821 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
20822 
  )
20823 
 
20824 
  def __init__(self, success=None, ex=None,):
20825 
    self.success = success
20826 
    self.ex = ex
20827 
 
20828 
  def read(self, iprot):
20829 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
20830 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
20831 
      return
20832 
    iprot.readStructBegin()
20833 
    while True:
20834 
      (fname, ftype, fid) = iprot.readFieldBegin()
20835 
      if ftype == TType.STOP:
20836 
        break
20837 
      if fid == 0:
20838 
        if ftype == TType.BOOL:
20839 
          self.success = iprot.readBool();
20840 
        else:
20841 
          iprot.skip(ftype)
20842 
      elif fid == 1:
20843 
        if ftype == TType.STRUCT:
20844 
          self.ex = TransactionServiceException()
20845 
          self.ex.read(iprot)
20846 
        else:
20847 
          iprot.skip(ftype)
20848 
      else:
20849 
        iprot.skip(ftype)
20850 
      iprot.readFieldEnd()
20851 
    iprot.readStructEnd()
20852 
 
20853 
  def write(self, oprot):
20854 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
20855 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
20856 
      return
20857 
    oprot.writeStructBegin('markOrderAsLostInTransit_result')
20858 
    if self.success is not None:
20859 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
20860 
      oprot.writeBool(self.success)
20861 
      oprot.writeFieldEnd()
20862 
    if self.ex is not None:
20863 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
20864 
      self.ex.write(oprot)
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 
 
4386 anupam.sin 20884 
class getOrderForAwb_args:
20885 
  """
20886 
  Attributes:
20887 
   - awb
20888 
  """
20889 
 
20890 
  thrift_spec = (
20891 
    None, # 0
20892 
    (1, TType.STRING, 'awb', None, None, ), # 1
20893 
  )
20894 
 
20895 
  def __init__(self, awb=None,):
20896 
    self.awb = awb
20897 
 
20898 
  def read(self, iprot):
20899 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
20900 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
20901 
      return
20902 
    iprot.readStructBegin()
20903 
    while True:
20904 
      (fname, ftype, fid) = iprot.readFieldBegin()
20905 
      if ftype == TType.STOP:
20906 
        break
20907 
      if fid == 1:
20908 
        if ftype == TType.STRING:
20909 
          self.awb = iprot.readString();
20910 
        else:
20911 
          iprot.skip(ftype)
20912 
      else:
20913 
        iprot.skip(ftype)
20914 
      iprot.readFieldEnd()
20915 
    iprot.readStructEnd()
20916 
 
20917 
  def write(self, oprot):
20918 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
20919 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
20920 
      return
20921 
    oprot.writeStructBegin('getOrderForAwb_args')
20922 
    if self.awb is not None:
20923 
      oprot.writeFieldBegin('awb', TType.STRING, 1)
20924 
      oprot.writeString(self.awb)
20925 
      oprot.writeFieldEnd()
20926 
    oprot.writeFieldStop()
20927 
    oprot.writeStructEnd()
20928 
 
20929 
  def validate(self):
20930 
    return
20931 
 
20932 
 
20933 
  def __repr__(self):
20934 
    L = ['%s=%r' % (key, value)
20935 
      for key, value in self.__dict__.iteritems()]
20936 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
20937 
 
20938 
  def __eq__(self, other):
20939 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
20940 
 
20941 
  def __ne__(self, other):
20942 
    return not (self == other)
20943 
 
20944 
class getOrderForAwb_result:
20945 
  """
20946 
  Attributes:
20947 
   - success
20948 
   - ex
20949 
  """
20950 
 
20951 
  thrift_spec = (
20952 
    (0, TType.STRUCT, 'success', (Order, Order.thrift_spec), None, ), # 0
20953 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
20954 
  )
20955 
 
20956 
  def __init__(self, success=None, ex=None,):
20957 
    self.success = success
20958 
    self.ex = ex
20959 
 
20960 
  def read(self, iprot):
20961 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
20962 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
20963 
      return
20964 
    iprot.readStructBegin()
20965 
    while True:
20966 
      (fname, ftype, fid) = iprot.readFieldBegin()
20967 
      if ftype == TType.STOP:
20968 
        break
20969 
      if fid == 0:
20970 
        if ftype == TType.STRUCT:
20971 
          self.success = Order()
20972 
          self.success.read(iprot)
20973 
        else:
20974 
          iprot.skip(ftype)
20975 
      elif fid == 1:
20976 
        if ftype == TType.STRUCT:
20977 
          self.ex = TransactionServiceException()
20978 
          self.ex.read(iprot)
20979 
        else:
20980 
          iprot.skip(ftype)
20981 
      else:
20982 
        iprot.skip(ftype)
20983 
      iprot.readFieldEnd()
20984 
    iprot.readStructEnd()
20985 
 
20986 
  def write(self, oprot):
20987 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
20988 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
20989 
      return
20990 
    oprot.writeStructBegin('getOrderForAwb_result')
20991 
    if self.success is not None:
20992 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
20993 
      self.success.write(oprot)
20994 
      oprot.writeFieldEnd()
20995 
    if self.ex is not None:
20996 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
20997 
      self.ex.write(oprot)
20998 
      oprot.writeFieldEnd()
20999 
    oprot.writeFieldStop()
21000 
    oprot.writeStructEnd()
21001 
 
21002 
  def validate(self):
21003 
    return
21004 
 
21005 
 
21006 
  def __repr__(self):
21007 
    L = ['%s=%r' % (key, value)
21008 
      for key, value in self.__dict__.iteritems()]
21009 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
21010 
 
21011 
  def __eq__(self, other):
21012 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
21013 
 
21014 
  def __ne__(self, other):
21015 
    return not (self == other)
4506 phani.kuma 21016 
 
21017 
class getOrdersForProviderForStatus_args:
21018 
  """
21019 
  Attributes:
21020 
   - logistics_provider_id
4910 phani.kuma 21021 
   - order_status_list
4506 phani.kuma 21022 
  """
21023 
 
21024 
  thrift_spec = (
21025 
    None, # 0
21026 
    (1, TType.I64, 'logistics_provider_id', None, None, ), # 1
4910 phani.kuma 21027 
    (2, TType.LIST, 'order_status_list', (TType.I32,None), None, ), # 2
4506 phani.kuma 21028 
  )
21029 
 
4910 phani.kuma 21030 
  def __init__(self, logistics_provider_id=None, order_status_list=None,):
4506 phani.kuma 21031 
    self.logistics_provider_id = logistics_provider_id
4910 phani.kuma 21032 
    self.order_status_list = order_status_list
4506 phani.kuma 21033 
 
21034 
  def read(self, iprot):
21035 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
21036 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
21037 
      return
21038 
    iprot.readStructBegin()
21039 
    while True:
21040 
      (fname, ftype, fid) = iprot.readFieldBegin()
21041 
      if ftype == TType.STOP:
21042 
        break
21043 
      if fid == 1:
21044 
        if ftype == TType.I64:
21045 
          self.logistics_provider_id = iprot.readI64();
21046 
        else:
21047 
          iprot.skip(ftype)
21048 
      elif fid == 2:
4910 phani.kuma 21049 
        if ftype == TType.LIST:
21050 
          self.order_status_list = []
5713 rajveer 21051 
          (_etype470, _size467) = iprot.readListBegin()
21052 
          for _i471 in xrange(_size467):
21053 
            _elem472 = iprot.readI32();
21054 
            self.order_status_list.append(_elem472)
4910 phani.kuma 21055 
          iprot.readListEnd()
4506 phani.kuma 21056 
        else:
21057 
          iprot.skip(ftype)
21058 
      else:
21059 
        iprot.skip(ftype)
21060 
      iprot.readFieldEnd()
21061 
    iprot.readStructEnd()
21062 
 
21063 
  def write(self, oprot):
21064 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
21065 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
21066 
      return
21067 
    oprot.writeStructBegin('getOrdersForProviderForStatus_args')
21068 
    if self.logistics_provider_id is not None:
21069 
      oprot.writeFieldBegin('logistics_provider_id', TType.I64, 1)
21070 
      oprot.writeI64(self.logistics_provider_id)
21071 
      oprot.writeFieldEnd()
4910 phani.kuma 21072 
    if self.order_status_list is not None:
21073 
      oprot.writeFieldBegin('order_status_list', TType.LIST, 2)
21074 
      oprot.writeListBegin(TType.I32, len(self.order_status_list))
5713 rajveer 21075 
      for iter473 in self.order_status_list:
21076 
        oprot.writeI32(iter473)
4910 phani.kuma 21077 
      oprot.writeListEnd()
4506 phani.kuma 21078 
      oprot.writeFieldEnd()
21079 
    oprot.writeFieldStop()
21080 
    oprot.writeStructEnd()
21081 
 
21082 
  def validate(self):
21083 
    return
21084 
 
21085 
 
21086 
  def __repr__(self):
21087 
    L = ['%s=%r' % (key, value)
21088 
      for key, value in self.__dict__.iteritems()]
21089 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
21090 
 
21091 
  def __eq__(self, other):
21092 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
21093 
 
21094 
  def __ne__(self, other):
21095 
    return not (self == other)
21096 
 
21097 
class getOrdersForProviderForStatus_result:
21098 
  """
21099 
  Attributes:
21100 
   - success
21101 
   - ex
21102 
  """
21103 
 
21104 
  thrift_spec = (
21105 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
21106 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
21107 
  )
21108 
 
21109 
  def __init__(self, success=None, ex=None,):
21110 
    self.success = success
21111 
    self.ex = ex
21112 
 
21113 
  def read(self, iprot):
21114 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
21115 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
21116 
      return
21117 
    iprot.readStructBegin()
21118 
    while True:
21119 
      (fname, ftype, fid) = iprot.readFieldBegin()
21120 
      if ftype == TType.STOP:
21121 
        break
21122 
      if fid == 0:
21123 
        if ftype == TType.LIST:
21124 
          self.success = []
5713 rajveer 21125 
          (_etype477, _size474) = iprot.readListBegin()
21126 
          for _i478 in xrange(_size474):
21127 
            _elem479 = Order()
21128 
            _elem479.read(iprot)
21129 
            self.success.append(_elem479)
4506 phani.kuma 21130 
          iprot.readListEnd()
21131 
        else:
21132 
          iprot.skip(ftype)
21133 
      elif fid == 1:
21134 
        if ftype == TType.STRUCT:
21135 
          self.ex = TransactionServiceException()
21136 
          self.ex.read(iprot)
21137 
        else:
21138 
          iprot.skip(ftype)
21139 
      else:
21140 
        iprot.skip(ftype)
21141 
      iprot.readFieldEnd()
21142 
    iprot.readStructEnd()
21143 
 
21144 
  def write(self, oprot):
21145 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
21146 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
21147 
      return
21148 
    oprot.writeStructBegin('getOrdersForProviderForStatus_result')
21149 
    if self.success is not None:
21150 
      oprot.writeFieldBegin('success', TType.LIST, 0)
21151 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
5713 rajveer 21152 
      for iter480 in self.success:
21153 
        iter480.write(oprot)
4506 phani.kuma 21154 
      oprot.writeListEnd()
21155 
      oprot.writeFieldEnd()
21156 
    if self.ex is not None:
21157 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
21158 
      self.ex.write(oprot)
21159 
      oprot.writeFieldEnd()
21160 
    oprot.writeFieldStop()
21161 
    oprot.writeStructEnd()
21162 
 
21163 
  def validate(self):
21164 
    return
21165 
 
21166 
 
21167 
  def __repr__(self):
21168 
    L = ['%s=%r' % (key, value)
21169 
      for key, value in self.__dict__.iteritems()]
21170 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
21171 
 
21172 
  def __eq__(self, other):
21173 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
21174 
 
21175 
  def __ne__(self, other):
21176 
    return not (self == other)
4600 varun.gupt 21177 
 
21178 
class getBilledOrdersForVendor_args:
21179 
  """
21180 
  Attributes:
21181 
   - vendorId
21182 
   - billingDateFrom
21183 
   - billingDateTo
21184 
  """
21185 
 
21186 
  thrift_spec = (
21187 
    None, # 0
21188 
    (1, TType.I64, 'vendorId', None, None, ), # 1
21189 
    (2, TType.I64, 'billingDateFrom', None, None, ), # 2
21190 
    (3, TType.I64, 'billingDateTo', None, None, ), # 3
21191 
  )
21192 
 
21193 
  def __init__(self, vendorId=None, billingDateFrom=None, billingDateTo=None,):
21194 
    self.vendorId = vendorId
21195 
    self.billingDateFrom = billingDateFrom
21196 
    self.billingDateTo = billingDateTo
21197 
 
21198 
  def read(self, iprot):
21199 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
21200 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
21201 
      return
21202 
    iprot.readStructBegin()
21203 
    while True:
21204 
      (fname, ftype, fid) = iprot.readFieldBegin()
21205 
      if ftype == TType.STOP:
21206 
        break
21207 
      if fid == 1:
21208 
        if ftype == TType.I64:
21209 
          self.vendorId = iprot.readI64();
21210 
        else:
21211 
          iprot.skip(ftype)
21212 
      elif fid == 2:
21213 
        if ftype == TType.I64:
21214 
          self.billingDateFrom = iprot.readI64();
21215 
        else:
21216 
          iprot.skip(ftype)
21217 
      elif fid == 3:
21218 
        if ftype == TType.I64:
21219 
          self.billingDateTo = iprot.readI64();
21220 
        else:
21221 
          iprot.skip(ftype)
21222 
      else:
21223 
        iprot.skip(ftype)
21224 
      iprot.readFieldEnd()
21225 
    iprot.readStructEnd()
21226 
 
21227 
  def write(self, oprot):
21228 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
21229 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
21230 
      return
21231 
    oprot.writeStructBegin('getBilledOrdersForVendor_args')
21232 
    if self.vendorId is not None:
21233 
      oprot.writeFieldBegin('vendorId', TType.I64, 1)
21234 
      oprot.writeI64(self.vendorId)
21235 
      oprot.writeFieldEnd()
21236 
    if self.billingDateFrom is not None:
21237 
      oprot.writeFieldBegin('billingDateFrom', TType.I64, 2)
21238 
      oprot.writeI64(self.billingDateFrom)
21239 
      oprot.writeFieldEnd()
21240 
    if self.billingDateTo is not None:
21241 
      oprot.writeFieldBegin('billingDateTo', TType.I64, 3)
21242 
      oprot.writeI64(self.billingDateTo)
21243 
      oprot.writeFieldEnd()
21244 
    oprot.writeFieldStop()
21245 
    oprot.writeStructEnd()
21246 
 
21247 
  def validate(self):
21248 
    return
21249 
 
21250 
 
21251 
  def __repr__(self):
21252 
    L = ['%s=%r' % (key, value)
21253 
      for key, value in self.__dict__.iteritems()]
21254 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
21255 
 
21256 
  def __eq__(self, other):
21257 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
21258 
 
21259 
  def __ne__(self, other):
21260 
    return not (self == other)
21261 
 
21262 
class getBilledOrdersForVendor_result:
21263 
  """
21264 
  Attributes:
21265 
   - success
21266 
   - ex
21267 
  """
21268 
 
21269 
  thrift_spec = (
21270 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
21271 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
21272 
  )
21273 
 
21274 
  def __init__(self, success=None, ex=None,):
21275 
    self.success = success
21276 
    self.ex = ex
21277 
 
21278 
  def read(self, iprot):
21279 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
21280 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
21281 
      return
21282 
    iprot.readStructBegin()
21283 
    while True:
21284 
      (fname, ftype, fid) = iprot.readFieldBegin()
21285 
      if ftype == TType.STOP:
21286 
        break
21287 
      if fid == 0:
21288 
        if ftype == TType.LIST:
21289 
          self.success = []
5713 rajveer 21290 
          (_etype484, _size481) = iprot.readListBegin()
21291 
          for _i485 in xrange(_size481):
21292 
            _elem486 = Order()
21293 
            _elem486.read(iprot)
21294 
            self.success.append(_elem486)
4600 varun.gupt 21295 
          iprot.readListEnd()
21296 
        else:
21297 
          iprot.skip(ftype)
21298 
      elif fid == 1:
21299 
        if ftype == TType.STRUCT:
21300 
          self.ex = TransactionServiceException()
21301 
          self.ex.read(iprot)
21302 
        else:
21303 
          iprot.skip(ftype)
21304 
      else:
21305 
        iprot.skip(ftype)
21306 
      iprot.readFieldEnd()
21307 
    iprot.readStructEnd()
21308 
 
21309 
  def write(self, oprot):
21310 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
21311 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
21312 
      return
21313 
    oprot.writeStructBegin('getBilledOrdersForVendor_result')
21314 
    if self.success is not None:
21315 
      oprot.writeFieldBegin('success', TType.LIST, 0)
21316 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
5713 rajveer 21317 
      for iter487 in self.success:
21318 
        iter487.write(oprot)
4600 varun.gupt 21319 
      oprot.writeListEnd()
21320 
      oprot.writeFieldEnd()
21321 
    if self.ex is not None:
21322 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
21323 
      self.ex.write(oprot)
21324 
      oprot.writeFieldEnd()
21325 
    oprot.writeFieldStop()
21326 
    oprot.writeStructEnd()
21327 
 
21328 
  def validate(self):
21329 
    return
21330 
 
21331 
 
21332 
  def __repr__(self):
21333 
    L = ['%s=%r' % (key, value)
21334 
      for key, value in self.__dict__.iteritems()]
21335 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
21336 
 
21337 
  def __eq__(self, other):
21338 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
21339 
 
21340 
  def __ne__(self, other):
21341 
    return not (self == other)
21342 
 
4607 rajveer 21343 
class getSlippedSippingDateOrders_args:
21344 
 
21345 
  thrift_spec = (
21346 
  )
21347 
 
21348 
  def read(self, iprot):
21349 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
21350 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
21351 
      return
21352 
    iprot.readStructBegin()
21353 
    while True:
21354 
      (fname, ftype, fid) = iprot.readFieldBegin()
21355 
      if ftype == TType.STOP:
21356 
        break
21357 
      else:
21358 
        iprot.skip(ftype)
21359 
      iprot.readFieldEnd()
21360 
    iprot.readStructEnd()
21361 
 
21362 
  def write(self, oprot):
21363 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
21364 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
21365 
      return
21366 
    oprot.writeStructBegin('getSlippedSippingDateOrders_args')
21367 
    oprot.writeFieldStop()
21368 
    oprot.writeStructEnd()
21369 
 
21370 
  def validate(self):
21371 
    return
21372 
 
21373 
 
21374 
  def __repr__(self):
21375 
    L = ['%s=%r' % (key, value)
21376 
      for key, value in self.__dict__.iteritems()]
21377 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
21378 
 
21379 
  def __eq__(self, other):
21380 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
21381 
 
21382 
  def __ne__(self, other):
21383 
    return not (self == other)
21384 
 
21385 
class getSlippedSippingDateOrders_result:
21386 
  """
21387 
  Attributes:
21388 
   - success
21389 
   - ex
21390 
  """
21391 
 
21392 
  thrift_spec = (
21393 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
21394 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
21395 
  )
21396 
 
21397 
  def __init__(self, success=None, ex=None,):
21398 
    self.success = success
21399 
    self.ex = ex
21400 
 
21401 
  def read(self, iprot):
21402 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
21403 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
21404 
      return
21405 
    iprot.readStructBegin()
21406 
    while True:
21407 
      (fname, ftype, fid) = iprot.readFieldBegin()
21408 
      if ftype == TType.STOP:
21409 
        break
21410 
      if fid == 0:
21411 
        if ftype == TType.LIST:
21412 
          self.success = []
5713 rajveer 21413 
          (_etype491, _size488) = iprot.readListBegin()
21414 
          for _i492 in xrange(_size488):
21415 
            _elem493 = Order()
21416 
            _elem493.read(iprot)
21417 
            self.success.append(_elem493)
4607 rajveer 21418 
          iprot.readListEnd()
21419 
        else:
21420 
          iprot.skip(ftype)
21421 
      elif fid == 1:
21422 
        if ftype == TType.STRUCT:
21423 
          self.ex = TransactionServiceException()
21424 
          self.ex.read(iprot)
21425 
        else:
21426 
          iprot.skip(ftype)
21427 
      else:
21428 
        iprot.skip(ftype)
21429 
      iprot.readFieldEnd()
21430 
    iprot.readStructEnd()
21431 
 
21432 
  def write(self, oprot):
21433 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
21434 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
21435 
      return
21436 
    oprot.writeStructBegin('getSlippedSippingDateOrders_result')
21437 
    if self.success is not None:
21438 
      oprot.writeFieldBegin('success', TType.LIST, 0)
21439 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
5713 rajveer 21440 
      for iter494 in self.success:
21441 
        iter494.write(oprot)
4607 rajveer 21442 
      oprot.writeListEnd()
21443 
      oprot.writeFieldEnd()
21444 
    if self.ex is not None:
21445 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
21446 
      self.ex.write(oprot)
21447 
      oprot.writeFieldEnd()
21448 
    oprot.writeFieldStop()
21449 
    oprot.writeStructEnd()
21450 
 
21451 
  def validate(self):
21452 
    return
21453 
 
21454 
 
21455 
  def __repr__(self):
21456 
    L = ['%s=%r' % (key, value)
21457 
      for key, value in self.__dict__.iteritems()]
21458 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
21459 
 
21460 
  def __eq__(self, other):
21461 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
21462 
 
21463 
  def __ne__(self, other):
21464 
    return not (self == other)
21465 
 
4709 rajveer 21466 
class getCancelledOrders_args:
21467 
  """
21468 
  Attributes:
21469 
   - cancelDateFrom
21470 
   - cancelDateTo
21471 
  """
21472 
 
21473 
  thrift_spec = (
21474 
    None, # 0
21475 
    (1, TType.I64, 'cancelDateFrom', None, None, ), # 1
21476 
    (2, TType.I64, 'cancelDateTo', None, None, ), # 2
21477 
  )
21478 
 
21479 
  def __init__(self, cancelDateFrom=None, cancelDateTo=None,):
21480 
    self.cancelDateFrom = cancelDateFrom
21481 
    self.cancelDateTo = cancelDateTo
21482 
 
21483 
  def read(self, iprot):
21484 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
21485 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
21486 
      return
21487 
    iprot.readStructBegin()
21488 
    while True:
21489 
      (fname, ftype, fid) = iprot.readFieldBegin()
21490 
      if ftype == TType.STOP:
21491 
        break
21492 
      if fid == 1:
21493 
        if ftype == TType.I64:
21494 
          self.cancelDateFrom = iprot.readI64();
21495 
        else:
21496 
          iprot.skip(ftype)
21497 
      elif fid == 2:
21498 
        if ftype == TType.I64:
21499 
          self.cancelDateTo = iprot.readI64();
21500 
        else:
21501 
          iprot.skip(ftype)
21502 
      else:
21503 
        iprot.skip(ftype)
21504 
      iprot.readFieldEnd()
21505 
    iprot.readStructEnd()
21506 
 
21507 
  def write(self, oprot):
21508 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
21509 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
21510 
      return
21511 
    oprot.writeStructBegin('getCancelledOrders_args')
21512 
    if self.cancelDateFrom is not None:
21513 
      oprot.writeFieldBegin('cancelDateFrom', TType.I64, 1)
21514 
      oprot.writeI64(self.cancelDateFrom)
21515 
      oprot.writeFieldEnd()
21516 
    if self.cancelDateTo is not None:
21517 
      oprot.writeFieldBegin('cancelDateTo', TType.I64, 2)
21518 
      oprot.writeI64(self.cancelDateTo)
21519 
      oprot.writeFieldEnd()
21520 
    oprot.writeFieldStop()
21521 
    oprot.writeStructEnd()
21522 
 
21523 
  def validate(self):
21524 
    return
21525 
 
21526 
 
21527 
  def __repr__(self):
21528 
    L = ['%s=%r' % (key, value)
21529 
      for key, value in self.__dict__.iteritems()]
21530 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
21531 
 
21532 
  def __eq__(self, other):
21533 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
21534 
 
21535 
  def __ne__(self, other):
21536 
    return not (self == other)
21537 
 
21538 
class getCancelledOrders_result:
21539 
  """
21540 
  Attributes:
21541 
   - success
21542 
   - ex
21543 
  """
21544 
 
21545 
  thrift_spec = (
21546 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
21547 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
21548 
  )
21549 
 
21550 
  def __init__(self, success=None, ex=None,):
21551 
    self.success = success
21552 
    self.ex = ex
21553 
 
21554 
  def read(self, iprot):
21555 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
21556 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
21557 
      return
21558 
    iprot.readStructBegin()
21559 
    while True:
21560 
      (fname, ftype, fid) = iprot.readFieldBegin()
21561 
      if ftype == TType.STOP:
21562 
        break
21563 
      if fid == 0:
21564 
        if ftype == TType.LIST:
21565 
          self.success = []
5713 rajveer 21566 
          (_etype498, _size495) = iprot.readListBegin()
21567 
          for _i499 in xrange(_size495):
21568 
            _elem500 = Order()
21569 
            _elem500.read(iprot)
21570 
            self.success.append(_elem500)
4709 rajveer 21571 
          iprot.readListEnd()
21572 
        else:
21573 
          iprot.skip(ftype)
21574 
      elif fid == 1:
21575 
        if ftype == TType.STRUCT:
21576 
          self.ex = TransactionServiceException()
21577 
          self.ex.read(iprot)
21578 
        else:
21579 
          iprot.skip(ftype)
21580 
      else:
21581 
        iprot.skip(ftype)
21582 
      iprot.readFieldEnd()
21583 
    iprot.readStructEnd()
21584 
 
21585 
  def write(self, oprot):
21586 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
21587 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
21588 
      return
21589 
    oprot.writeStructBegin('getCancelledOrders_result')
21590 
    if self.success is not None:
21591 
      oprot.writeFieldBegin('success', TType.LIST, 0)
21592 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
5713 rajveer 21593 
      for iter501 in self.success:
21594 
        iter501.write(oprot)
4709 rajveer 21595 
      oprot.writeListEnd()
21596 
      oprot.writeFieldEnd()
21597 
    if self.ex is not None:
21598 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
21599 
      self.ex.write(oprot)
21600 
      oprot.writeFieldEnd()
21601 
    oprot.writeFieldStop()
21602 
    oprot.writeStructEnd()
21603 
 
21604 
  def validate(self):
21605 
    return
21606 
 
21607 
 
21608 
  def __repr__(self):
21609 
    L = ['%s=%r' % (key, value)
21610 
      for key, value in self.__dict__.iteritems()]
21611 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
21612 
 
21613 
  def __eq__(self, other):
21614 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
21615 
 
21616 
  def __ne__(self, other):
21617 
    return not (self == other)
21618 
 
4600 varun.gupt 21619 
class saveBluedartSettlements_args:
21620 
  """
21621 
  Attributes:
21622 
   - mapAWBAndAmount
21623 
  """
21624 
 
21625 
  thrift_spec = (
21626 
    None, # 0
21627 
    (1, TType.MAP, 'mapAWBAndAmount', (TType.I64,None,TType.DOUBLE,None), None, ), # 1
21628 
  )
21629 
 
21630 
  def __init__(self, mapAWBAndAmount=None,):
21631 
    self.mapAWBAndAmount = mapAWBAndAmount
21632 
 
21633 
  def read(self, iprot):
21634 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
21635 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
21636 
      return
21637 
    iprot.readStructBegin()
21638 
    while True:
21639 
      (fname, ftype, fid) = iprot.readFieldBegin()
21640 
      if ftype == TType.STOP:
21641 
        break
21642 
      if fid == 1:
21643 
        if ftype == TType.MAP:
21644 
          self.mapAWBAndAmount = {}
5713 rajveer 21645 
          (_ktype503, _vtype504, _size502 ) = iprot.readMapBegin()
21646 
          for _i506 in xrange(_size502):
21647 
            _key507 = iprot.readI64();
21648 
            _val508 = iprot.readDouble();
21649 
            self.mapAWBAndAmount[_key507] = _val508
4600 varun.gupt 21650 
          iprot.readMapEnd()
21651 
        else:
21652 
          iprot.skip(ftype)
21653 
      else:
21654 
        iprot.skip(ftype)
21655 
      iprot.readFieldEnd()
21656 
    iprot.readStructEnd()
21657 
 
21658 
  def write(self, oprot):
21659 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
21660 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
21661 
      return
21662 
    oprot.writeStructBegin('saveBluedartSettlements_args')
21663 
    if self.mapAWBAndAmount is not None:
21664 
      oprot.writeFieldBegin('mapAWBAndAmount', TType.MAP, 1)
21665 
      oprot.writeMapBegin(TType.I64, TType.DOUBLE, len(self.mapAWBAndAmount))
5713 rajveer 21666 
      for kiter509,viter510 in self.mapAWBAndAmount.items():
21667 
        oprot.writeI64(kiter509)
21668 
        oprot.writeDouble(viter510)
4600 varun.gupt 21669 
      oprot.writeMapEnd()
21670 
      oprot.writeFieldEnd()
21671 
    oprot.writeFieldStop()
21672 
    oprot.writeStructEnd()
21673 
 
21674 
  def validate(self):
21675 
    return
21676 
 
21677 
 
21678 
  def __repr__(self):
21679 
    L = ['%s=%r' % (key, value)
21680 
      for key, value in self.__dict__.iteritems()]
21681 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
21682 
 
21683 
  def __eq__(self, other):
21684 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
21685 
 
21686 
  def __ne__(self, other):
21687 
    return not (self == other)
21688 
 
21689 
class saveBluedartSettlements_result:
21690 
  """
21691 
  Attributes:
21692 
   - ex
21693 
  """
21694 
 
21695 
  thrift_spec = (
21696 
    None, # 0
21697 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
21698 
  )
21699 
 
21700 
  def __init__(self, ex=None,):
21701 
    self.ex = ex
21702 
 
21703 
  def read(self, iprot):
21704 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
21705 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
21706 
      return
21707 
    iprot.readStructBegin()
21708 
    while True:
21709 
      (fname, ftype, fid) = iprot.readFieldBegin()
21710 
      if ftype == TType.STOP:
21711 
        break
21712 
      if fid == 1:
21713 
        if ftype == TType.STRUCT:
21714 
          self.ex = TransactionServiceException()
21715 
          self.ex.read(iprot)
21716 
        else:
21717 
          iprot.skip(ftype)
21718 
      else:
21719 
        iprot.skip(ftype)
21720 
      iprot.readFieldEnd()
21721 
    iprot.readStructEnd()
21722 
 
21723 
  def write(self, oprot):
21724 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
21725 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
21726 
      return
21727 
    oprot.writeStructBegin('saveBluedartSettlements_result')
21728 
    if self.ex is not None:
21729 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
21730 
      self.ex.write(oprot)
21731 
      oprot.writeFieldEnd()
21732 
    oprot.writeFieldStop()
21733 
    oprot.writeStructEnd()
21734 
 
21735 
  def validate(self):
21736 
    return
21737 
 
21738 
 
21739 
  def __repr__(self):
21740 
    L = ['%s=%r' % (key, value)
21741 
      for key, value in self.__dict__.iteritems()]
21742 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
21743 
 
21744 
  def __eq__(self, other):
21745 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
21746 
 
21747 
  def __ne__(self, other):
21748 
    return not (self == other)
21749 
 
21750 
class savePaymentSettlements_args:
21751 
  """
21752 
  Attributes:
21753 
   - settlementDate
21754 
   - paymentGatewayId
4905 varun.gupt 21755 
   - referenceId
4600 varun.gupt 21756 
   - serviceTax
21757 
   - otherCharges
21758 
   - netCollection
21759 
  """
21760 
 
21761 
  thrift_spec = (
21762 
    None, # 0
21763 
    (1, TType.I64, 'settlementDate', None, None, ), # 1
21764 
    (2, TType.I64, 'paymentGatewayId', None, None, ), # 2
4905 varun.gupt 21765 
    (3, TType.I64, 'referenceId', None, None, ), # 3
4600 varun.gupt 21766 
    (4, TType.DOUBLE, 'serviceTax', None, None, ), # 4
21767 
    (5, TType.DOUBLE, 'otherCharges', None, None, ), # 5
21768 
    (6, TType.DOUBLE, 'netCollection', None, None, ), # 6
21769 
  )
21770 
 
4905 varun.gupt 21771 
  def __init__(self, settlementDate=None, paymentGatewayId=None, referenceId=None, serviceTax=None, otherCharges=None, netCollection=None,):
4600 varun.gupt 21772 
    self.settlementDate = settlementDate
21773 
    self.paymentGatewayId = paymentGatewayId
4905 varun.gupt 21774 
    self.referenceId = referenceId
4600 varun.gupt 21775 
    self.serviceTax = serviceTax
21776 
    self.otherCharges = otherCharges
21777 
    self.netCollection = netCollection
21778 
 
21779 
  def read(self, iprot):
21780 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
21781 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
21782 
      return
21783 
    iprot.readStructBegin()
21784 
    while True:
21785 
      (fname, ftype, fid) = iprot.readFieldBegin()
21786 
      if ftype == TType.STOP:
21787 
        break
21788 
      if fid == 1:
21789 
        if ftype == TType.I64:
21790 
          self.settlementDate = iprot.readI64();
21791 
        else:
21792 
          iprot.skip(ftype)
21793 
      elif fid == 2:
21794 
        if ftype == TType.I64:
21795 
          self.paymentGatewayId = iprot.readI64();
21796 
        else:
21797 
          iprot.skip(ftype)
21798 
      elif fid == 3:
21799 
        if ftype == TType.I64:
4905 varun.gupt 21800 
          self.referenceId = iprot.readI64();
4600 varun.gupt 21801 
        else:
21802 
          iprot.skip(ftype)
21803 
      elif fid == 4:
21804 
        if ftype == TType.DOUBLE:
21805 
          self.serviceTax = iprot.readDouble();
21806 
        else:
21807 
          iprot.skip(ftype)
21808 
      elif fid == 5:
21809 
        if ftype == TType.DOUBLE:
21810 
          self.otherCharges = iprot.readDouble();
21811 
        else:
21812 
          iprot.skip(ftype)
21813 
      elif fid == 6:
21814 
        if ftype == TType.DOUBLE:
21815 
          self.netCollection = iprot.readDouble();
21816 
        else:
21817 
          iprot.skip(ftype)
21818 
      else:
21819 
        iprot.skip(ftype)
21820 
      iprot.readFieldEnd()
21821 
    iprot.readStructEnd()
21822 
 
21823 
  def write(self, oprot):
21824 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
21825 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
21826 
      return
21827 
    oprot.writeStructBegin('savePaymentSettlements_args')
21828 
    if self.settlementDate is not None:
21829 
      oprot.writeFieldBegin('settlementDate', TType.I64, 1)
21830 
      oprot.writeI64(self.settlementDate)
21831 
      oprot.writeFieldEnd()
21832 
    if self.paymentGatewayId is not None:
21833 
      oprot.writeFieldBegin('paymentGatewayId', TType.I64, 2)
21834 
      oprot.writeI64(self.paymentGatewayId)
21835 
      oprot.writeFieldEnd()
4905 varun.gupt 21836 
    if self.referenceId is not None:
21837 
      oprot.writeFieldBegin('referenceId', TType.I64, 3)
21838 
      oprot.writeI64(self.referenceId)
4600 varun.gupt 21839 
      oprot.writeFieldEnd()
21840 
    if self.serviceTax is not None:
21841 
      oprot.writeFieldBegin('serviceTax', TType.DOUBLE, 4)
21842 
      oprot.writeDouble(self.serviceTax)
21843 
      oprot.writeFieldEnd()
21844 
    if self.otherCharges is not None:
21845 
      oprot.writeFieldBegin('otherCharges', TType.DOUBLE, 5)
21846 
      oprot.writeDouble(self.otherCharges)
21847 
      oprot.writeFieldEnd()
21848 
    if self.netCollection is not None:
21849 
      oprot.writeFieldBegin('netCollection', TType.DOUBLE, 6)
21850 
      oprot.writeDouble(self.netCollection)
21851 
      oprot.writeFieldEnd()
21852 
    oprot.writeFieldStop()
21853 
    oprot.writeStructEnd()
21854 
 
21855 
  def validate(self):
21856 
    return
21857 
 
21858 
 
21859 
  def __repr__(self):
21860 
    L = ['%s=%r' % (key, value)
21861 
      for key, value in self.__dict__.iteritems()]
21862 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
21863 
 
21864 
  def __eq__(self, other):
21865 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
21866 
 
21867 
  def __ne__(self, other):
21868 
    return not (self == other)
21869 
 
21870 
class savePaymentSettlements_result:
21871 
  """
21872 
  Attributes:
21873 
   - ex
21874 
  """
21875 
 
21876 
  thrift_spec = (
21877 
    None, # 0
21878 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
21879 
  )
21880 
 
21881 
  def __init__(self, ex=None,):
21882 
    self.ex = ex
21883 
 
21884 
  def read(self, iprot):
21885 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
21886 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
21887 
      return
21888 
    iprot.readStructBegin()
21889 
    while True:
21890 
      (fname, ftype, fid) = iprot.readFieldBegin()
21891 
      if ftype == TType.STOP:
21892 
        break
21893 
      if fid == 1:
21894 
        if ftype == TType.STRUCT:
21895 
          self.ex = TransactionServiceException()
21896 
          self.ex.read(iprot)
21897 
        else:
21898 
          iprot.skip(ftype)
21899 
      else:
21900 
        iprot.skip(ftype)
21901 
      iprot.readFieldEnd()
21902 
    iprot.readStructEnd()
21903 
 
21904 
  def write(self, oprot):
21905 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
21906 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
21907 
      return
21908 
    oprot.writeStructBegin('savePaymentSettlements_result')
21909 
    if self.ex is not None:
21910 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
21911 
      self.ex.write(oprot)
21912 
      oprot.writeFieldEnd()
21913 
    oprot.writeFieldStop()
21914 
    oprot.writeStructEnd()
21915 
 
21916 
  def validate(self):
21917 
    return
21918 
 
21919 
 
21920 
  def __repr__(self):
21921 
    L = ['%s=%r' % (key, value)
21922 
      for key, value in self.__dict__.iteritems()]
21923 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
21924 
 
21925 
  def __eq__(self, other):
21926 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
21927 
 
21928 
  def __ne__(self, other):
21929 
    return not (self == other)
21930 
 
21931 
class saveEBSSettlementSummary_args:
21932 
  """
21933 
  Attributes:
21934 
   - settlementId
21935 
   - settlementDate
21936 
   - transactionDateFrom
21937 
   - transactionDateTo
21938 
   - amount
21939 
  """
21940 
 
21941 
  thrift_spec = (
21942 
    None, # 0
21943 
    (1, TType.I64, 'settlementId', None, None, ), # 1
21944 
    (2, TType.I64, 'settlementDate', None, None, ), # 2
21945 
    (3, TType.I64, 'transactionDateFrom', None, None, ), # 3
21946 
    (4, TType.I64, 'transactionDateTo', None, None, ), # 4
21947 
    (5, TType.DOUBLE, 'amount', None, None, ), # 5
21948 
  )
21949 
 
21950 
  def __init__(self, settlementId=None, settlementDate=None, transactionDateFrom=None, transactionDateTo=None, amount=None,):
21951 
    self.settlementId = settlementId
21952 
    self.settlementDate = settlementDate
21953 
    self.transactionDateFrom = transactionDateFrom
21954 
    self.transactionDateTo = transactionDateTo
21955 
    self.amount = amount
21956 
 
21957 
  def read(self, iprot):
21958 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
21959 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
21960 
      return
21961 
    iprot.readStructBegin()
21962 
    while True:
21963 
      (fname, ftype, fid) = iprot.readFieldBegin()
21964 
      if ftype == TType.STOP:
21965 
        break
21966 
      if fid == 1:
21967 
        if ftype == TType.I64:
21968 
          self.settlementId = iprot.readI64();
21969 
        else:
21970 
          iprot.skip(ftype)
21971 
      elif fid == 2:
21972 
        if ftype == TType.I64:
21973 
          self.settlementDate = iprot.readI64();
21974 
        else:
21975 
          iprot.skip(ftype)
21976 
      elif fid == 3:
21977 
        if ftype == TType.I64:
21978 
          self.transactionDateFrom = iprot.readI64();
21979 
        else:
21980 
          iprot.skip(ftype)
21981 
      elif fid == 4:
21982 
        if ftype == TType.I64:
21983 
          self.transactionDateTo = iprot.readI64();
21984 
        else:
21985 
          iprot.skip(ftype)
21986 
      elif fid == 5:
21987 
        if ftype == TType.DOUBLE:
21988 
          self.amount = iprot.readDouble();
21989 
        else:
21990 
          iprot.skip(ftype)
21991 
      else:
21992 
        iprot.skip(ftype)
21993 
      iprot.readFieldEnd()
21994 
    iprot.readStructEnd()
21995 
 
21996 
  def write(self, oprot):
21997 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
21998 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
21999 
      return
22000 
    oprot.writeStructBegin('saveEBSSettlementSummary_args')
22001 
    if self.settlementId is not None:
22002 
      oprot.writeFieldBegin('settlementId', TType.I64, 1)
22003 
      oprot.writeI64(self.settlementId)
22004 
      oprot.writeFieldEnd()
22005 
    if self.settlementDate is not None:
22006 
      oprot.writeFieldBegin('settlementDate', TType.I64, 2)
22007 
      oprot.writeI64(self.settlementDate)
22008 
      oprot.writeFieldEnd()
22009 
    if self.transactionDateFrom is not None:
22010 
      oprot.writeFieldBegin('transactionDateFrom', TType.I64, 3)
22011 
      oprot.writeI64(self.transactionDateFrom)
22012 
      oprot.writeFieldEnd()
22013 
    if self.transactionDateTo is not None:
22014 
      oprot.writeFieldBegin('transactionDateTo', TType.I64, 4)
22015 
      oprot.writeI64(self.transactionDateTo)
22016 
      oprot.writeFieldEnd()
22017 
    if self.amount is not None:
22018 
      oprot.writeFieldBegin('amount', TType.DOUBLE, 5)
22019 
      oprot.writeDouble(self.amount)
22020 
      oprot.writeFieldEnd()
22021 
    oprot.writeFieldStop()
22022 
    oprot.writeStructEnd()
22023 
 
22024 
  def validate(self):
22025 
    return
22026 
 
22027 
 
22028 
  def __repr__(self):
22029 
    L = ['%s=%r' % (key, value)
22030 
      for key, value in self.__dict__.iteritems()]
22031 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
22032 
 
22033 
  def __eq__(self, other):
22034 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
22035 
 
22036 
  def __ne__(self, other):
22037 
    return not (self == other)
22038 
 
22039 
class saveEBSSettlementSummary_result:
22040 
  """
22041 
  Attributes:
22042 
   - ex
22043 
  """
22044 
 
22045 
  thrift_spec = (
22046 
    None, # 0
22047 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
22048 
  )
22049 
 
22050 
  def __init__(self, ex=None,):
22051 
    self.ex = ex
22052 
 
22053 
  def read(self, iprot):
22054 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
22055 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
22056 
      return
22057 
    iprot.readStructBegin()
22058 
    while True:
22059 
      (fname, ftype, fid) = iprot.readFieldBegin()
22060 
      if ftype == TType.STOP:
22061 
        break
22062 
      if fid == 1:
22063 
        if ftype == TType.STRUCT:
22064 
          self.ex = TransactionServiceException()
22065 
          self.ex.read(iprot)
22066 
        else:
22067 
          iprot.skip(ftype)
22068 
      else:
22069 
        iprot.skip(ftype)
22070 
      iprot.readFieldEnd()
22071 
    iprot.readStructEnd()
22072 
 
22073 
  def write(self, oprot):
22074 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
22075 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
22076 
      return
22077 
    oprot.writeStructBegin('saveEBSSettlementSummary_result')
22078 
    if self.ex is not None:
22079 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
22080 
      self.ex.write(oprot)
22081 
      oprot.writeFieldEnd()
22082 
    oprot.writeFieldStop()
22083 
    oprot.writeStructEnd()
22084 
 
22085 
  def validate(self):
22086 
    return
22087 
 
22088 
 
22089 
  def __repr__(self):
22090 
    L = ['%s=%r' % (key, value)
22091 
      for key, value in self.__dict__.iteritems()]
22092 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
22093 
 
22094 
  def __eq__(self, other):
22095 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
22096 
 
22097 
  def __ne__(self, other):
22098 
    return not (self == other)
22099 
 
5386 phani.kuma 22100 
class getSettlementForPrepaid_args:
4600 varun.gupt 22101 
  """
22102 
  Attributes:
5189 varun.gupt 22103 
   - referenceId
22104 
   - isRefund
4600 varun.gupt 22105 
  """
22106 
 
22107 
  thrift_spec = (
22108 
    None, # 0
5189 varun.gupt 22109 
    (1, TType.I64, 'referenceId', None, None, ), # 1
5386 phani.kuma 22110 
    (2, TType.BOOL, 'isRefund', None, None, ), # 2
4600 varun.gupt 22111 
  )
22112 
 
5386 phani.kuma 22113 
  def __init__(self, referenceId=None, isRefund=None,):
5189 varun.gupt 22114 
    self.referenceId = referenceId
22115 
    self.isRefund = isRefund
4600 varun.gupt 22116 
 
22117 
  def read(self, iprot):
22118 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
22119 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
22120 
      return
22121 
    iprot.readStructBegin()
22122 
    while True:
22123 
      (fname, ftype, fid) = iprot.readFieldBegin()
22124 
      if ftype == TType.STOP:
22125 
        break
22126 
      if fid == 1:
22127 
        if ftype == TType.I64:
5189 varun.gupt 22128 
          self.referenceId = iprot.readI64();
4600 varun.gupt 22129 
        else:
22130 
          iprot.skip(ftype)
5189 varun.gupt 22131 
      elif fid == 2:
22132 
        if ftype == TType.BOOL:
22133 
          self.isRefund = iprot.readBool();
22134 
        else:
22135 
          iprot.skip(ftype)
4600 varun.gupt 22136 
      else:
22137 
        iprot.skip(ftype)
22138 
      iprot.readFieldEnd()
22139 
    iprot.readStructEnd()
22140 
 
22141 
  def write(self, oprot):
22142 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
22143 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
22144 
      return
5386 phani.kuma 22145 
    oprot.writeStructBegin('getSettlementForPrepaid_args')
5189 varun.gupt 22146 
    if self.referenceId is not None:
22147 
      oprot.writeFieldBegin('referenceId', TType.I64, 1)
22148 
      oprot.writeI64(self.referenceId)
4600 varun.gupt 22149 
      oprot.writeFieldEnd()
5386 phani.kuma 22150 
    if self.isRefund is not None:
22151 
      oprot.writeFieldBegin('isRefund', TType.BOOL, 2)
22152 
      oprot.writeBool(self.isRefund)
5382 varun.gupt 22153 
      oprot.writeFieldEnd()
5386 phani.kuma 22154 
    oprot.writeFieldStop()
22155 
    oprot.writeStructEnd()
22156 
 
22157 
  def validate(self):
22158 
    return
22159 
 
22160 
 
22161 
  def __repr__(self):
22162 
    L = ['%s=%r' % (key, value)
22163 
      for key, value in self.__dict__.iteritems()]
22164 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
22165 
 
22166 
  def __eq__(self, other):
22167 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
22168 
 
22169 
  def __ne__(self, other):
22170 
    return not (self == other)
22171 
 
22172 
class getSettlementForPrepaid_result:
22173 
  """
22174 
  Attributes:
22175 
   - success
22176 
   - ex
22177 
  """
22178 
 
22179 
  thrift_spec = (
22180 
    (0, TType.STRUCT, 'success', (PaymentSettlement, PaymentSettlement.thrift_spec), None, ), # 0
22181 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
22182 
  )
22183 
 
22184 
  def __init__(self, success=None, ex=None,):
22185 
    self.success = success
22186 
    self.ex = ex
22187 
 
22188 
  def read(self, iprot):
22189 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
22190 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
22191 
      return
22192 
    iprot.readStructBegin()
22193 
    while True:
22194 
      (fname, ftype, fid) = iprot.readFieldBegin()
22195 
      if ftype == TType.STOP:
22196 
        break
22197 
      if fid == 0:
22198 
        if ftype == TType.STRUCT:
22199 
          self.success = PaymentSettlement()
22200 
          self.success.read(iprot)
22201 
        else:
22202 
          iprot.skip(ftype)
22203 
      elif fid == 1:
22204 
        if ftype == TType.STRUCT:
22205 
          self.ex = TransactionServiceException()
22206 
          self.ex.read(iprot)
22207 
        else:
22208 
          iprot.skip(ftype)
22209 
      else:
22210 
        iprot.skip(ftype)
22211 
      iprot.readFieldEnd()
22212 
    iprot.readStructEnd()
22213 
 
22214 
  def write(self, oprot):
22215 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
22216 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
22217 
      return
22218 
    oprot.writeStructBegin('getSettlementForPrepaid_result')
22219 
    if self.success is not None:
22220 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
22221 
      self.success.write(oprot)
22222 
      oprot.writeFieldEnd()
22223 
    if self.ex is not None:
22224 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
22225 
      self.ex.write(oprot)
22226 
      oprot.writeFieldEnd()
22227 
    oprot.writeFieldStop()
22228 
    oprot.writeStructEnd()
22229 
 
22230 
  def validate(self):
22231 
    return
22232 
 
22233 
 
22234 
  def __repr__(self):
22235 
    L = ['%s=%r' % (key, value)
22236 
      for key, value in self.__dict__.iteritems()]
22237 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
22238 
 
22239 
  def __eq__(self, other):
22240 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
22241 
 
22242 
  def __ne__(self, other):
22243 
    return not (self == other)
22244 
 
22245 
class getSettlementForCod_args:
22246 
  """
22247 
  Attributes:
22248 
   - orderId
22249 
   - isRefund
22250 
  """
22251 
 
22252 
  thrift_spec = (
22253 
    None, # 0
22254 
    (1, TType.I64, 'orderId', None, None, ), # 1
22255 
    (2, TType.BOOL, 'isRefund', None, None, ), # 2
22256 
  )
22257 
 
22258 
  def __init__(self, orderId=None, isRefund=None,):
22259 
    self.orderId = orderId
22260 
    self.isRefund = isRefund
22261 
 
22262 
  def read(self, iprot):
22263 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
22264 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
22265 
      return
22266 
    iprot.readStructBegin()
22267 
    while True:
22268 
      (fname, ftype, fid) = iprot.readFieldBegin()
22269 
      if ftype == TType.STOP:
22270 
        break
22271 
      if fid == 1:
22272 
        if ftype == TType.I64:
22273 
          self.orderId = iprot.readI64();
22274 
        else:
22275 
          iprot.skip(ftype)
22276 
      elif fid == 2:
22277 
        if ftype == TType.BOOL:
22278 
          self.isRefund = iprot.readBool();
22279 
        else:
22280 
          iprot.skip(ftype)
22281 
      else:
22282 
        iprot.skip(ftype)
22283 
      iprot.readFieldEnd()
22284 
    iprot.readStructEnd()
22285 
 
22286 
  def write(self, oprot):
22287 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
22288 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
22289 
      return
22290 
    oprot.writeStructBegin('getSettlementForCod_args')
22291 
    if self.orderId is not None:
22292 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
22293 
      oprot.writeI64(self.orderId)
22294 
      oprot.writeFieldEnd()
5189 varun.gupt 22295 
    if self.isRefund is not None:
5386 phani.kuma 22296 
      oprot.writeFieldBegin('isRefund', TType.BOOL, 2)
5189 varun.gupt 22297 
      oprot.writeBool(self.isRefund)
22298 
      oprot.writeFieldEnd()
4600 varun.gupt 22299 
    oprot.writeFieldStop()
22300 
    oprot.writeStructEnd()
22301 
 
22302 
  def validate(self):
22303 
    return
22304 
 
22305 
 
22306 
  def __repr__(self):
22307 
    L = ['%s=%r' % (key, value)
22308 
      for key, value in self.__dict__.iteritems()]
22309 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
22310 
 
22311 
  def __eq__(self, other):
22312 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
22313 
 
22314 
  def __ne__(self, other):
22315 
    return not (self == other)
22316 
 
5386 phani.kuma 22317 
class getSettlementForCod_result:
4600 varun.gupt 22318 
  """
22319 
  Attributes:
22320 
   - success
22321 
   - ex
22322 
  """
22323 
 
22324 
  thrift_spec = (
22325 
    (0, TType.STRUCT, 'success', (PaymentSettlement, PaymentSettlement.thrift_spec), None, ), # 0
22326 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
22327 
  )
22328 
 
22329 
  def __init__(self, success=None, ex=None,):
22330 
    self.success = success
22331 
    self.ex = ex
22332 
 
22333 
  def read(self, iprot):
22334 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
22335 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
22336 
      return
22337 
    iprot.readStructBegin()
22338 
    while True:
22339 
      (fname, ftype, fid) = iprot.readFieldBegin()
22340 
      if ftype == TType.STOP:
22341 
        break
22342 
      if fid == 0:
22343 
        if ftype == TType.STRUCT:
22344 
          self.success = PaymentSettlement()
22345 
          self.success.read(iprot)
22346 
        else:
22347 
          iprot.skip(ftype)
22348 
      elif fid == 1:
22349 
        if ftype == TType.STRUCT:
22350 
          self.ex = TransactionServiceException()
22351 
          self.ex.read(iprot)
22352 
        else:
22353 
          iprot.skip(ftype)
22354 
      else:
22355 
        iprot.skip(ftype)
22356 
      iprot.readFieldEnd()
22357 
    iprot.readStructEnd()
22358 
 
22359 
  def write(self, oprot):
22360 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
22361 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
22362 
      return
5386 phani.kuma 22363 
    oprot.writeStructBegin('getSettlementForCod_result')
4600 varun.gupt 22364 
    if self.success is not None:
22365 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
22366 
      self.success.write(oprot)
22367 
      oprot.writeFieldEnd()
22368 
    if self.ex is not None:
22369 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
22370 
      self.ex.write(oprot)
22371 
      oprot.writeFieldEnd()
22372 
    oprot.writeFieldStop()
22373 
    oprot.writeStructEnd()
22374 
 
22375 
  def validate(self):
22376 
    return
22377 
 
22378 
 
22379 
  def __repr__(self):
22380 
    L = ['%s=%r' % (key, value)
22381 
      for key, value in self.__dict__.iteritems()]
22382 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
22383 
 
22384 
  def __eq__(self, other):
22385 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
22386 
 
22387 
  def __ne__(self, other):
22388 
    return not (self == other)
22389 
 
22390 
class getEBSSettlementSummaries_args:
22391 
 
22392 
  thrift_spec = (
22393 
  )
22394 
 
22395 
  def read(self, iprot):
22396 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
22397 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
22398 
      return
22399 
    iprot.readStructBegin()
22400 
    while True:
22401 
      (fname, ftype, fid) = iprot.readFieldBegin()
22402 
      if ftype == TType.STOP:
22403 
        break
22404 
      else:
22405 
        iprot.skip(ftype)
22406 
      iprot.readFieldEnd()
22407 
    iprot.readStructEnd()
22408 
 
22409 
  def write(self, oprot):
22410 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
22411 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
22412 
      return
22413 
    oprot.writeStructBegin('getEBSSettlementSummaries_args')
22414 
    oprot.writeFieldStop()
22415 
    oprot.writeStructEnd()
22416 
 
22417 
  def validate(self):
22418 
    return
22419 
 
22420 
 
22421 
  def __repr__(self):
22422 
    L = ['%s=%r' % (key, value)
22423 
      for key, value in self.__dict__.iteritems()]
22424 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
22425 
 
22426 
  def __eq__(self, other):
22427 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
22428 
 
22429 
  def __ne__(self, other):
22430 
    return not (self == other)
22431 
 
22432 
class getEBSSettlementSummaries_result:
22433 
  """
22434 
  Attributes:
22435 
   - success
22436 
   - ex
22437 
  """
22438 
 
22439 
  thrift_spec = (
22440 
    (0, TType.MAP, 'success', (TType.I64,None,TType.STRING,None), None, ), # 0
22441 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
22442 
  )
22443 
 
22444 
  def __init__(self, success=None, ex=None,):
22445 
    self.success = success
22446 
    self.ex = ex
22447 
 
22448 
  def read(self, iprot):
22449 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
22450 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
22451 
      return
22452 
    iprot.readStructBegin()
22453 
    while True:
22454 
      (fname, ftype, fid) = iprot.readFieldBegin()
22455 
      if ftype == TType.STOP:
22456 
        break
22457 
      if fid == 0:
22458 
        if ftype == TType.MAP:
22459 
          self.success = {}
5713 rajveer 22460 
          (_ktype512, _vtype513, _size511 ) = iprot.readMapBegin()
22461 
          for _i515 in xrange(_size511):
22462 
            _key516 = iprot.readI64();
22463 
            _val517 = iprot.readString();
22464 
            self.success[_key516] = _val517
4600 varun.gupt 22465 
          iprot.readMapEnd()
22466 
        else:
22467 
          iprot.skip(ftype)
22468 
      elif fid == 1:
22469 
        if ftype == TType.STRUCT:
22470 
          self.ex = TransactionServiceException()
22471 
          self.ex.read(iprot)
22472 
        else:
22473 
          iprot.skip(ftype)
22474 
      else:
22475 
        iprot.skip(ftype)
22476 
      iprot.readFieldEnd()
22477 
    iprot.readStructEnd()
22478 
 
22479 
  def write(self, oprot):
22480 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
22481 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
22482 
      return
22483 
    oprot.writeStructBegin('getEBSSettlementSummaries_result')
22484 
    if self.success is not None:
22485 
      oprot.writeFieldBegin('success', TType.MAP, 0)
22486 
      oprot.writeMapBegin(TType.I64, TType.STRING, len(self.success))
5713 rajveer 22487 
      for kiter518,viter519 in self.success.items():
22488 
        oprot.writeI64(kiter518)
22489 
        oprot.writeString(viter519)
4600 varun.gupt 22490 
      oprot.writeMapEnd()
22491 
      oprot.writeFieldEnd()
22492 
    if self.ex is not None:
22493 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
22494 
      self.ex.write(oprot)
22495 
      oprot.writeFieldEnd()
22496 
    oprot.writeFieldStop()
22497 
    oprot.writeStructEnd()
22498 
 
22499 
  def validate(self):
22500 
    return
22501 
 
22502 
 
22503 
  def __repr__(self):
22504 
    L = ['%s=%r' % (key, value)
22505 
      for key, value in self.__dict__.iteritems()]
22506 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
22507 
 
22508 
  def __eq__(self, other):
22509 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
22510 
 
22511 
  def __ne__(self, other):
22512 
    return not (self == other)
22513 
 
22514 
class markEBSSettlementUploaded_args:
22515 
  """
22516 
  Attributes:
22517 
   - settlementId
22518 
  """
22519 
 
22520 
  thrift_spec = (
22521 
    None, # 0
22522 
    (1, TType.I64, 'settlementId', None, None, ), # 1
22523 
  )
22524 
 
22525 
  def __init__(self, settlementId=None,):
22526 
    self.settlementId = settlementId
22527 
 
22528 
  def read(self, iprot):
22529 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
22530 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
22531 
      return
22532 
    iprot.readStructBegin()
22533 
    while True:
22534 
      (fname, ftype, fid) = iprot.readFieldBegin()
22535 
      if ftype == TType.STOP:
22536 
        break
22537 
      if fid == 1:
22538 
        if ftype == TType.I64:
22539 
          self.settlementId = iprot.readI64();
22540 
        else:
22541 
          iprot.skip(ftype)
22542 
      else:
22543 
        iprot.skip(ftype)
22544 
      iprot.readFieldEnd()
22545 
    iprot.readStructEnd()
22546 
 
22547 
  def write(self, oprot):
22548 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
22549 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
22550 
      return
22551 
    oprot.writeStructBegin('markEBSSettlementUploaded_args')
22552 
    if self.settlementId is not None:
22553 
      oprot.writeFieldBegin('settlementId', TType.I64, 1)
22554 
      oprot.writeI64(self.settlementId)
22555 
      oprot.writeFieldEnd()
22556 
    oprot.writeFieldStop()
22557 
    oprot.writeStructEnd()
22558 
 
22559 
  def validate(self):
22560 
    return
22561 
 
22562 
 
22563 
  def __repr__(self):
22564 
    L = ['%s=%r' % (key, value)
22565 
      for key, value in self.__dict__.iteritems()]
22566 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
22567 
 
22568 
  def __eq__(self, other):
22569 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
22570 
 
22571 
  def __ne__(self, other):
22572 
    return not (self == other)
22573 
 
22574 
class markEBSSettlementUploaded_result:
22575 
  """
22576 
  Attributes:
22577 
   - ex
22578 
  """
22579 
 
22580 
  thrift_spec = (
22581 
    None, # 0
22582 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
22583 
  )
22584 
 
22585 
  def __init__(self, ex=None,):
22586 
    self.ex = ex
22587 
 
22588 
  def read(self, iprot):
22589 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
22590 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
22591 
      return
22592 
    iprot.readStructBegin()
22593 
    while True:
22594 
      (fname, ftype, fid) = iprot.readFieldBegin()
22595 
      if ftype == TType.STOP:
22596 
        break
22597 
      if fid == 1:
22598 
        if ftype == TType.STRUCT:
22599 
          self.ex = TransactionServiceException()
22600 
          self.ex.read(iprot)
22601 
        else:
22602 
          iprot.skip(ftype)
22603 
      else:
22604 
        iprot.skip(ftype)
22605 
      iprot.readFieldEnd()
22606 
    iprot.readStructEnd()
22607 
 
22608 
  def write(self, oprot):
22609 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
22610 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
22611 
      return
22612 
    oprot.writeStructBegin('markEBSSettlementUploaded_result')
22613 
    if self.ex is not None:
22614 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
22615 
      self.ex.write(oprot)
22616 
      oprot.writeFieldEnd()
22617 
    oprot.writeFieldStop()
22618 
    oprot.writeStructEnd()
22619 
 
22620 
  def validate(self):
22621 
    return
22622 
 
22623 
 
22624 
  def __repr__(self):
22625 
    L = ['%s=%r' % (key, value)
22626 
      for key, value in self.__dict__.iteritems()]
22627 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
22628 
 
22629 
  def __eq__(self, other):
22630 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
22631 
 
22632 
  def __ne__(self, other):
22633 
    return not (self == other)
22634 
 
22635 
class getEBSSettlementDate_args:
22636 
  """
22637 
  Attributes:
22638 
   - settlementId
22639 
  """
22640 
 
22641 
  thrift_spec = (
22642 
    None, # 0
22643 
    (1, TType.I64, 'settlementId', None, None, ), # 1
22644 
  )
22645 
 
22646 
  def __init__(self, settlementId=None,):
22647 
    self.settlementId = settlementId
22648 
 
22649 
  def read(self, iprot):
22650 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
22651 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
22652 
      return
22653 
    iprot.readStructBegin()
22654 
    while True:
22655 
      (fname, ftype, fid) = iprot.readFieldBegin()
22656 
      if ftype == TType.STOP:
22657 
        break
22658 
      if fid == 1:
22659 
        if ftype == TType.I64:
22660 
          self.settlementId = iprot.readI64();
22661 
        else:
22662 
          iprot.skip(ftype)
22663 
      else:
22664 
        iprot.skip(ftype)
22665 
      iprot.readFieldEnd()
22666 
    iprot.readStructEnd()
22667 
 
22668 
  def write(self, oprot):
22669 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
22670 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
22671 
      return
22672 
    oprot.writeStructBegin('getEBSSettlementDate_args')
22673 
    if self.settlementId is not None:
22674 
      oprot.writeFieldBegin('settlementId', TType.I64, 1)
22675 
      oprot.writeI64(self.settlementId)
22676 
      oprot.writeFieldEnd()
22677 
    oprot.writeFieldStop()
22678 
    oprot.writeStructEnd()
22679 
 
22680 
  def validate(self):
22681 
    return
22682 
 
22683 
 
22684 
  def __repr__(self):
22685 
    L = ['%s=%r' % (key, value)
22686 
      for key, value in self.__dict__.iteritems()]
22687 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
22688 
 
22689 
  def __eq__(self, other):
22690 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
22691 
 
22692 
  def __ne__(self, other):
22693 
    return not (self == other)
22694 
 
22695 
class getEBSSettlementDate_result:
22696 
  """
22697 
  Attributes:
22698 
   - success
22699 
   - ex
22700 
  """
22701 
 
22702 
  thrift_spec = (
22703 
    (0, TType.I64, 'success', None, None, ), # 0
22704 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
22705 
  )
22706 
 
22707 
  def __init__(self, success=None, ex=None,):
22708 
    self.success = success
22709 
    self.ex = ex
22710 
 
22711 
  def read(self, iprot):
22712 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
22713 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
22714 
      return
22715 
    iprot.readStructBegin()
22716 
    while True:
22717 
      (fname, ftype, fid) = iprot.readFieldBegin()
22718 
      if ftype == TType.STOP:
22719 
        break
22720 
      if fid == 0:
22721 
        if ftype == TType.I64:
22722 
          self.success = iprot.readI64();
22723 
        else:
22724 
          iprot.skip(ftype)
22725 
      elif fid == 1:
22726 
        if ftype == TType.STRUCT:
22727 
          self.ex = TransactionServiceException()
22728 
          self.ex.read(iprot)
22729 
        else:
22730 
          iprot.skip(ftype)
22731 
      else:
22732 
        iprot.skip(ftype)
22733 
      iprot.readFieldEnd()
22734 
    iprot.readStructEnd()
22735 
 
22736 
  def write(self, oprot):
22737 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
22738 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
22739 
      return
22740 
    oprot.writeStructBegin('getEBSSettlementDate_result')
22741 
    if self.success is not None:
22742 
      oprot.writeFieldBegin('success', TType.I64, 0)
22743 
      oprot.writeI64(self.success)
22744 
      oprot.writeFieldEnd()
22745 
    if self.ex is not None:
22746 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
22747 
      self.ex.write(oprot)
22748 
      oprot.writeFieldEnd()
22749 
    oprot.writeFieldStop()
22750 
    oprot.writeStructEnd()
22751 
 
22752 
  def validate(self):
22753 
    return
22754 
 
22755 
 
22756 
  def __repr__(self):
22757 
    L = ['%s=%r' % (key, value)
22758 
      for key, value in self.__dict__.iteritems()]
22759 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
22760 
 
22761 
  def __eq__(self, other):
22762 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
22763 
 
22764 
  def __ne__(self, other):
22765 
    return not (self == other)
4715 varun.gupt 22766 
 
22767 
class getSettlementsByDate_args:
22768 
  """
22769 
  Attributes:
22770 
   - settlementDateFrom
22771 
   - settlementDateTo
22772 
   - isRefund
22773 
  """
22774 
 
22775 
  thrift_spec = (
22776 
    None, # 0
22777 
    (1, TType.I64, 'settlementDateFrom', None, None, ), # 1
22778 
    (2, TType.I64, 'settlementDateTo', None, None, ), # 2
22779 
    (3, TType.BOOL, 'isRefund', None, None, ), # 3
22780 
  )
22781 
 
22782 
  def __init__(self, settlementDateFrom=None, settlementDateTo=None, isRefund=None,):
22783 
    self.settlementDateFrom = settlementDateFrom
22784 
    self.settlementDateTo = settlementDateTo
22785 
    self.isRefund = isRefund
22786 
 
22787 
  def read(self, iprot):
22788 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
22789 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
22790 
      return
22791 
    iprot.readStructBegin()
22792 
    while True:
22793 
      (fname, ftype, fid) = iprot.readFieldBegin()
22794 
      if ftype == TType.STOP:
22795 
        break
22796 
      if fid == 1:
22797 
        if ftype == TType.I64:
22798 
          self.settlementDateFrom = iprot.readI64();
22799 
        else:
22800 
          iprot.skip(ftype)
22801 
      elif fid == 2:
22802 
        if ftype == TType.I64:
22803 
          self.settlementDateTo = iprot.readI64();
22804 
        else:
22805 
          iprot.skip(ftype)
22806 
      elif fid == 3:
22807 
        if ftype == TType.BOOL:
22808 
          self.isRefund = iprot.readBool();
22809 
        else:
22810 
          iprot.skip(ftype)
22811 
      else:
22812 
        iprot.skip(ftype)
22813 
      iprot.readFieldEnd()
22814 
    iprot.readStructEnd()
22815 
 
22816 
  def write(self, oprot):
22817 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
22818 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
22819 
      return
22820 
    oprot.writeStructBegin('getSettlementsByDate_args')
22821 
    if self.settlementDateFrom is not None:
22822 
      oprot.writeFieldBegin('settlementDateFrom', TType.I64, 1)
22823 
      oprot.writeI64(self.settlementDateFrom)
22824 
      oprot.writeFieldEnd()
22825 
    if self.settlementDateTo is not None:
22826 
      oprot.writeFieldBegin('settlementDateTo', TType.I64, 2)
22827 
      oprot.writeI64(self.settlementDateTo)
22828 
      oprot.writeFieldEnd()
22829 
    if self.isRefund is not None:
22830 
      oprot.writeFieldBegin('isRefund', TType.BOOL, 3)
22831 
      oprot.writeBool(self.isRefund)
22832 
      oprot.writeFieldEnd()
22833 
    oprot.writeFieldStop()
22834 
    oprot.writeStructEnd()
22835 
 
22836 
  def validate(self):
22837 
    return
22838 
 
22839 
 
22840 
  def __repr__(self):
22841 
    L = ['%s=%r' % (key, value)
22842 
      for key, value in self.__dict__.iteritems()]
22843 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
22844 
 
22845 
  def __eq__(self, other):
22846 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
22847 
 
22848 
  def __ne__(self, other):
22849 
    return not (self == other)
22850 
 
22851 
class getSettlementsByDate_result:
22852 
  """
22853 
  Attributes:
22854 
   - success
22855 
   - ex
22856 
  """
22857 
 
22858 
  thrift_spec = (
22859 
    (0, TType.LIST, 'success', (TType.STRUCT,(PaymentSettlement, PaymentSettlement.thrift_spec)), None, ), # 0
22860 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
22861 
  )
22862 
 
22863 
  def __init__(self, success=None, ex=None,):
22864 
    self.success = success
22865 
    self.ex = ex
22866 
 
22867 
  def read(self, iprot):
22868 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
22869 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
22870 
      return
22871 
    iprot.readStructBegin()
22872 
    while True:
22873 
      (fname, ftype, fid) = iprot.readFieldBegin()
22874 
      if ftype == TType.STOP:
22875 
        break
22876 
      if fid == 0:
22877 
        if ftype == TType.LIST:
22878 
          self.success = []
5713 rajveer 22879 
          (_etype523, _size520) = iprot.readListBegin()
22880 
          for _i524 in xrange(_size520):
22881 
            _elem525 = PaymentSettlement()
22882 
            _elem525.read(iprot)
22883 
            self.success.append(_elem525)
4715 varun.gupt 22884 
          iprot.readListEnd()
22885 
        else:
22886 
          iprot.skip(ftype)
22887 
      elif fid == 1:
22888 
        if ftype == TType.STRUCT:
22889 
          self.ex = TransactionServiceException()
22890 
          self.ex.read(iprot)
22891 
        else:
22892 
          iprot.skip(ftype)
22893 
      else:
22894 
        iprot.skip(ftype)
22895 
      iprot.readFieldEnd()
22896 
    iprot.readStructEnd()
22897 
 
22898 
  def write(self, oprot):
22899 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
22900 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
22901 
      return
22902 
    oprot.writeStructBegin('getSettlementsByDate_result')
22903 
    if self.success is not None:
22904 
      oprot.writeFieldBegin('success', TType.LIST, 0)
22905 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
5713 rajveer 22906 
      for iter526 in self.success:
22907 
        iter526.write(oprot)
4715 varun.gupt 22908 
      oprot.writeListEnd()
22909 
      oprot.writeFieldEnd()
22910 
    if self.ex is not None:
22911 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
22912 
      self.ex.write(oprot)
22913 
      oprot.writeFieldEnd()
22914 
    oprot.writeFieldStop()
22915 
    oprot.writeStructEnd()
22916 
 
22917 
  def validate(self):
22918 
    return
22919 
 
22920 
 
22921 
  def __repr__(self):
22922 
    L = ['%s=%r' % (key, value)
22923 
      for key, value in self.__dict__.iteritems()]
22924 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
22925 
 
22926 
  def __eq__(self, other):
22927 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
22928 
 
22929 
  def __ne__(self, other):
22930 
    return not (self == other)
22931 
 
22932 
class getReshippedOrderIds_args:
22933 
  """
22934 
  Attributes:
22935 
   - orderIds
22936 
  """
22937 
 
22938 
  thrift_spec = (
22939 
    None, # 0
22940 
    (1, TType.LIST, 'orderIds', (TType.I64,None), None, ), # 1
22941 
  )
22942 
 
22943 
  def __init__(self, orderIds=None,):
22944 
    self.orderIds = orderIds
22945 
 
22946 
  def read(self, iprot):
22947 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
22948 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
22949 
      return
22950 
    iprot.readStructBegin()
22951 
    while True:
22952 
      (fname, ftype, fid) = iprot.readFieldBegin()
22953 
      if ftype == TType.STOP:
22954 
        break
22955 
      if fid == 1:
22956 
        if ftype == TType.LIST:
22957 
          self.orderIds = []
5713 rajveer 22958 
          (_etype530, _size527) = iprot.readListBegin()
22959 
          for _i531 in xrange(_size527):
22960 
            _elem532 = iprot.readI64();
22961 
            self.orderIds.append(_elem532)
4715 varun.gupt 22962 
          iprot.readListEnd()
22963 
        else:
22964 
          iprot.skip(ftype)
22965 
      else:
22966 
        iprot.skip(ftype)
22967 
      iprot.readFieldEnd()
22968 
    iprot.readStructEnd()
22969 
 
22970 
  def write(self, oprot):
22971 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
22972 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
22973 
      return
22974 
    oprot.writeStructBegin('getReshippedOrderIds_args')
22975 
    if self.orderIds is not None:
22976 
      oprot.writeFieldBegin('orderIds', TType.LIST, 1)
22977 
      oprot.writeListBegin(TType.I64, len(self.orderIds))
5713 rajveer 22978 
      for iter533 in self.orderIds:
22979 
        oprot.writeI64(iter533)
4715 varun.gupt 22980 
      oprot.writeListEnd()
22981 
      oprot.writeFieldEnd()
22982 
    oprot.writeFieldStop()
22983 
    oprot.writeStructEnd()
22984 
 
22985 
  def validate(self):
22986 
    return
22987 
 
22988 
 
22989 
  def __repr__(self):
22990 
    L = ['%s=%r' % (key, value)
22991 
      for key, value in self.__dict__.iteritems()]
22992 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
22993 
 
22994 
  def __eq__(self, other):
22995 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
22996 
 
22997 
  def __ne__(self, other):
22998 
    return not (self == other)
22999 
 
23000 
class getReshippedOrderIds_result:
23001 
  """
23002 
  Attributes:
23003 
   - success
23004 
   - ex
23005 
  """
23006 
 
23007 
  thrift_spec = (
23008 
    (0, TType.LIST, 'success', (TType.I64,None), None, ), # 0
23009 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
23010 
  )
23011 
 
23012 
  def __init__(self, success=None, ex=None,):
23013 
    self.success = success
23014 
    self.ex = ex
23015 
 
23016 
  def read(self, iprot):
23017 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
23018 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
23019 
      return
23020 
    iprot.readStructBegin()
23021 
    while True:
23022 
      (fname, ftype, fid) = iprot.readFieldBegin()
23023 
      if ftype == TType.STOP:
23024 
        break
23025 
      if fid == 0:
23026 
        if ftype == TType.LIST:
23027 
          self.success = []
5713 rajveer 23028 
          (_etype537, _size534) = iprot.readListBegin()
23029 
          for _i538 in xrange(_size534):
23030 
            _elem539 = iprot.readI64();
23031 
            self.success.append(_elem539)
4715 varun.gupt 23032 
          iprot.readListEnd()
23033 
        else:
23034 
          iprot.skip(ftype)
23035 
      elif fid == 1:
23036 
        if ftype == TType.STRUCT:
23037 
          self.ex = TransactionServiceException()
23038 
          self.ex.read(iprot)
23039 
        else:
23040 
          iprot.skip(ftype)
23041 
      else:
23042 
        iprot.skip(ftype)
23043 
      iprot.readFieldEnd()
23044 
    iprot.readStructEnd()
23045 
 
23046 
  def write(self, oprot):
23047 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
23048 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
23049 
      return
23050 
    oprot.writeStructBegin('getReshippedOrderIds_result')
23051 
    if self.success is not None:
23052 
      oprot.writeFieldBegin('success', TType.LIST, 0)
23053 
      oprot.writeListBegin(TType.I64, len(self.success))
5713 rajveer 23054 
      for iter540 in self.success:
23055 
        oprot.writeI64(iter540)
4715 varun.gupt 23056 
      oprot.writeListEnd()
23057 
      oprot.writeFieldEnd()
23058 
    if self.ex is not None:
23059 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
23060 
      self.ex.write(oprot)
23061 
      oprot.writeFieldEnd()
23062 
    oprot.writeFieldStop()
23063 
    oprot.writeStructEnd()
23064 
 
23065 
  def validate(self):
23066 
    return
23067 
 
23068 
 
23069 
  def __repr__(self):
23070 
    L = ['%s=%r' % (key, value)
23071 
      for key, value in self.__dict__.iteritems()]
23072 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
23073 
 
23074 
  def __eq__(self, other):
23075 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
23076 
 
23077 
  def __ne__(self, other):
23078 
    return not (self == other)
4757 mandeep.dh 23079 
 
5481 phani.kuma 23080 
class getBilledOrders_args:
4875 varun.gupt 23081 
  """
23082 
  Attributes:
23083 
   - vendorId
5481 phani.kuma 23084 
   - onlyVendorNotPaid
23085 
   - billingDateFrom
23086 
   - billingDateTo
4875 varun.gupt 23087 
  """
23088 
 
23089 
  thrift_spec = (
23090 
    None, # 0
23091 
    (1, TType.I64, 'vendorId', None, None, ), # 1
5481 phani.kuma 23092 
    (2, TType.BOOL, 'onlyVendorNotPaid', None, None, ), # 2
23093 
    (3, TType.I64, 'billingDateFrom', None, None, ), # 3
23094 
    (4, TType.I64, 'billingDateTo', None, None, ), # 4
4875 varun.gupt 23095 
  )
23096 
 
5481 phani.kuma 23097 
  def __init__(self, vendorId=None, onlyVendorNotPaid=None, billingDateFrom=None, billingDateTo=None,):
4875 varun.gupt 23098 
    self.vendorId = vendorId
5481 phani.kuma 23099 
    self.onlyVendorNotPaid = onlyVendorNotPaid
23100 
    self.billingDateFrom = billingDateFrom
23101 
    self.billingDateTo = billingDateTo
4875 varun.gupt 23102 
 
23103 
  def read(self, iprot):
23104 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
23105 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
23106 
      return
23107 
    iprot.readStructBegin()
23108 
    while True:
23109 
      (fname, ftype, fid) = iprot.readFieldBegin()
23110 
      if ftype == TType.STOP:
23111 
        break
23112 
      if fid == 1:
23113 
        if ftype == TType.I64:
23114 
          self.vendorId = iprot.readI64();
23115 
        else:
23116 
          iprot.skip(ftype)
5481 phani.kuma 23117 
      elif fid == 2:
23118 
        if ftype == TType.BOOL:
23119 
          self.onlyVendorNotPaid = iprot.readBool();
23120 
        else:
23121 
          iprot.skip(ftype)
23122 
      elif fid == 3:
23123 
        if ftype == TType.I64:
23124 
          self.billingDateFrom = iprot.readI64();
23125 
        else:
23126 
          iprot.skip(ftype)
23127 
      elif fid == 4:
23128 
        if ftype == TType.I64:
23129 
          self.billingDateTo = iprot.readI64();
23130 
        else:
23131 
          iprot.skip(ftype)
4875 varun.gupt 23132 
      else:
23133 
        iprot.skip(ftype)
23134 
      iprot.readFieldEnd()
23135 
    iprot.readStructEnd()
23136 
 
23137 
  def write(self, oprot):
23138 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
23139 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
23140 
      return
5481 phani.kuma 23141 
    oprot.writeStructBegin('getBilledOrders_args')
4875 varun.gupt 23142 
    if self.vendorId is not None:
23143 
      oprot.writeFieldBegin('vendorId', TType.I64, 1)
23144 
      oprot.writeI64(self.vendorId)
23145 
      oprot.writeFieldEnd()
5481 phani.kuma 23146 
    if self.onlyVendorNotPaid is not None:
23147 
      oprot.writeFieldBegin('onlyVendorNotPaid', TType.BOOL, 2)
23148 
      oprot.writeBool(self.onlyVendorNotPaid)
23149 
      oprot.writeFieldEnd()
23150 
    if self.billingDateFrom is not None:
23151 
      oprot.writeFieldBegin('billingDateFrom', TType.I64, 3)
23152 
      oprot.writeI64(self.billingDateFrom)
23153 
      oprot.writeFieldEnd()
23154 
    if self.billingDateTo is not None:
23155 
      oprot.writeFieldBegin('billingDateTo', TType.I64, 4)
23156 
      oprot.writeI64(self.billingDateTo)
23157 
      oprot.writeFieldEnd()
4875 varun.gupt 23158 
    oprot.writeFieldStop()
23159 
    oprot.writeStructEnd()
23160 
 
23161 
  def validate(self):
23162 
    return
23163 
 
23164 
 
23165 
  def __repr__(self):
23166 
    L = ['%s=%r' % (key, value)
23167 
      for key, value in self.__dict__.iteritems()]
23168 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
23169 
 
23170 
  def __eq__(self, other):
23171 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
23172 
 
23173 
  def __ne__(self, other):
23174 
    return not (self == other)
23175 
 
5481 phani.kuma 23176 
class getBilledOrders_result:
4875 varun.gupt 23177 
  """
23178 
  Attributes:
23179 
   - success
23180 
   - ex
23181 
  """
23182 
 
23183 
  thrift_spec = (
23184 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
23185 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
23186 
  )
23187 
 
23188 
  def __init__(self, success=None, ex=None,):
23189 
    self.success = success
23190 
    self.ex = ex
23191 
 
23192 
  def read(self, iprot):
23193 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
23194 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
23195 
      return
23196 
    iprot.readStructBegin()
23197 
    while True:
23198 
      (fname, ftype, fid) = iprot.readFieldBegin()
23199 
      if ftype == TType.STOP:
23200 
        break
23201 
      if fid == 0:
23202 
        if ftype == TType.LIST:
23203 
          self.success = []
5713 rajveer 23204 
          (_etype544, _size541) = iprot.readListBegin()
23205 
          for _i545 in xrange(_size541):
23206 
            _elem546 = Order()
23207 
            _elem546.read(iprot)
23208 
            self.success.append(_elem546)
4875 varun.gupt 23209 
          iprot.readListEnd()
23210 
        else:
23211 
          iprot.skip(ftype)
23212 
      elif fid == 1:
23213 
        if ftype == TType.STRUCT:
23214 
          self.ex = TransactionServiceException()
23215 
          self.ex.read(iprot)
23216 
        else:
23217 
          iprot.skip(ftype)
23218 
      else:
23219 
        iprot.skip(ftype)
23220 
      iprot.readFieldEnd()
23221 
    iprot.readStructEnd()
23222 
 
23223 
  def write(self, oprot):
23224 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
23225 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
23226 
      return
5481 phani.kuma 23227 
    oprot.writeStructBegin('getBilledOrders_result')
4875 varun.gupt 23228 
    if self.success is not None:
23229 
      oprot.writeFieldBegin('success', TType.LIST, 0)
23230 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
5713 rajveer 23231 
      for iter547 in self.success:
23232 
        iter547.write(oprot)
4875 varun.gupt 23233 
      oprot.writeListEnd()
23234 
      oprot.writeFieldEnd()
23235 
    if self.ex is not None:
23236 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
23237 
      self.ex.write(oprot)
23238 
      oprot.writeFieldEnd()
23239 
    oprot.writeFieldStop()
23240 
    oprot.writeStructEnd()
23241 
 
23242 
  def validate(self):
23243 
    return
23244 
 
23245 
 
23246 
  def __repr__(self):
23247 
    L = ['%s=%r' % (key, value)
23248 
      for key, value in self.__dict__.iteritems()]
23249 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
23250 
 
23251 
  def __eq__(self, other):
23252 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
23253 
 
23254 
  def __ne__(self, other):
23255 
    return not (self == other)
5031 varun.gupt 23256 
 
23257 
class getStatusDistributionOfOrders_args:
23258 
  """
23259 
  Attributes:
23260 
   - startDate
23261 
   - endDate
23262 
  """
23263 
 
23264 
  thrift_spec = (
23265 
    None, # 0
23266 
    (1, TType.I64, 'startDate', None, None, ), # 1
23267 
    (2, TType.I64, 'endDate', None, None, ), # 2
23268 
  )
23269 
 
23270 
  def __init__(self, startDate=None, endDate=None,):
23271 
    self.startDate = startDate
23272 
    self.endDate = endDate
23273 
 
23274 
  def read(self, iprot):
23275 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
23276 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
23277 
      return
23278 
    iprot.readStructBegin()
23279 
    while True:
23280 
      (fname, ftype, fid) = iprot.readFieldBegin()
23281 
      if ftype == TType.STOP:
23282 
        break
23283 
      if fid == 1:
23284 
        if ftype == TType.I64:
23285 
          self.startDate = iprot.readI64();
23286 
        else:
23287 
          iprot.skip(ftype)
23288 
      elif fid == 2:
23289 
        if ftype == TType.I64:
23290 
          self.endDate = iprot.readI64();
23291 
        else:
23292 
          iprot.skip(ftype)
23293 
      else:
23294 
        iprot.skip(ftype)
23295 
      iprot.readFieldEnd()
23296 
    iprot.readStructEnd()
23297 
 
23298 
  def write(self, oprot):
23299 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
23300 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
23301 
      return
23302 
    oprot.writeStructBegin('getStatusDistributionOfOrders_args')
23303 
    if self.startDate is not None:
23304 
      oprot.writeFieldBegin('startDate', TType.I64, 1)
23305 
      oprot.writeI64(self.startDate)
23306 
      oprot.writeFieldEnd()
23307 
    if self.endDate is not None:
23308 
      oprot.writeFieldBegin('endDate', TType.I64, 2)
23309 
      oprot.writeI64(self.endDate)
23310 
      oprot.writeFieldEnd()
23311 
    oprot.writeFieldStop()
23312 
    oprot.writeStructEnd()
23313 
 
23314 
  def validate(self):
23315 
    return
23316 
 
23317 
 
23318 
  def __repr__(self):
23319 
    L = ['%s=%r' % (key, value)
23320 
      for key, value in self.__dict__.iteritems()]
23321 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
23322 
 
23323 
  def __eq__(self, other):
23324 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
23325 
 
23326 
  def __ne__(self, other):
23327 
    return not (self == other)
23328 
 
23329 
class getStatusDistributionOfOrders_result:
23330 
  """
23331 
  Attributes:
23332 
   - success
23333 
   - ex
23334 
  """
23335 
 
23336 
  thrift_spec = (
23337 
    (0, TType.MAP, 'success', (TType.I64,None,TType.I64,None), None, ), # 0
23338 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
23339 
  )
23340 
 
23341 
  def __init__(self, success=None, ex=None,):
23342 
    self.success = success
23343 
    self.ex = ex
23344 
 
23345 
  def read(self, iprot):
23346 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
23347 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
23348 
      return
23349 
    iprot.readStructBegin()
23350 
    while True:
23351 
      (fname, ftype, fid) = iprot.readFieldBegin()
23352 
      if ftype == TType.STOP:
23353 
        break
23354 
      if fid == 0:
23355 
        if ftype == TType.MAP:
23356 
          self.success = {}
5713 rajveer 23357 
          (_ktype549, _vtype550, _size548 ) = iprot.readMapBegin()
23358 
          for _i552 in xrange(_size548):
23359 
            _key553 = iprot.readI64();
23360 
            _val554 = iprot.readI64();
23361 
            self.success[_key553] = _val554
5031 varun.gupt 23362 
          iprot.readMapEnd()
23363 
        else:
23364 
          iprot.skip(ftype)
23365 
      elif fid == 1:
23366 
        if ftype == TType.STRUCT:
23367 
          self.ex = TransactionServiceException()
23368 
          self.ex.read(iprot)
23369 
        else:
23370 
          iprot.skip(ftype)
23371 
      else:
23372 
        iprot.skip(ftype)
23373 
      iprot.readFieldEnd()
23374 
    iprot.readStructEnd()
23375 
 
23376 
  def write(self, oprot):
23377 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
23378 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
23379 
      return
23380 
    oprot.writeStructBegin('getStatusDistributionOfOrders_result')
23381 
    if self.success is not None:
23382 
      oprot.writeFieldBegin('success', TType.MAP, 0)
23383 
      oprot.writeMapBegin(TType.I64, TType.I64, len(self.success))
5713 rajveer 23384 
      for kiter555,viter556 in self.success.items():
23385 
        oprot.writeI64(kiter555)
23386 
        oprot.writeI64(viter556)
5031 varun.gupt 23387 
      oprot.writeMapEnd()
23388 
      oprot.writeFieldEnd()
23389 
    if self.ex is not None:
23390 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
23391 
      self.ex.write(oprot)
23392 
      oprot.writeFieldEnd()
23393 
    oprot.writeFieldStop()
23394 
    oprot.writeStructEnd()
23395 
 
23396 
  def validate(self):
23397 
    return
23398 
 
23399 
 
23400 
  def __repr__(self):
23401 
    L = ['%s=%r' % (key, value)
23402 
      for key, value in self.__dict__.iteritems()]
23403 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
23404 
 
23405 
  def __eq__(self, other):
23406 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
23407 
 
23408 
  def __ne__(self, other):
23409 
    return not (self == other)
5067 varun.gupt 23410 
 
23411 
class getOrderIdsForStatus_args:
23412 
  """
23413 
  Attributes:
23414 
   - status
23415 
   - startDatetime
23416 
   - endDatetime
23417 
  """
23418 
 
23419 
  thrift_spec = (
23420 
    None, # 0
23421 
    (1, TType.I64, 'status', None, None, ), # 1
23422 
    (2, TType.I64, 'startDatetime', None, None, ), # 2
23423 
    (3, TType.I64, 'endDatetime', None, None, ), # 3
23424 
  )
23425 
 
23426 
  def __init__(self, status=None, startDatetime=None, endDatetime=None,):
23427 
    self.status = status
23428 
    self.startDatetime = startDatetime
23429 
    self.endDatetime = endDatetime
23430 
 
23431 
  def read(self, iprot):
23432 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
23433 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
23434 
      return
23435 
    iprot.readStructBegin()
23436 
    while True:
23437 
      (fname, ftype, fid) = iprot.readFieldBegin()
23438 
      if ftype == TType.STOP:
23439 
        break
23440 
      if fid == 1:
23441 
        if ftype == TType.I64:
23442 
          self.status = iprot.readI64();
23443 
        else:
23444 
          iprot.skip(ftype)
23445 
      elif fid == 2:
23446 
        if ftype == TType.I64:
23447 
          self.startDatetime = iprot.readI64();
23448 
        else:
23449 
          iprot.skip(ftype)
23450 
      elif fid == 3:
23451 
        if ftype == TType.I64:
23452 
          self.endDatetime = iprot.readI64();
23453 
        else:
23454 
          iprot.skip(ftype)
23455 
      else:
23456 
        iprot.skip(ftype)
23457 
      iprot.readFieldEnd()
23458 
    iprot.readStructEnd()
23459 
 
23460 
  def write(self, oprot):
23461 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
23462 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
23463 
      return
23464 
    oprot.writeStructBegin('getOrderIdsForStatus_args')
23465 
    if self.status is not None:
23466 
      oprot.writeFieldBegin('status', TType.I64, 1)
23467 
      oprot.writeI64(self.status)
23468 
      oprot.writeFieldEnd()
23469 
    if self.startDatetime is not None:
23470 
      oprot.writeFieldBegin('startDatetime', TType.I64, 2)
23471 
      oprot.writeI64(self.startDatetime)
23472 
      oprot.writeFieldEnd()
23473 
    if self.endDatetime is not None:
23474 
      oprot.writeFieldBegin('endDatetime', TType.I64, 3)
23475 
      oprot.writeI64(self.endDatetime)
23476 
      oprot.writeFieldEnd()
23477 
    oprot.writeFieldStop()
23478 
    oprot.writeStructEnd()
23479 
 
23480 
  def validate(self):
23481 
    return
23482 
 
23483 
 
23484 
  def __repr__(self):
23485 
    L = ['%s=%r' % (key, value)
23486 
      for key, value in self.__dict__.iteritems()]
23487 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
23488 
 
23489 
  def __eq__(self, other):
23490 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
23491 
 
23492 
  def __ne__(self, other):
23493 
    return not (self == other)
23494 
 
23495 
class getOrderIdsForStatus_result:
23496 
  """
23497 
  Attributes:
23498 
   - success
23499 
   - ex
23500 
  """
23501 
 
23502 
  thrift_spec = (
23503 
    (0, TType.LIST, 'success', (TType.I64,None), None, ), # 0
23504 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
23505 
  )
23506 
 
23507 
  def __init__(self, success=None, ex=None,):
23508 
    self.success = success
23509 
    self.ex = ex
23510 
 
23511 
  def read(self, iprot):
23512 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
23513 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
23514 
      return
23515 
    iprot.readStructBegin()
23516 
    while True:
23517 
      (fname, ftype, fid) = iprot.readFieldBegin()
23518 
      if ftype == TType.STOP:
23519 
        break
23520 
      if fid == 0:
23521 
        if ftype == TType.LIST:
23522 
          self.success = []
5713 rajveer 23523 
          (_etype560, _size557) = iprot.readListBegin()
23524 
          for _i561 in xrange(_size557):
23525 
            _elem562 = iprot.readI64();
23526 
            self.success.append(_elem562)
5067 varun.gupt 23527 
          iprot.readListEnd()
23528 
        else:
23529 
          iprot.skip(ftype)
23530 
      elif fid == 1:
23531 
        if ftype == TType.STRUCT:
23532 
          self.ex = TransactionServiceException()
23533 
          self.ex.read(iprot)
23534 
        else:
23535 
          iprot.skip(ftype)
23536 
      else:
23537 
        iprot.skip(ftype)
23538 
      iprot.readFieldEnd()
23539 
    iprot.readStructEnd()
23540 
 
23541 
  def write(self, oprot):
23542 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
23543 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
23544 
      return
23545 
    oprot.writeStructBegin('getOrderIdsForStatus_result')
23546 
    if self.success is not None:
23547 
      oprot.writeFieldBegin('success', TType.LIST, 0)
23548 
      oprot.writeListBegin(TType.I64, len(self.success))
5713 rajveer 23549 
      for iter563 in self.success:
23550 
        oprot.writeI64(iter563)
5067 varun.gupt 23551 
      oprot.writeListEnd()
23552 
      oprot.writeFieldEnd()
23553 
    if self.ex is not None:
23554 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
23555 
      self.ex.write(oprot)
23556 
      oprot.writeFieldEnd()
23557 
    oprot.writeFieldStop()
23558 
    oprot.writeStructEnd()
23559 
 
23560 
  def validate(self):
23561 
    return
23562 
 
23563 
 
23564 
  def __repr__(self):
23565 
    L = ['%s=%r' % (key, value)
23566 
      for key, value in self.__dict__.iteritems()]
23567 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
23568 
 
23569 
  def __eq__(self, other):
23570 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
23571 
 
23572 
  def __ne__(self, other):
23573 
    return not (self == other)
5099 varun.gupt 23574 
 
5348 anupam.sin 23575 
class updateCODAgent_args:
23576 
  """
23577 
  Attributes:
23578 
   - agent
23579 
   - orderId
23580 
  """
23581 
 
23582 
  thrift_spec = (
23583 
    None, # 0
23584 
    (1, TType.STRING, 'agent', None, None, ), # 1
23585 
    (2, TType.I64, 'orderId', None, None, ), # 2
23586 
  )
23587 
 
23588 
  def __init__(self, agent=None, orderId=None,):
23589 
    self.agent = agent
23590 
    self.orderId = orderId
23591 
 
23592 
  def read(self, iprot):
23593 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
23594 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
23595 
      return
23596 
    iprot.readStructBegin()
23597 
    while True:
23598 
      (fname, ftype, fid) = iprot.readFieldBegin()
23599 
      if ftype == TType.STOP:
23600 
        break
23601 
      if fid == 1:
23602 
        if ftype == TType.STRING:
23603 
          self.agent = iprot.readString();
23604 
        else:
23605 
          iprot.skip(ftype)
23606 
      elif fid == 2:
23607 
        if ftype == TType.I64:
23608 
          self.orderId = iprot.readI64();
23609 
        else:
23610 
          iprot.skip(ftype)
23611 
      else:
23612 
        iprot.skip(ftype)
23613 
      iprot.readFieldEnd()
23614 
    iprot.readStructEnd()
23615 
 
23616 
  def write(self, oprot):
23617 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
23618 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
23619 
      return
23620 
    oprot.writeStructBegin('updateCODAgent_args')
23621 
    if self.agent is not None:
23622 
      oprot.writeFieldBegin('agent', TType.STRING, 1)
23623 
      oprot.writeString(self.agent)
23624 
      oprot.writeFieldEnd()
23625 
    if self.orderId is not None:
23626 
      oprot.writeFieldBegin('orderId', TType.I64, 2)
23627 
      oprot.writeI64(self.orderId)
23628 
      oprot.writeFieldEnd()
23629 
    oprot.writeFieldStop()
23630 
    oprot.writeStructEnd()
23631 
 
23632 
  def validate(self):
23633 
    return
23634 
 
23635 
 
23636 
  def __repr__(self):
23637 
    L = ['%s=%r' % (key, value)
23638 
      for key, value in self.__dict__.iteritems()]
23639 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
23640 
 
23641 
  def __eq__(self, other):
23642 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
23643 
 
23644 
  def __ne__(self, other):
23645 
    return not (self == other)
23646 
 
23647 
class updateCODAgent_result:
23648 
  """
23649 
  Attributes:
23650 
   - ex
23651 
  """
23652 
 
23653 
  thrift_spec = (
23654 
    None, # 0
23655 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
23656 
  )
23657 
 
23658 
  def __init__(self, ex=None,):
23659 
    self.ex = ex
23660 
 
23661 
  def read(self, iprot):
23662 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
23663 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
23664 
      return
23665 
    iprot.readStructBegin()
23666 
    while True:
23667 
      (fname, ftype, fid) = iprot.readFieldBegin()
23668 
      if ftype == TType.STOP:
23669 
        break
23670 
      if fid == 1:
23671 
        if ftype == TType.STRUCT:
23672 
          self.ex = TransactionServiceException()
23673 
          self.ex.read(iprot)
23674 
        else:
23675 
          iprot.skip(ftype)
23676 
      else:
23677 
        iprot.skip(ftype)
23678 
      iprot.readFieldEnd()
23679 
    iprot.readStructEnd()
23680 
 
23681 
  def write(self, oprot):
23682 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
23683 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
23684 
      return
23685 
    oprot.writeStructBegin('updateCODAgent_result')
23686 
    if self.ex is not None:
23687 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
23688 
      self.ex.write(oprot)
23689 
      oprot.writeFieldEnd()
23690 
    oprot.writeFieldStop()
23691 
    oprot.writeStructEnd()
23692 
 
23693 
  def validate(self):
23694 
    return
23695 
 
23696 
 
23697 
  def __repr__(self):
23698 
    L = ['%s=%r' % (key, value)
23699 
      for key, value in self.__dict__.iteritems()]
23700 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
23701 
 
23702 
  def __eq__(self, other):
23703 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
23704 
 
23705 
  def __ne__(self, other):
23706 
    return not (self == other)
23707 
 
5099 varun.gupt 23708 
class updateOrderAsPaidToVendor_args:
23709 
  """
23710 
  Attributes:
23711 
   - orderId
23712 
  """
23713 
 
23714 
  thrift_spec = (
23715 
    None, # 0
23716 
    (1, TType.I64, 'orderId', None, None, ), # 1
23717 
  )
23718 
 
23719 
  def __init__(self, orderId=None,):
23720 
    self.orderId = orderId
23721 
 
23722 
  def read(self, iprot):
23723 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
23724 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
23725 
      return
23726 
    iprot.readStructBegin()
23727 
    while True:
23728 
      (fname, ftype, fid) = iprot.readFieldBegin()
23729 
      if ftype == TType.STOP:
23730 
        break
23731 
      if fid == 1:
23732 
        if ftype == TType.I64:
23733 
          self.orderId = iprot.readI64();
23734 
        else:
23735 
          iprot.skip(ftype)
23736 
      else:
23737 
        iprot.skip(ftype)
23738 
      iprot.readFieldEnd()
23739 
    iprot.readStructEnd()
23740 
 
23741 
  def write(self, oprot):
23742 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
23743 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
23744 
      return
23745 
    oprot.writeStructBegin('updateOrderAsPaidToVendor_args')
23746 
    if self.orderId is not None:
23747 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
23748 
      oprot.writeI64(self.orderId)
23749 
      oprot.writeFieldEnd()
23750 
    oprot.writeFieldStop()
23751 
    oprot.writeStructEnd()
23752 
 
23753 
  def validate(self):
23754 
    return
23755 
 
23756 
 
23757 
  def __repr__(self):
23758 
    L = ['%s=%r' % (key, value)
23759 
      for key, value in self.__dict__.iteritems()]
23760 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
23761 
 
23762 
  def __eq__(self, other):
23763 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
23764 
 
23765 
  def __ne__(self, other):
23766 
    return not (self == other)
23767 
 
23768 
class updateOrderAsPaidToVendor_result:
23769 
  """
23770 
  Attributes:
23771 
   - ex
23772 
  """
23773 
 
23774 
  thrift_spec = (
23775 
    None, # 0
23776 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
23777 
  )
23778 
 
23779 
  def __init__(self, ex=None,):
23780 
    self.ex = ex
23781 
 
23782 
  def read(self, iprot):
23783 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
23784 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
23785 
      return
23786 
    iprot.readStructBegin()
23787 
    while True:
23788 
      (fname, ftype, fid) = iprot.readFieldBegin()
23789 
      if ftype == TType.STOP:
23790 
        break
23791 
      if fid == 1:
23792 
        if ftype == TType.STRUCT:
23793 
          self.ex = TransactionServiceException()
23794 
          self.ex.read(iprot)
23795 
        else:
23796 
          iprot.skip(ftype)
23797 
      else:
23798 
        iprot.skip(ftype)
23799 
      iprot.readFieldEnd()
23800 
    iprot.readStructEnd()
23801 
 
23802 
  def write(self, oprot):
23803 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
23804 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
23805 
      return
23806 
    oprot.writeStructBegin('updateOrderAsPaidToVendor_result')
23807 
    if self.ex is not None:
23808 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
23809 
      self.ex.write(oprot)
23810 
      oprot.writeFieldEnd()
23811 
    oprot.writeFieldStop()
23812 
    oprot.writeStructEnd()
23813 
 
23814 
  def validate(self):
23815 
    return
23816 
 
23817 
 
23818 
  def __repr__(self):
23819 
    L = ['%s=%r' % (key, value)
23820 
      for key, value in self.__dict__.iteritems()]
23821 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
23822 
 
23823 
  def __eq__(self, other):
23824 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
23825 
 
23826 
  def __ne__(self, other):
23827 
    return not (self == other)
5208 varun.gupt 23828 
 
5386 phani.kuma 23829 
class updateOrderOnlyAsPaidToVendor_args:
23830 
  """
23831 
  Attributes:
23832 
   - orderId
23833 
  """
23834 
 
23835 
  thrift_spec = (
23836 
    None, # 0
23837 
    (1, TType.I64, 'orderId', None, None, ), # 1
23838 
  )
23839 
 
23840 
  def __init__(self, orderId=None,):
23841 
    self.orderId = orderId
23842 
 
23843 
  def read(self, iprot):
23844 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
23845 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
23846 
      return
23847 
    iprot.readStructBegin()
23848 
    while True:
23849 
      (fname, ftype, fid) = iprot.readFieldBegin()
23850 
      if ftype == TType.STOP:
23851 
        break
23852 
      if fid == 1:
23853 
        if ftype == TType.I64:
23854 
          self.orderId = iprot.readI64();
23855 
        else:
23856 
          iprot.skip(ftype)
23857 
      else:
23858 
        iprot.skip(ftype)
23859 
      iprot.readFieldEnd()
23860 
    iprot.readStructEnd()
23861 
 
23862 
  def write(self, oprot):
23863 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
23864 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
23865 
      return
23866 
    oprot.writeStructBegin('updateOrderOnlyAsPaidToVendor_args')
23867 
    if self.orderId is not None:
23868 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
23869 
      oprot.writeI64(self.orderId)
23870 
      oprot.writeFieldEnd()
23871 
    oprot.writeFieldStop()
23872 
    oprot.writeStructEnd()
23873 
 
23874 
  def validate(self):
23875 
    return
23876 
 
23877 
 
23878 
  def __repr__(self):
23879 
    L = ['%s=%r' % (key, value)
23880 
      for key, value in self.__dict__.iteritems()]
23881 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
23882 
 
23883 
  def __eq__(self, other):
23884 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
23885 
 
23886 
  def __ne__(self, other):
23887 
    return not (self == other)
23888 
 
23889 
class updateOrderOnlyAsPaidToVendor_result:
23890 
  """
23891 
  Attributes:
23892 
   - ex
23893 
  """
23894 
 
23895 
  thrift_spec = (
23896 
    None, # 0
23897 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
23898 
  )
23899 
 
23900 
  def __init__(self, ex=None,):
23901 
    self.ex = ex
23902 
 
23903 
  def read(self, iprot):
23904 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
23905 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
23906 
      return
23907 
    iprot.readStructBegin()
23908 
    while True:
23909 
      (fname, ftype, fid) = iprot.readFieldBegin()
23910 
      if ftype == TType.STOP:
23911 
        break
23912 
      if fid == 1:
23913 
        if ftype == TType.STRUCT:
23914 
          self.ex = TransactionServiceException()
23915 
          self.ex.read(iprot)
23916 
        else:
23917 
          iprot.skip(ftype)
23918 
      else:
23919 
        iprot.skip(ftype)
23920 
      iprot.readFieldEnd()
23921 
    iprot.readStructEnd()
23922 
 
23923 
  def write(self, oprot):
23924 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
23925 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
23926 
      return
23927 
    oprot.writeStructBegin('updateOrderOnlyAsPaidToVendor_result')
23928 
    if self.ex is not None:
23929 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
23930 
      self.ex.write(oprot)
23931 
      oprot.writeFieldEnd()
23932 
    oprot.writeFieldStop()
23933 
    oprot.writeStructEnd()
23934 
 
23935 
  def validate(self):
23936 
    return
23937 
 
23938 
 
23939 
  def __repr__(self):
23940 
    L = ['%s=%r' % (key, value)
23941 
      for key, value in self.__dict__.iteritems()]
23942 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
23943 
 
23944 
  def __eq__(self, other):
23945 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
23946 
 
23947 
  def __ne__(self, other):
23948 
    return not (self == other)
23949 
 
5208 varun.gupt 23950 
class getRefundedOrdersMarkedPaid_args:
23951 
 
23952 
  thrift_spec = (
23953 
  )
23954 
 
23955 
  def read(self, iprot):
23956 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
23957 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
23958 
      return
23959 
    iprot.readStructBegin()
23960 
    while True:
23961 
      (fname, ftype, fid) = iprot.readFieldBegin()
23962 
      if ftype == TType.STOP:
23963 
        break
23964 
      else:
23965 
        iprot.skip(ftype)
23966 
      iprot.readFieldEnd()
23967 
    iprot.readStructEnd()
23968 
 
23969 
  def write(self, oprot):
23970 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
23971 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
23972 
      return
23973 
    oprot.writeStructBegin('getRefundedOrdersMarkedPaid_args')
23974 
    oprot.writeFieldStop()
23975 
    oprot.writeStructEnd()
23976 
 
23977 
  def validate(self):
23978 
    return
23979 
 
23980 
 
23981 
  def __repr__(self):
23982 
    L = ['%s=%r' % (key, value)
23983 
      for key, value in self.__dict__.iteritems()]
23984 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
23985 
 
23986 
  def __eq__(self, other):
23987 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
23988 
 
23989 
  def __ne__(self, other):
23990 
    return not (self == other)
23991 
 
23992 
class getRefundedOrdersMarkedPaid_result:
23993 
  """
23994 
  Attributes:
23995 
   - success
23996 
   - ex
23997 
  """
23998 
 
23999 
  thrift_spec = (
24000 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
24001 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
24002 
  )
24003 
 
24004 
  def __init__(self, success=None, ex=None,):
24005 
    self.success = success
24006 
    self.ex = ex
24007 
 
24008 
  def read(self, iprot):
24009 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
24010 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
24011 
      return
24012 
    iprot.readStructBegin()
24013 
    while True:
24014 
      (fname, ftype, fid) = iprot.readFieldBegin()
24015 
      if ftype == TType.STOP:
24016 
        break
24017 
      if fid == 0:
24018 
        if ftype == TType.LIST:
24019 
          self.success = []
5713 rajveer 24020 
          (_etype567, _size564) = iprot.readListBegin()
24021 
          for _i568 in xrange(_size564):
24022 
            _elem569 = Order()
24023 
            _elem569.read(iprot)
24024 
            self.success.append(_elem569)
5208 varun.gupt 24025 
          iprot.readListEnd()
24026 
        else:
24027 
          iprot.skip(ftype)
24028 
      elif fid == 1:
24029 
        if ftype == TType.STRUCT:
24030 
          self.ex = TransactionServiceException()
24031 
          self.ex.read(iprot)
24032 
        else:
24033 
          iprot.skip(ftype)
24034 
      else:
24035 
        iprot.skip(ftype)
24036 
      iprot.readFieldEnd()
24037 
    iprot.readStructEnd()
24038 
 
24039 
  def write(self, oprot):
24040 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
24041 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
24042 
      return
24043 
    oprot.writeStructBegin('getRefundedOrdersMarkedPaid_result')
24044 
    if self.success is not None:
24045 
      oprot.writeFieldBegin('success', TType.LIST, 0)
24046 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
5713 rajveer 24047 
      for iter570 in self.success:
24048 
        iter570.write(oprot)
5208 varun.gupt 24049 
      oprot.writeListEnd()
24050 
      oprot.writeFieldEnd()
24051 
    if self.ex is not None:
24052 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
24053 
      self.ex.write(oprot)
24054 
      oprot.writeFieldEnd()
24055 
    oprot.writeFieldStop()
24056 
    oprot.writeStructEnd()
24057 
 
24058 
  def validate(self):
24059 
    return
24060 
 
24061 
 
24062 
  def __repr__(self):
24063 
    L = ['%s=%r' % (key, value)
24064 
      for key, value in self.__dict__.iteritems()]
24065 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
24066 
 
24067 
  def __eq__(self, other):
24068 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
24069 
 
24070 
  def __ne__(self, other):
24071 
    return not (self == other)
5447 anupam.sin 24072 
 
24073 
class getAllVerificationAgents_args:
24074 
  """
24075 
  Attributes:
24076 
   - minOrderId
24077 
   - maxOrderId
24078 
  """
24079 
 
24080 
  thrift_spec = (
24081 
    None, # 0
24082 
    (1, TType.I64, 'minOrderId', None, None, ), # 1
24083 
    (2, TType.I64, 'maxOrderId', None, None, ), # 2
24084 
  )
24085 
 
24086 
  def __init__(self, minOrderId=None, maxOrderId=None,):
24087 
    self.minOrderId = minOrderId
24088 
    self.maxOrderId = maxOrderId
24089 
 
24090 
  def read(self, iprot):
24091 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
24092 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
24093 
      return
24094 
    iprot.readStructBegin()
24095 
    while True:
24096 
      (fname, ftype, fid) = iprot.readFieldBegin()
24097 
      if ftype == TType.STOP:
24098 
        break
24099 
      if fid == 1:
24100 
        if ftype == TType.I64:
24101 
          self.minOrderId = iprot.readI64();
24102 
        else:
24103 
          iprot.skip(ftype)
24104 
      elif fid == 2:
24105 
        if ftype == TType.I64:
24106 
          self.maxOrderId = iprot.readI64();
24107 
        else:
24108 
          iprot.skip(ftype)
24109 
      else:
24110 
        iprot.skip(ftype)
24111 
      iprot.readFieldEnd()
24112 
    iprot.readStructEnd()
24113 
 
24114 
  def write(self, oprot):
24115 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
24116 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
24117 
      return
24118 
    oprot.writeStructBegin('getAllVerificationAgents_args')
24119 
    if self.minOrderId is not None:
24120 
      oprot.writeFieldBegin('minOrderId', TType.I64, 1)
24121 
      oprot.writeI64(self.minOrderId)
24122 
      oprot.writeFieldEnd()
24123 
    if self.maxOrderId is not None:
24124 
      oprot.writeFieldBegin('maxOrderId', TType.I64, 2)
24125 
      oprot.writeI64(self.maxOrderId)
24126 
      oprot.writeFieldEnd()
24127 
    oprot.writeFieldStop()
24128 
    oprot.writeStructEnd()
24129 
 
24130 
  def validate(self):
24131 
    return
24132 
 
24133 
 
24134 
  def __repr__(self):
24135 
    L = ['%s=%r' % (key, value)
24136 
      for key, value in self.__dict__.iteritems()]
24137 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
24138 
 
24139 
  def __eq__(self, other):
24140 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
24141 
 
24142 
  def __ne__(self, other):
24143 
    return not (self == other)
24144 
 
24145 
class getAllVerificationAgents_result:
24146 
  """
24147 
  Attributes:
24148 
   - success
24149 
  """
24150 
 
24151 
  thrift_spec = (
24152 
    (0, TType.LIST, 'success', (TType.STRUCT,(CODVerificationAgent, CODVerificationAgent.thrift_spec)), None, ), # 0
24153 
  )
24154 
 
24155 
  def __init__(self, success=None,):
24156 
    self.success = success
24157 
 
24158 
  def read(self, iprot):
24159 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
24160 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
24161 
      return
24162 
    iprot.readStructBegin()
24163 
    while True:
24164 
      (fname, ftype, fid) = iprot.readFieldBegin()
24165 
      if ftype == TType.STOP:
24166 
        break
24167 
      if fid == 0:
24168 
        if ftype == TType.LIST:
24169 
          self.success = []
5713 rajveer 24170 
          (_etype574, _size571) = iprot.readListBegin()
24171 
          for _i575 in xrange(_size571):
24172 
            _elem576 = CODVerificationAgent()
24173 
            _elem576.read(iprot)
24174 
            self.success.append(_elem576)
5447 anupam.sin 24175 
          iprot.readListEnd()
24176 
        else:
24177 
          iprot.skip(ftype)
24178 
      else:
24179 
        iprot.skip(ftype)
24180 
      iprot.readFieldEnd()
24181 
    iprot.readStructEnd()
24182 
 
24183 
  def write(self, oprot):
24184 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
24185 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
24186 
      return
24187 
    oprot.writeStructBegin('getAllVerificationAgents_result')
24188 
    if self.success is not None:
24189 
      oprot.writeFieldBegin('success', TType.LIST, 0)
24190 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
5713 rajveer 24191 
      for iter577 in self.success:
24192 
        iter577.write(oprot)
5447 anupam.sin 24193 
      oprot.writeListEnd()
24194 
      oprot.writeFieldEnd()
24195 
    oprot.writeFieldStop()
24196 
    oprot.writeStructEnd()
24197 
 
24198 
  def validate(self):
24199 
    return
24200 
 
24201 
 
24202 
  def __repr__(self):
24203 
    L = ['%s=%r' % (key, value)
24204 
      for key, value in self.__dict__.iteritems()]
24205 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
24206 
 
24207 
  def __eq__(self, other):
24208 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
24209 
 
24210 
  def __ne__(self, other):
24211 
    return not (self == other)
5527 anupam.sin 24212 
 
24213 
class getAllAttributesForOrderId_args:
24214 
  """
24215 
  Attributes:
24216 
   - orderId
24217 
  """
24218 
 
24219 
  thrift_spec = (
24220 
    None, # 0
24221 
    (1, TType.I64, 'orderId', None, None, ), # 1
24222 
  )
24223 
 
24224 
  def __init__(self, orderId=None,):
24225 
    self.orderId = orderId
24226 
 
24227 
  def read(self, iprot):
24228 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
24229 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
24230 
      return
24231 
    iprot.readStructBegin()
24232 
    while True:
24233 
      (fname, ftype, fid) = iprot.readFieldBegin()
24234 
      if ftype == TType.STOP:
24235 
        break
24236 
      if fid == 1:
24237 
        if ftype == TType.I64:
24238 
          self.orderId = iprot.readI64();
24239 
        else:
24240 
          iprot.skip(ftype)
24241 
      else:
24242 
        iprot.skip(ftype)
24243 
      iprot.readFieldEnd()
24244 
    iprot.readStructEnd()
24245 
 
24246 
  def write(self, oprot):
24247 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
24248 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
24249 
      return
24250 
    oprot.writeStructBegin('getAllAttributesForOrderId_args')
24251 
    if self.orderId is not None:
24252 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
24253 
      oprot.writeI64(self.orderId)
24254 
      oprot.writeFieldEnd()
24255 
    oprot.writeFieldStop()
24256 
    oprot.writeStructEnd()
24257 
 
24258 
  def validate(self):
24259 
    return
24260 
 
24261 
 
24262 
  def __repr__(self):
24263 
    L = ['%s=%r' % (key, value)
24264 
      for key, value in self.__dict__.iteritems()]
24265 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
24266 
 
24267 
  def __eq__(self, other):
24268 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
24269 
 
24270 
  def __ne__(self, other):
24271 
    return not (self == other)
24272 
 
24273 
class getAllAttributesForOrderId_result:
24274 
  """
24275 
  Attributes:
24276 
   - success
24277 
  """
24278 
 
24279 
  thrift_spec = (
24280 
    (0, TType.LIST, 'success', (TType.STRUCT,(Attribute, Attribute.thrift_spec)), None, ), # 0
24281 
  )
24282 
 
24283 
  def __init__(self, success=None,):
24284 
    self.success = success
24285 
 
24286 
  def read(self, iprot):
24287 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
24288 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
24289 
      return
24290 
    iprot.readStructBegin()
24291 
    while True:
24292 
      (fname, ftype, fid) = iprot.readFieldBegin()
24293 
      if ftype == TType.STOP:
24294 
        break
24295 
      if fid == 0:
24296 
        if ftype == TType.LIST:
24297 
          self.success = []
5713 rajveer 24298 
          (_etype581, _size578) = iprot.readListBegin()
24299 
          for _i582 in xrange(_size578):
24300 
            _elem583 = Attribute()
24301 
            _elem583.read(iprot)
24302 
            self.success.append(_elem583)
5527 anupam.sin 24303 
          iprot.readListEnd()
24304 
        else:
24305 
          iprot.skip(ftype)
24306 
      else:
24307 
        iprot.skip(ftype)
24308 
      iprot.readFieldEnd()
24309 
    iprot.readStructEnd()
24310 
 
24311 
  def write(self, oprot):
24312 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
24313 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
24314 
      return
24315 
    oprot.writeStructBegin('getAllAttributesForOrderId_result')
24316 
    if self.success is not None:
24317 
      oprot.writeFieldBegin('success', TType.LIST, 0)
24318 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
5713 rajveer 24319 
      for iter584 in self.success:
24320 
        iter584.write(oprot)
5527 anupam.sin 24321 
      oprot.writeListEnd()
24322 
      oprot.writeFieldEnd()
24323 
    oprot.writeFieldStop()
24324 
    oprot.writeStructEnd()
24325 
 
24326 
  def validate(self):
24327 
    return
24328 
 
24329 
 
24330 
  def __repr__(self):
24331 
    L = ['%s=%r' % (key, value)
24332 
      for key, value in self.__dict__.iteritems()]
24333 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
24334 
 
24335 
  def __eq__(self, other):
24336 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
24337 
 
24338 
  def __ne__(self, other):
24339 
    return not (self == other)
24340 
 
5676 rajveer 24341 
class setOrderAttributes_args:
24342 
  """
24343 
  Attributes:
24344 
   - orderId
24345 
   - attributes
24346 
  """
24347 
 
24348 
  thrift_spec = None
24349 
  def __init__(self, orderId=None, attributes=None,):
24350 
    self.orderId = orderId
24351 
    self.attributes = attributes
24352 
 
24353 
  def read(self, iprot):
24354 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
24355 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
24356 
      return
24357 
    iprot.readStructBegin()
24358 
    while True:
24359 
      (fname, ftype, fid) = iprot.readFieldBegin()
24360 
      if ftype == TType.STOP:
24361 
        break
24362 
      if fid == 1:
24363 
        if ftype == TType.I64:
24364 
          self.orderId = iprot.readI64();
24365 
        else:
24366 
          iprot.skip(ftype)
24367 
      elif fid == -1:
24368 
        if ftype == TType.LIST:
24369 
          self.attributes = []
5713 rajveer 24370 
          (_etype588, _size585) = iprot.readListBegin()
24371 
          for _i589 in xrange(_size585):
24372 
            _elem590 = Attribute()
24373 
            _elem590.read(iprot)
24374 
            self.attributes.append(_elem590)
5676 rajveer 24375 
          iprot.readListEnd()
24376 
        else:
24377 
          iprot.skip(ftype)
24378 
      else:
24379 
        iprot.skip(ftype)
24380 
      iprot.readFieldEnd()
24381 
    iprot.readStructEnd()
24382 
 
24383 
  def write(self, oprot):
24384 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
24385 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
24386 
      return
24387 
    oprot.writeStructBegin('setOrderAttributes_args')
24388 
    if self.attributes is not None:
24389 
      oprot.writeFieldBegin('attributes', TType.LIST, -1)
24390 
      oprot.writeListBegin(TType.STRUCT, len(self.attributes))
5713 rajveer 24391 
      for iter591 in self.attributes:
24392 
        iter591.write(oprot)
5676 rajveer 24393 
      oprot.writeListEnd()
24394 
      oprot.writeFieldEnd()
24395 
    if self.orderId is not None:
24396 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
24397 
      oprot.writeI64(self.orderId)
24398 
      oprot.writeFieldEnd()
24399 
    oprot.writeFieldStop()
24400 
    oprot.writeStructEnd()
24401 
 
24402 
  def validate(self):
24403 
    return
24404 
 
24405 
 
24406 
  def __repr__(self):
24407 
    L = ['%s=%r' % (key, value)
24408 
      for key, value in self.__dict__.iteritems()]
24409 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
24410 
 
24411 
  def __eq__(self, other):
24412 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
24413 
 
24414 
  def __ne__(self, other):
24415 
    return not (self == other)
24416 
 
24417 
class setOrderAttributes_result:
24418 
 
24419 
  thrift_spec = (
24420 
  )
24421 
 
24422 
  def read(self, iprot):
24423 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
24424 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
24425 
      return
24426 
    iprot.readStructBegin()
24427 
    while True:
24428 
      (fname, ftype, fid) = iprot.readFieldBegin()
24429 
      if ftype == TType.STOP:
24430 
        break
24431 
      else:
24432 
        iprot.skip(ftype)
24433 
      iprot.readFieldEnd()
24434 
    iprot.readStructEnd()
24435 
 
24436 
  def write(self, oprot):
24437 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
24438 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
24439 
      return
24440 
    oprot.writeStructBegin('setOrderAttributes_result')
24441 
    oprot.writeFieldStop()
24442 
    oprot.writeStructEnd()
24443 
 
24444 
  def validate(self):
24445 
    return
24446 
 
24447 
 
24448 
  def __repr__(self):
24449 
    L = ['%s=%r' % (key, value)
24450 
      for key, value in self.__dict__.iteritems()]
24451 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
24452 
 
24453 
  def __eq__(self, other):
24454 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
24455 
 
24456 
  def __ne__(self, other):
24457 
    return not (self == other)
24458 
 
5527 anupam.sin 24459 
class setOrderAttributeForTransaction_args:
24460 
  """
24461 
  Attributes:
24462 
   - transactionId
24463 
   - attribute
24464 
  """
24465 
 
24466 
  thrift_spec = None
24467 
  def __init__(self, transactionId=None, attribute=None,):
24468 
    self.transactionId = transactionId
24469 
    self.attribute = attribute
24470 
 
24471 
  def read(self, iprot):
24472 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
24473 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
24474 
      return
24475 
    iprot.readStructBegin()
24476 
    while True:
24477 
      (fname, ftype, fid) = iprot.readFieldBegin()
24478 
      if ftype == TType.STOP:
24479 
        break
24480 
      if fid == 1:
24481 
        if ftype == TType.I64:
24482 
          self.transactionId = iprot.readI64();
24483 
        else:
24484 
          iprot.skip(ftype)
24485 
      elif fid == -1:
24486 
        if ftype == TType.STRUCT:
24487 
          self.attribute = Attribute()
24488 
          self.attribute.read(iprot)
24489 
        else:
24490 
          iprot.skip(ftype)
24491 
      else:
24492 
        iprot.skip(ftype)
24493 
      iprot.readFieldEnd()
24494 
    iprot.readStructEnd()
24495 
 
24496 
  def write(self, oprot):
24497 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
24498 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
24499 
      return
24500 
    oprot.writeStructBegin('setOrderAttributeForTransaction_args')
24501 
    if self.attribute is not None:
24502 
      oprot.writeFieldBegin('attribute', TType.STRUCT, -1)
24503 
      self.attribute.write(oprot)
24504 
      oprot.writeFieldEnd()
24505 
    if self.transactionId is not None:
24506 
      oprot.writeFieldBegin('transactionId', TType.I64, 1)
24507 
      oprot.writeI64(self.transactionId)
24508 
      oprot.writeFieldEnd()
24509 
    oprot.writeFieldStop()
24510 
    oprot.writeStructEnd()
24511 
 
24512 
  def validate(self):
24513 
    return
24514 
 
24515 
 
24516 
  def __repr__(self):
24517 
    L = ['%s=%r' % (key, value)
24518 
      for key, value in self.__dict__.iteritems()]
24519 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
24520 
 
24521 
  def __eq__(self, other):
24522 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
24523 
 
24524 
  def __ne__(self, other):
24525 
    return not (self == other)
24526 
 
24527 
class setOrderAttributeForTransaction_result:
24528 
 
24529 
  thrift_spec = (
24530 
  )
24531 
 
24532 
  def read(self, iprot):
24533 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
24534 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
24535 
      return
24536 
    iprot.readStructBegin()
24537 
    while True:
24538 
      (fname, ftype, fid) = iprot.readFieldBegin()
24539 
      if ftype == TType.STOP:
24540 
        break
24541 
      else:
24542 
        iprot.skip(ftype)
24543 
      iprot.readFieldEnd()
24544 
    iprot.readStructEnd()
24545 
 
24546 
  def write(self, oprot):
24547 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
24548 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
24549 
      return
24550 
    oprot.writeStructBegin('setOrderAttributeForTransaction_result')
24551 
    oprot.writeFieldStop()
24552 
    oprot.writeStructEnd()
24553 
 
24554 
  def validate(self):
24555 
    return
24556 
 
24557 
 
24558 
  def __repr__(self):
24559 
    L = ['%s=%r' % (key, value)
24560 
      for key, value in self.__dict__.iteritems()]
24561 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
24562 
 
24563 
  def __eq__(self, other):
24564 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
24565 
 
24566 
  def __ne__(self, other):
24567 
    return not (self == other)
5553 rajveer 24568 
 
24569 
class getReceivePendingOrders_args:
24570 
  """
24571 
  Attributes:
24572 
   - storeId
24573 
  """
24574 
 
24575 
  thrift_spec = (
24576 
    None, # 0
24577 
    (1, TType.I64, 'storeId', None, None, ), # 1
24578 
  )
24579 
 
24580 
  def __init__(self, storeId=None,):
24581 
    self.storeId = storeId
24582 
 
24583 
  def read(self, iprot):
24584 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
24585 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
24586 
      return
24587 
    iprot.readStructBegin()
24588 
    while True:
24589 
      (fname, ftype, fid) = iprot.readFieldBegin()
24590 
      if ftype == TType.STOP:
24591 
        break
24592 
      if fid == 1:
24593 
        if ftype == TType.I64:
24594 
          self.storeId = iprot.readI64();
24595 
        else:
24596 
          iprot.skip(ftype)
24597 
      else:
24598 
        iprot.skip(ftype)
24599 
      iprot.readFieldEnd()
24600 
    iprot.readStructEnd()
24601 
 
24602 
  def write(self, oprot):
24603 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
24604 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
24605 
      return
24606 
    oprot.writeStructBegin('getReceivePendingOrders_args')
24607 
    if self.storeId is not None:
24608 
      oprot.writeFieldBegin('storeId', TType.I64, 1)
24609 
      oprot.writeI64(self.storeId)
24610 
      oprot.writeFieldEnd()
24611 
    oprot.writeFieldStop()
24612 
    oprot.writeStructEnd()
24613 
 
24614 
  def validate(self):
24615 
    return
24616 
 
24617 
 
24618 
  def __repr__(self):
24619 
    L = ['%s=%r' % (key, value)
24620 
      for key, value in self.__dict__.iteritems()]
24621 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
24622 
 
24623 
  def __eq__(self, other):
24624 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
24625 
 
24626 
  def __ne__(self, other):
24627 
    return not (self == other)
24628 
 
24629 
class getReceivePendingOrders_result:
24630 
  """
24631 
  Attributes:
24632 
   - success
24633 
  """
24634 
 
24635 
  thrift_spec = (
24636 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
24637 
  )
24638 
 
24639 
  def __init__(self, success=None,):
24640 
    self.success = success
24641 
 
24642 
  def read(self, iprot):
24643 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
24644 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
24645 
      return
24646 
    iprot.readStructBegin()
24647 
    while True:
24648 
      (fname, ftype, fid) = iprot.readFieldBegin()
24649 
      if ftype == TType.STOP:
24650 
        break
24651 
      if fid == 0:
24652 
        if ftype == TType.LIST:
24653 
          self.success = []
5713 rajveer 24654 
          (_etype595, _size592) = iprot.readListBegin()
24655 
          for _i596 in xrange(_size592):
24656 
            _elem597 = Order()
24657 
            _elem597.read(iprot)
24658 
            self.success.append(_elem597)
5553 rajveer 24659 
          iprot.readListEnd()
24660 
        else:
24661 
          iprot.skip(ftype)
24662 
      else:
24663 
        iprot.skip(ftype)
24664 
      iprot.readFieldEnd()
24665 
    iprot.readStructEnd()
24666 
 
24667 
  def write(self, oprot):
24668 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
24669 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
24670 
      return
24671 
    oprot.writeStructBegin('getReceivePendingOrders_result')
24672 
    if self.success is not None:
24673 
      oprot.writeFieldBegin('success', TType.LIST, 0)
24674 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
5713 rajveer 24675 
      for iter598 in self.success:
24676 
        iter598.write(oprot)
5553 rajveer 24677 
      oprot.writeListEnd()
24678 
      oprot.writeFieldEnd()
24679 
    oprot.writeFieldStop()
24680 
    oprot.writeStructEnd()
24681 
 
24682 
  def validate(self):
24683 
    return
24684 
 
24685 
 
24686 
  def __repr__(self):
24687 
    L = ['%s=%r' % (key, value)
24688 
      for key, value in self.__dict__.iteritems()]
24689 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
24690 
 
24691 
  def __eq__(self, other):
24692 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
24693 
 
24694 
  def __ne__(self, other):
24695 
    return not (self == other)
24696 
 
24697 
class getReceivedAtStoreOrders_args:
24698 
  """
24699 
  Attributes:
24700 
   - storeId
24701 
  """
24702 
 
24703 
  thrift_spec = (
24704 
    None, # 0
24705 
    (1, TType.I64, 'storeId', None, None, ), # 1
24706 
  )
24707 
 
24708 
  def __init__(self, storeId=None,):
24709 
    self.storeId = storeId
24710 
 
24711 
  def read(self, iprot):
24712 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
24713 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
24714 
      return
24715 
    iprot.readStructBegin()
24716 
    while True:
24717 
      (fname, ftype, fid) = iprot.readFieldBegin()
24718 
      if ftype == TType.STOP:
24719 
        break
24720 
      if fid == 1:
24721 
        if ftype == TType.I64:
24722 
          self.storeId = iprot.readI64();
24723 
        else:
24724 
          iprot.skip(ftype)
24725 
      else:
24726 
        iprot.skip(ftype)
24727 
      iprot.readFieldEnd()
24728 
    iprot.readStructEnd()
24729 
 
24730 
  def write(self, oprot):
24731 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
24732 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
24733 
      return
24734 
    oprot.writeStructBegin('getReceivedAtStoreOrders_args')
24735 
    if self.storeId is not None:
24736 
      oprot.writeFieldBegin('storeId', TType.I64, 1)
24737 
      oprot.writeI64(self.storeId)
24738 
      oprot.writeFieldEnd()
24739 
    oprot.writeFieldStop()
24740 
    oprot.writeStructEnd()
24741 
 
24742 
  def validate(self):
24743 
    return
24744 
 
24745 
 
24746 
  def __repr__(self):
24747 
    L = ['%s=%r' % (key, value)
24748 
      for key, value in self.__dict__.iteritems()]
24749 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
24750 
 
24751 
  def __eq__(self, other):
24752 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
24753 
 
24754 
  def __ne__(self, other):
24755 
    return not (self == other)
24756 
 
24757 
class getReceivedAtStoreOrders_result:
24758 
  """
24759 
  Attributes:
24760 
   - success
24761 
  """
24762 
 
24763 
  thrift_spec = (
24764 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
24765 
  )
24766 
 
24767 
  def __init__(self, success=None,):
24768 
    self.success = success
24769 
 
24770 
  def read(self, iprot):
24771 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
24772 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
24773 
      return
24774 
    iprot.readStructBegin()
24775 
    while True:
24776 
      (fname, ftype, fid) = iprot.readFieldBegin()
24777 
      if ftype == TType.STOP:
24778 
        break
24779 
      if fid == 0:
24780 
        if ftype == TType.LIST:
24781 
          self.success = []
5713 rajveer 24782 
          (_etype602, _size599) = iprot.readListBegin()
24783 
          for _i603 in xrange(_size599):
24784 
            _elem604 = Order()
24785 
            _elem604.read(iprot)
24786 
            self.success.append(_elem604)
5553 rajveer 24787 
          iprot.readListEnd()
24788 
        else:
24789 
          iprot.skip(ftype)
24790 
      else:
24791 
        iprot.skip(ftype)
24792 
      iprot.readFieldEnd()
24793 
    iprot.readStructEnd()
24794 
 
24795 
  def write(self, oprot):
24796 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
24797 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
24798 
      return
24799 
    oprot.writeStructBegin('getReceivedAtStoreOrders_result')
24800 
    if self.success is not None:
24801 
      oprot.writeFieldBegin('success', TType.LIST, 0)
24802 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
5713 rajveer 24803 
      for iter605 in self.success:
24804 
        iter605.write(oprot)
5553 rajveer 24805 
      oprot.writeListEnd()
24806 
      oprot.writeFieldEnd()
24807 
    oprot.writeFieldStop()
24808 
    oprot.writeStructEnd()
24809 
 
24810 
  def validate(self):
24811 
    return
24812 
 
24813 
 
24814 
  def __repr__(self):
24815 
    L = ['%s=%r' % (key, value)
24816 
      for key, value in self.__dict__.iteritems()]
24817 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
24818 
 
24819 
  def __eq__(self, other):
24820 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
24821 
 
24822 
  def __ne__(self, other):
24823 
    return not (self == other)
5593 mandeep.dh 24824 
 
5713 rajveer 24825 
class getOrdersCollectionAtStore_args:
24826 
  """
24827 
  Attributes:
24828 
   - storeId
24829 
   - fromDate
24830 
   - toDate
24831 
   - onlyCod
24832 
  """
24833 
 
24834 
  thrift_spec = (
24835 
    None, # 0
24836 
    (1, TType.I64, 'storeId', None, None, ), # 1
24837 
    (2, TType.I64, 'fromDate', None, None, ), # 2
24838 
    (3, TType.I64, 'toDate', None, None, ), # 3
24839 
    (4, TType.BOOL, 'onlyCod', None, None, ), # 4
24840 
  )
24841 
 
24842 
  def __init__(self, storeId=None, fromDate=None, toDate=None, onlyCod=None,):
24843 
    self.storeId = storeId
24844 
    self.fromDate = fromDate
24845 
    self.toDate = toDate
24846 
    self.onlyCod = onlyCod
24847 
 
24848 
  def read(self, iprot):
24849 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
24850 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
24851 
      return
24852 
    iprot.readStructBegin()
24853 
    while True:
24854 
      (fname, ftype, fid) = iprot.readFieldBegin()
24855 
      if ftype == TType.STOP:
24856 
        break
24857 
      if fid == 1:
24858 
        if ftype == TType.I64:
24859 
          self.storeId = iprot.readI64();
24860 
        else:
24861 
          iprot.skip(ftype)
24862 
      elif fid == 2:
24863 
        if ftype == TType.I64:
24864 
          self.fromDate = iprot.readI64();
24865 
        else:
24866 
          iprot.skip(ftype)
24867 
      elif fid == 3:
24868 
        if ftype == TType.I64:
24869 
          self.toDate = iprot.readI64();
24870 
        else:
24871 
          iprot.skip(ftype)
24872 
      elif fid == 4:
24873 
        if ftype == TType.BOOL:
24874 
          self.onlyCod = iprot.readBool();
24875 
        else:
24876 
          iprot.skip(ftype)
24877 
      else:
24878 
        iprot.skip(ftype)
24879 
      iprot.readFieldEnd()
24880 
    iprot.readStructEnd()
24881 
 
24882 
  def write(self, oprot):
24883 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
24884 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
24885 
      return
24886 
    oprot.writeStructBegin('getOrdersCollectionAtStore_args')
24887 
    if self.storeId is not None:
24888 
      oprot.writeFieldBegin('storeId', TType.I64, 1)
24889 
      oprot.writeI64(self.storeId)
24890 
      oprot.writeFieldEnd()
24891 
    if self.fromDate is not None:
24892 
      oprot.writeFieldBegin('fromDate', TType.I64, 2)
24893 
      oprot.writeI64(self.fromDate)
24894 
      oprot.writeFieldEnd()
24895 
    if self.toDate is not None:
24896 
      oprot.writeFieldBegin('toDate', TType.I64, 3)
24897 
      oprot.writeI64(self.toDate)
24898 
      oprot.writeFieldEnd()
24899 
    if self.onlyCod is not None:
24900 
      oprot.writeFieldBegin('onlyCod', TType.BOOL, 4)
24901 
      oprot.writeBool(self.onlyCod)
24902 
      oprot.writeFieldEnd()
24903 
    oprot.writeFieldStop()
24904 
    oprot.writeStructEnd()
24905 
 
24906 
  def validate(self):
24907 
    return
24908 
 
24909 
 
24910 
  def __repr__(self):
24911 
    L = ['%s=%r' % (key, value)
24912 
      for key, value in self.__dict__.iteritems()]
24913 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
24914 
 
24915 
  def __eq__(self, other):
24916 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
24917 
 
24918 
  def __ne__(self, other):
24919 
    return not (self == other)
24920 
 
24921 
class getOrdersCollectionAtStore_result:
24922 
  """
24923 
  Attributes:
24924 
   - success
24925 
  """
24926 
 
24927 
  thrift_spec = (
24928 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
24929 
  )
24930 
 
24931 
  def __init__(self, success=None,):
24932 
    self.success = success
24933 
 
24934 
  def read(self, iprot):
24935 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
24936 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
24937 
      return
24938 
    iprot.readStructBegin()
24939 
    while True:
24940 
      (fname, ftype, fid) = iprot.readFieldBegin()
24941 
      if ftype == TType.STOP:
24942 
        break
24943 
      if fid == 0:
24944 
        if ftype == TType.LIST:
24945 
          self.success = []
24946 
          (_etype609, _size606) = iprot.readListBegin()
24947 
          for _i610 in xrange(_size606):
24948 
            _elem611 = Order()
24949 
            _elem611.read(iprot)
24950 
            self.success.append(_elem611)
24951 
          iprot.readListEnd()
24952 
        else:
24953 
          iprot.skip(ftype)
24954 
      else:
24955 
        iprot.skip(ftype)
24956 
      iprot.readFieldEnd()
24957 
    iprot.readStructEnd()
24958 
 
24959 
  def write(self, oprot):
24960 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
24961 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
24962 
      return
24963 
    oprot.writeStructBegin('getOrdersCollectionAtStore_result')
24964 
    if self.success is not None:
24965 
      oprot.writeFieldBegin('success', TType.LIST, 0)
24966 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
24967 
      for iter612 in self.success:
24968 
        iter612.write(oprot)
24969 
      oprot.writeListEnd()
24970 
      oprot.writeFieldEnd()
24971 
    oprot.writeFieldStop()
24972 
    oprot.writeStructEnd()
24973 
 
24974 
  def validate(self):
24975 
    return
24976 
 
24977 
 
24978 
  def __repr__(self):
24979 
    L = ['%s=%r' % (key, value)
24980 
      for key, value in self.__dict__.iteritems()]
24981 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
24982 
 
24983 
  def __eq__(self, other):
24984 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
24985 
 
24986 
  def __ne__(self, other):
24987 
    return not (self == other)
24988 
 
5833 rajveer 24989 
class getOrderAttributeValue_args:
24990 
  """
24991 
  Attributes:
24992 
   - orderId
24993 
   - attributeName
24994 
  """
24995 
 
24996 
  thrift_spec = None
24997 
  def __init__(self, orderId=None, attributeName=None,):
24998 
    self.orderId = orderId
24999 
    self.attributeName = attributeName
25000 
 
25001 
  def read(self, iprot):
25002 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
25003 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
25004 
      return
25005 
    iprot.readStructBegin()
25006 
    while True:
25007 
      (fname, ftype, fid) = iprot.readFieldBegin()
25008 
      if ftype == TType.STOP:
25009 
        break
25010 
      if fid == 1:
25011 
        if ftype == TType.I64:
25012 
          self.orderId = iprot.readI64();
25013 
        else:
25014 
          iprot.skip(ftype)
25015 
      elif fid == -1:
25016 
        if ftype == TType.STRING:
25017 
          self.attributeName = iprot.readString();
25018 
        else:
25019 
          iprot.skip(ftype)
25020 
      else:
25021 
        iprot.skip(ftype)
25022 
      iprot.readFieldEnd()
25023 
    iprot.readStructEnd()
25024 
 
25025 
  def write(self, oprot):
25026 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
25027 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
25028 
      return
25029 
    oprot.writeStructBegin('getOrderAttributeValue_args')
25030 
    if self.attributeName is not None:
25031 
      oprot.writeFieldBegin('attributeName', TType.STRING, -1)
25032 
      oprot.writeString(self.attributeName)
25033 
      oprot.writeFieldEnd()
25034 
    if self.orderId is not None:
25035 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
25036 
      oprot.writeI64(self.orderId)
25037 
      oprot.writeFieldEnd()
25038 
    oprot.writeFieldStop()
25039 
    oprot.writeStructEnd()
25040 
 
25041 
  def validate(self):
25042 
    return
25043 
 
25044 
 
25045 
  def __repr__(self):
25046 
    L = ['%s=%r' % (key, value)
25047 
      for key, value in self.__dict__.iteritems()]
25048 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
25049 
 
25050 
  def __eq__(self, other):
25051 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
25052 
 
25053 
  def __ne__(self, other):
25054 
    return not (self == other)
25055 
 
25056 
class getOrderAttributeValue_result:
25057 
  """
25058 
  Attributes:
25059 
   - success
25060 
  """
25061 
 
25062 
  thrift_spec = (
25063 
    (0, TType.STRING, 'success', None, None, ), # 0
25064 
  )
25065 
 
25066 
  def __init__(self, success=None,):
25067 
    self.success = success
25068 
 
25069 
  def read(self, iprot):
25070 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
25071 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
25072 
      return
25073 
    iprot.readStructBegin()
25074 
    while True:
25075 
      (fname, ftype, fid) = iprot.readFieldBegin()
25076 
      if ftype == TType.STOP:
25077 
        break
25078 
      if fid == 0:
25079 
        if ftype == TType.STRING:
25080 
          self.success = iprot.readString();
25081 
        else:
25082 
          iprot.skip(ftype)
25083 
      else:
25084 
        iprot.skip(ftype)
25085 
      iprot.readFieldEnd()
25086 
    iprot.readStructEnd()
25087 
 
25088 
  def write(self, oprot):
25089 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
25090 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
25091 
      return
25092 
    oprot.writeStructBegin('getOrderAttributeValue_result')
25093 
    if self.success is not None:
25094 
      oprot.writeFieldBegin('success', TType.STRING, 0)
25095 
      oprot.writeString(self.success)
25096 
      oprot.writeFieldEnd()
25097 
    oprot.writeFieldStop()
25098 
    oprot.writeStructEnd()
25099 
 
25100 
  def validate(self):
25101 
    return
25102 
 
25103 
 
25104 
  def __repr__(self):
25105 
    L = ['%s=%r' % (key, value)
25106 
      for key, value in self.__dict__.iteritems()]
25107 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
25108 
 
25109 
  def __eq__(self, other):
25110 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
25111 
 
25112 
  def __ne__(self, other):
25113 
    return not (self == other)
25114 
 
5593 mandeep.dh 25115 
class acceptOrderForItem_args:
25116 
  """
25117 
  Attributes:
25118 
   - itemId
25119 
   - quantity
25120 
   - fulfilmentWarehouseId
25121 
   - billingWarehouseId
25122 
  """
25123 
 
25124 
  thrift_spec = (
25125 
    None, # 0
25126 
    (1, TType.I64, 'itemId', None, None, ), # 1
25127 
    (2, TType.I64, 'quantity', None, None, ), # 2
25128 
    (3, TType.I64, 'fulfilmentWarehouseId', None, None, ), # 3
25129 
    (4, TType.I64, 'billingWarehouseId', None, None, ), # 4
25130 
  )
25131 
 
25132 
  def __init__(self, itemId=None, quantity=None, fulfilmentWarehouseId=None, billingWarehouseId=None,):
25133 
    self.itemId = itemId
25134 
    self.quantity = quantity
25135 
    self.fulfilmentWarehouseId = fulfilmentWarehouseId
25136 
    self.billingWarehouseId = billingWarehouseId
25137 
 
25138 
  def read(self, iprot):
25139 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
25140 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
25141 
      return
25142 
    iprot.readStructBegin()
25143 
    while True:
25144 
      (fname, ftype, fid) = iprot.readFieldBegin()
25145 
      if ftype == TType.STOP:
25146 
        break
25147 
      if fid == 1:
25148 
        if ftype == TType.I64:
25149 
          self.itemId = iprot.readI64();
25150 
        else:
25151 
          iprot.skip(ftype)
25152 
      elif fid == 2:
25153 
        if ftype == TType.I64:
25154 
          self.quantity = iprot.readI64();
25155 
        else:
25156 
          iprot.skip(ftype)
25157 
      elif fid == 3:
25158 
        if ftype == TType.I64:
25159 
          self.fulfilmentWarehouseId = iprot.readI64();
25160 
        else:
25161 
          iprot.skip(ftype)
25162 
      elif fid == 4:
25163 
        if ftype == TType.I64:
25164 
          self.billingWarehouseId = iprot.readI64();
25165 
        else:
25166 
          iprot.skip(ftype)
25167 
      else:
25168 
        iprot.skip(ftype)
25169 
      iprot.readFieldEnd()
25170 
    iprot.readStructEnd()
25171 
 
25172 
  def write(self, oprot):
25173 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
25174 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
25175 
      return
25176 
    oprot.writeStructBegin('acceptOrderForItem_args')
25177 
    if self.itemId is not None:
25178 
      oprot.writeFieldBegin('itemId', TType.I64, 1)
25179 
      oprot.writeI64(self.itemId)
25180 
      oprot.writeFieldEnd()
25181 
    if self.quantity is not None:
25182 
      oprot.writeFieldBegin('quantity', TType.I64, 2)
25183 
      oprot.writeI64(self.quantity)
25184 
      oprot.writeFieldEnd()
25185 
    if self.fulfilmentWarehouseId is not None:
25186 
      oprot.writeFieldBegin('fulfilmentWarehouseId', TType.I64, 3)
25187 
      oprot.writeI64(self.fulfilmentWarehouseId)
25188 
      oprot.writeFieldEnd()
25189 
    if self.billingWarehouseId is not None:
25190 
      oprot.writeFieldBegin('billingWarehouseId', TType.I64, 4)
25191 
      oprot.writeI64(self.billingWarehouseId)
25192 
      oprot.writeFieldEnd()
25193 
    oprot.writeFieldStop()
25194 
    oprot.writeStructEnd()
25195 
 
25196 
  def validate(self):
25197 
    return
25198 
 
25199 
 
25200 
  def __repr__(self):
25201 
    L = ['%s=%r' % (key, value)
25202 
      for key, value in self.__dict__.iteritems()]
25203 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
25204 
 
25205 
  def __eq__(self, other):
25206 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
25207 
 
25208 
  def __ne__(self, other):
25209 
    return not (self == other)
25210 
 
25211 
class acceptOrderForItem_result:
25212 
 
25213 
  thrift_spec = (
25214 
  )
25215 
 
25216 
  def read(self, iprot):
25217 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
25218 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
25219 
      return
25220 
    iprot.readStructBegin()
25221 
    while True:
25222 
      (fname, ftype, fid) = iprot.readFieldBegin()
25223 
      if ftype == TType.STOP:
25224 
        break
25225 
      else:
25226 
        iprot.skip(ftype)
25227 
      iprot.readFieldEnd()
25228 
    iprot.readStructEnd()
25229 
 
25230 
  def write(self, oprot):
25231 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
25232 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
25233 
      return
25234 
    oprot.writeStructBegin('acceptOrderForItem_result')
25235 
    oprot.writeFieldStop()
25236 
    oprot.writeStructEnd()
25237 
 
25238 
  def validate(self):
25239 
    return
25240 
 
25241 
 
25242 
  def __repr__(self):
25243 
    L = ['%s=%r' % (key, value)
25244 
      for key, value in self.__dict__.iteritems()]
25245 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
25246 
 
25247 
  def __eq__(self, other):
25248 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
25249 
 
25250 
  def __ne__(self, other):
25251 
    return not (self == other)