Subversion Repositories SmartDukaan

Rev

Rev 5593 | Rev 5713 | 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 
 
281 
  def getValidOrders(self, limit):
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
288 
    """
289 
    pass
290 
 
1220 chandransh 291 
  def batchOrders(self, warehouseId):
292 
    """
293 
    Create a batch of all the pending orders for the given warehouse.
294 
    The returned list is orderd by created_timestamp.
295 
    If there are no pending orders, an empty list is returned.
3431 rajveer 296 
 
1220 chandransh 297 
    Parameters:
298 
     - warehouseId
299 
    """
300 
    pass
301 
 
1208 chandransh 302 
  def markOrderAsOutOfStock(self, orderId):
303 
    """
304 
    Mark the given order as out of stock. Throws an exception if the order with the given Id couldn't be found.
3431 rajveer 305 
 
1208 chandransh 306 
    Parameters:
307 
     - orderId
308 
    """
309 
    pass
310 
 
3064 chandransh 311 
  def verifyOrder(self, orderId):
759 chandransh 312 
    """
3064 chandransh 313 
    Marks the given order as SUBMITTED_FOR_PROCESSING and updates the verified
314 
    timestamp. It is intended to be used for COD orders but can be harmlessly
315 
    used for all other orders as well.
316 
    Throws an exception if no such order exists.
3431 rajveer 317 
 
759 chandransh 318 
    Parameters:
3064 chandransh 319 
     - orderId
320 
    """
321 
    pass
322 
 
323 
  def acceptOrder(self, orderId):
324 
    """
325 
    Marks the given order as ACCEPTED and updates the accepted timestamp. If the
326 
    given order is not a COD order, it also captures the payment if the same has
327 
    not been captured.
328 
    Throws an exception if no such order exists.
3431 rajveer 329 
 
3064 chandransh 330 
    Parameters:
331 
     - orderId
332 
    """
333 
    pass
334 
 
5110 mandeep.dh 335 
  def addBillingDetails(self, orderId, invoice_number, serialNumber, itemNumber, billed_by, jacketNumber, billingType, fulfilmentWarehouseId, authorize):
3064 chandransh 336 
    """
337 
    Add billing details such as the bill number and the biller to the Order.
4658 mandeep.dh 338 
    Adds jacket number, item number and Serial no. to the order. Doesn't update
3064 chandransh 339 
    the IMEI no. if a -1 is supplied.
340 
    Also, it generates an invoice number for the order, marks the order as
341 
    BILLED and sets the billing timestamp.
342 
    Returns false if it doesn't find the order with the given ID.
3431 rajveer 343 
 
3064 chandransh 344 
    Parameters:
345 
     - orderId
4283 anupam.sin 346 
     - invoice_number
4658 mandeep.dh 347 
     - serialNumber
3064 chandransh 348 
     - itemNumber
4283 anupam.sin 349 
     - billed_by
350 
     - jacketNumber
3064 chandransh 351 
     - billingType
5110 mandeep.dh 352 
     - fulfilmentWarehouseId
4763 rajveer 353 
     - authorize
3064 chandransh 354 
    """
355 
    pass
356 
 
4763 rajveer 357 
  def addInvoiceNumber(self, orderId, invoiceNumber, color):
4579 rajveer 358 
    """
359 
    Add the invoice number to the order.
360 
 
361 
    Parameters:
362 
     - orderId
363 
     - invoiceNumber
4763 rajveer 364 
     - color
4579 rajveer 365 
    """
366 
    pass
367 
 
4910 phani.kuma 368 
  def markOrdersAsShippedFromWarehouse(self, warehouseId, providerId, cod, orderIds):
3064 chandransh 369 
    """
370 
    Depending on the third parameter, marks either all prepaid or all cod orders BILLED by the
4910 phani.kuma 371 
    given warehouse and were picked up by the given provider as SHIPPED_FROM_WH.
4410 rajveer 372 
 
373 
    Parameters:
374 
     - warehouseId
375 
     - providerId
376 
     - cod
4910 phani.kuma 377 
     - orderIds
4410 rajveer 378 
    """
379 
    pass
380 
 
5676 rajveer 381 
  def markOrdersAsReturnedFromStore(self, providerId, orderIds):
382 
    """
383 
    Parameters:
384 
     - providerId
385 
     - orderIds
386 
    """
387 
    pass
388 
 
4910 phani.kuma 389 
  def markOrdersAsPickedUp(self, providerId, pickupDetails):
4410 rajveer 390 
    """
4910 phani.kuma 391 
    Marks all SHIPPED_FROM_WH orders of the previous day for a provider as SHIPPED_TO_LOGISTICS.
392 
    Raises an exception if we encounter report for an AWB number that we did not ship.
3431 rajveer 393 
 
3064 chandransh 394 
    Parameters:
759 chandransh 395 
     - providerId
4910 phani.kuma 396 
     - pickupDetails
759 chandransh 397 
    """
398 
    pass
399 
 
4910 phani.kuma 400 
  def getOrdersNotPickedUp(self, providerId):
1113 chandransh 401 
    """
402 
    Returns a list of orders that were shipped from warehouse but did not appear in the pick-up report.
3431 rajveer 403 
 
1113 chandransh 404 
    Parameters:
405 
     - providerId
406 
    """
407 
    pass
408 
 
1132 chandransh 409 
  def markOrdersAsDelivered(self, providerId, deliveredOrders):
410 
    """
411 
    Marks all orders with AWBs in the given map as delivered. Also sets the delivery timestamp and
412 
    the name of the receiver.
413 
    Raises an exception if we encounter report for an AWB number that we did not ship.
3431 rajveer 414 
 
1132 chandransh 415 
    Parameters:
416 
     - providerId
417 
     - deliveredOrders
418 
    """
419 
    pass
420 
 
4910 phani.kuma 421 
  def markAsRTOrders(self, providerId, returnedOrders):
1135 chandransh 422 
    """
4910 phani.kuma 423 
    Mark all orders with AWBs in the given map as RTO. Also sets the delivery timestamp.
1135 chandransh 424 
    Raises an exception if we encounter report for an AWB number that we did not ship.
3431 rajveer 425 
 
1135 chandransh 426 
    Parameters:
427 
     - providerId
428 
     - returnedOrders
429 
    """
430 
    pass
431 
 
4910 phani.kuma 432 
  def getRTOrders(self, providerId):
433 
    """
434 
    Returns a list of orders that were returned by courier.
435 
 
436 
    Parameters:
437 
     - providerId
438 
    """
439 
    pass
440 
 
1246 chandransh 441 
  def updateNonDeliveryReason(self, providerId, undeliveredOrders):
442 
    """
443 
    Update the status description of orders whose AWB numbers are keys of the Map.
3431 rajveer 444 
 
1246 chandransh 445 
    Parameters:
446 
     - providerId
447 
     - undeliveredOrders
448 
    """
449 
    pass
450 
 
4910 phani.kuma 451 
  def getNonDeliveredOrdersbyCourier(self, providerId):
452 
    """
453 
    Returns a list of orders that were picked up or shipped four days ago but did not get delivered.
454 
 
455 
    Parameters:
456 
     - providerId
457 
    """
458 
    pass
459 
 
460 
  def markOrdersAsLocalConnected(self, providerId, local_connected_orders):
461 
    """
462 
    Mark all orders with AWBs in the given map as local connected. Also sets the local connected timestamp.
463 
 
464 
    Parameters:
465 
     - providerId
466 
     - local_connected_orders
467 
    """
468 
    pass
469 
 
470 
  def getOrdersNotLocalConnected(self, providerId):
471 
    """
472 
    Returns a list of orders that were picked up or shipped but pending local connection.
473 
 
474 
    Parameters:
475 
     - providerId
476 
    """
477 
    pass
478 
 
479 
  def markOrdersAsDestinationCityReached(self, providerId, destination_city_reached_orders):
480 
    """
481 
    Mark all orders with AWBs in the given map as reached destination city. Also sets the reached destination timestamp.
482 
 
483 
    Parameters:
484 
     - providerId
485 
     - destination_city_reached_orders
486 
    """
487 
    pass
488 
 
489 
  def markOrdersAsFirstDeliveryAttempted(self, providerId, first_atdl_orders):
490 
    """
491 
    Mark all orders with AWBs in the given map as first delivery attempt made. Also sets the first delivery attempted timestamp.
492 
 
493 
    Parameters:
494 
     - providerId
495 
     - first_atdl_orders
496 
    """
497 
    pass
498 
 
1408 ankur.sing 499 
  def getUndeliveredOrders(self, providerId, warehouseId):
500 
    """
501 
    Returns the list of orders whose delivery time has passed but have not been
502 
    delivered yet for the given provider and warehouse. To get a complete list of
503 
    undelivered orders, pass them as -1.
504 
    Returns an empty list if no such orders exist.
3431 rajveer 505 
 
1408 ankur.sing 506 
    Parameters:
507 
     - providerId
508 
     - warehouseId
509 
    """
510 
    pass
511 
 
4783 phani.kuma 512 
  def getUndeliveredOrdersExpectedDeliveryDateNotMet(self, ):
513 
    """
514 
    Returns the list of orders whose expected delivery date has passed but have not been
515 
    delivered yet.
516 
    Returns an empty list if no such orders exist.
517 
    """
518 
    pass
519 
 
2536 chandransh 520 
  def toggleDOAFlag(self, orderId):
521 
    """
522 
    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.
523 
    Returns the final flag status.
524 
    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 525 
 
2536 chandransh 526 
    Parameters:
527 
     - orderId
528 
    """
529 
    pass
1886 ankur.sing 530 
 
4712 rajveer 531 
  def markOrderAsDelivered(self, orderId, deliveryTimestamp, receiver):
532 
    """
533 
    Parameters:
534 
     - orderId
535 
     - deliveryTimestamp
536 
     - receiver
537 
    """
538 
    pass
539 
 
5553 rajveer 540 
  def markOrderAsReceivedAtStore(self, orderId, deliveryTimestamp):
541 
    """
542 
    Parameters:
543 
     - orderId
544 
     - deliveryTimestamp
545 
    """
546 
    pass
547 
 
4454 rajveer 548 
  def markOrderDoaRequestReceived(self, orderId):
549 
    """
550 
    Once user raise the request for a DOA, order status will be changed from DELVIERY_SUCCESS to DOA_REQUEST_RECEIVED
551 
 
552 
    Parameters:
553 
     - orderId
554 
    """
555 
    pass
556 
 
557 
  def markOrderDoaRequestAuthorized(self, orderId, isAuthorized):
558 
    """
559 
    CRM person can authorize or deny the request reised by customer. If he authorizes order will change from DOA_REQUEST_RECEIVED
560 
    to DOA_REQUEST_AUTHORIZED. If he denies, status will be changed back to DELVIERY_SUCCESS.
561 
 
562 
    Parameters:
563 
     - orderId
564 
     - isAuthorized
565 
    """
566 
    pass
567 
 
4488 rajveer 568 
  def markOrderReturnRequestReceived(self, orderId):
569 
    """
570 
    Once user raise the request for a RET, order status will be changed from DELVIERY_SUCCESS to RET_REQUEST_RECEIVED
571 
 
572 
    Parameters:
573 
     - orderId
574 
    """
575 
    pass
576 
 
577 
  def markOrderReturnRequestAuthorized(self, orderId, isAuthorized):
578 
    """
579 
    CRM person can authorize or deny the request reised by customer. If he authorizes order will change from RET_REQUEST_RECEIVED
580 
    to RET_REQUEST_AUTHORIZED. If he denies, status will be changed back to DELVIERY_SUCCESS.
581 
 
582 
    Parameters:
583 
     - orderId
584 
     - isAuthorized
585 
    """
586 
    pass
587 
 
4579 rajveer 588 
  def requestPickupNumber(self, orderId, providerId):
2536 chandransh 589 
    """
590 
    Sends out an email to the account manager of the original courier provider used to ship the order.
4452 rajveer 591 
    If the order status was DELIVERY_SUCCESS, it is changed to be DOA_PICKUP_REQUEST_RAISED.
592 
    If the order status was DOA_PICKUP_REQUEST_RAISED, it is left unchanged.
2536 chandransh 593 
    For any other status, it returns false.
594 
    Throws an exception if the order with the given id couldn't be found.
3431 rajveer 595 
 
2536 chandransh 596 
    Parameters:
597 
     - orderId
4579 rajveer 598 
     - providerId
2536 chandransh 599 
    """
600 
    pass
601 
 
4602 rajveer 602 
  def authorizePickup(self, orderId, pickupNumber, providerId):
2536 chandransh 603 
    """
4452 rajveer 604 
    If the order status is DOA_PICKUP_REQUEST_RAISED, it does the following
2536 chandransh 605 
    	1. Sends out an email to the customer with the dispatch advice that he has to print as an attachment.
606 
    	2. Changes order status to be DOA_PICKUP_AUTHORIZED.
607 
    	3. Returns true
2591 chandransh 608 
    If the order is in any other status, it returns false.
2536 chandransh 609 
    Throws an exception if the order with the given id couldn't be found.
3431 rajveer 610 
 
2536 chandransh 611 
    Parameters:
612 
     - orderId
613 
     - pickupNumber
4602 rajveer 614 
     - providerId
2536 chandransh 615 
    """
616 
    pass
617 
 
2764 chandransh 618 
  def markDoasAsPickedUp(self, providerId, pickupDetails):
619 
    """
620 
    Marks all DOA_PICKUP_AUTHORIZED orders of the previous day for a provider as DOA_RETURN_IN_TRANSIT.
3431 rajveer 621 
 
2764 chandransh 622 
    Parameters:
623 
     - providerId
624 
     - pickupDetails
625 
    """
626 
    pass
627 
 
4910 phani.kuma 628 
  def getDoasNotPickedUp(self, providerId):
629 
    """
630 
    Returns a list of orders that were authorized for pickup but did not appear in the pick-up report.
631 
 
632 
    Parameters:
633 
     - providerId
634 
    """
635 
    pass
636 
 
4741 phani.kuma 637 
  def markReturnOrdersAsPickedUp(self, providerId, pickupDetails):
638 
    """
639 
    Marks all RET_PICKUP_CONFIRMED orders of the previous day for a provider as RET_RETURN_IN_TRANSIT.
640 
 
641 
    Parameters:
642 
     - providerId
643 
     - pickupDetails
644 
    """
645 
    pass
646 
 
4910 phani.kuma 647 
  def getReturnOrdersNotPickedUp(self, providerId):
648 
    """
649 
    Returns a list of orders that were authorized for pickup but did not appear in the pick-up report.
650 
 
651 
    Parameters:
652 
     - providerId
653 
    """
654 
    pass
655 
 
4479 rajveer 656 
  def receiveReturn(self, orderId, receiveCondition):
2591 chandransh 657 
    """
4452 rajveer 658 
    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 659 
    If the order status is RTO_IN_TRANSIT, marks the order status as RTO_RECEIVED_PRESTINE and returns true.
2591 chandransh 660 
    If the order is in any other state, it returns false.
661 
    Throws an exception if the order with the given id couldn't be found.
3431 rajveer 662 
 
2591 chandransh 663 
    Parameters:
664 
     - orderId
4479 rajveer 665 
     - receiveCondition
2591 chandransh 666 
    """
667 
    pass
2536 chandransh 668 
 
2591 chandransh 669 
  def validateDoa(self, orderId, isValid):
670 
    """
4452 rajveer 671 
    Used to validate the DOA certificate for an order in the DOA_RECEIVED_PRESTINE state. If the certificate is valid,
2616 chandransh 672 
    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 673 
    If the order is in any other state, it returns false.
674 
    Throws an exception if the order with the given id couldn't be found.
3431 rajveer 675 
 
2591 chandransh 676 
    Parameters:
677 
     - orderId
678 
     - isValid
679 
    """
680 
    pass
681 
 
4495 rajveer 682 
  def validateReturnProduct(self, orderId, isUsable):
683 
    """
684 
    Parameters:
685 
     - orderId
686 
     - isUsable
687 
    """
688 
    pass
689 
 
2616 chandransh 690 
  def reshipOrder(self, orderId):
691 
    """
4484 rajveer 692 
    If the order is in RTO_RECEIVED_PRESTINE or DOA_CERT_INVALID state, it does the following:
2616 chandransh 693 
    	1. Creates a new order for processing in the BILLED state. All billing information is saved.
4484 rajveer 694 
    	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 695 
 
696 
    If the order is in DOA_CERT_VALID state, it does the following:
697 
    	1. Creates a new order for processing in the SUBMITTED_FOR_PROCESSING state.
698 
    	2. Creates a return order for the warehouse executive to return the DOA material.
4452 rajveer 699 
    	3. Marks the current order as the final DOA_VALID_RESHIPPED state.
3431 rajveer 700 
 
2616 chandransh 701 
    Returns the id of the newly created order.
3431 rajveer 702 
 
2616 chandransh 703 
    Throws an exception if the order with the given id couldn't be found.
3431 rajveer 704 
 
2616 chandransh 705 
    Parameters:
706 
     - orderId
707 
    """
708 
    pass
2591 chandransh 709 
 
3226 chandransh 710 
  def refundOrder(self, orderId, refundedBy, reason):
2616 chandransh 711 
    """
4484 rajveer 712 
    If the order is in RTO_RECEIVED_PRESTINE, DOA_CERT_VALID or DOA_CERT_INVALID state, it does the following:
2616 chandransh 713 
    	1. Creates a refund request for batch processing.
714 
    	2. Creates a return order for the warehouse executive to return the shipped material.
4484 rajveer 715 
    	3. Marks the current order as RTO_REFUNDED, DOA_VALID_REFUNDED or DOA_INVALID_REFUNDED final states.
3431 rajveer 716 
 
2616 chandransh 717 
    If the order is in SUBMITTED_FOR_PROCESSING or INVENTORY_LOW state, it does the following:
718 
    	1. Creates a refund request for batch processing.
3226 chandransh 719 
    	2. Cancels the reservation of the item in the warehouse.
720 
    	3. Marks the current order as the REFUNDED final state.
3431 rajveer 721 
 
3226 chandransh 722 
    For all COD orders, if the order is in INIT, SUBMITTED_FOR_PROCESSING or INVENTORY_LOW state, it does the following:
723 
    	1. Cancels the reservation of the item in the warehouse.
724 
    	2. Marks the current order as CANCELED.
725 
 
726 
    In all cases, it updates the reason for cancellation or refund and the person who performed the action.
727 
 
2616 chandransh 728 
    Returns True if it is successful, False otherwise.
3431 rajveer 729 
 
2616 chandransh 730 
    Throws an exception if the order with the given id couldn't be found.
3431 rajveer 731 
 
2616 chandransh 732 
    Parameters:
733 
     - orderId
3226 chandransh 734 
     - refundedBy
735 
     - reason
2616 chandransh 736 
    """
737 
    pass
738 
 
2690 chandransh 739 
  def getReturnOrders(self, warehouseId, fromDate, toDate):
740 
    """
741 
    Get all return orders created between the from and to dates for the given warehouse.
742 
    Ignores the warehouse if it is passed as -1.
3431 rajveer 743 
 
2690 chandransh 744 
    Parameters:
745 
     - warehouseId
746 
     - fromDate
747 
     - toDate
748 
    """
749 
    pass
2616 chandransh 750 
 
5481 phani.kuma 751 
  def getAllReturnOrders(self, onlyNotProcessed, fromDate, toDate):
752 
    """
753 
    Get all return orders created between the from and to dates.
754 
 
755 
    Parameters:
756 
     - onlyNotProcessed
757 
     - fromDate
758 
     - toDate
759 
    """
760 
    pass
761 
 
2700 chandransh 762 
  def getReturnOrder(self, id):
763 
    """
764 
    Returns the ReturnOrder corresponding to the given id.
765 
    Throws an exception if the return order with the given id couldn't be found.
3431 rajveer 766 
 
2700 chandransh 767 
    Parameters:
768 
     - id
769 
    """
770 
    pass
771 
 
2690 chandransh 772 
  def processReturn(self, returnOrderId):
773 
    """
774 
    Marks the return order with the given id as processed. Raises an exception if no such return order exists.
3431 rajveer 775 
 
2690 chandransh 776 
    Parameters:
777 
     - returnOrderId
778 
    """
779 
    pass
780 
 
3451 chandransh 781 
  def updateWeight(self, orderId, weight):
782 
    """
783 
    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 784 
 
3451 chandransh 785 
    Parameters:
786 
     - orderId
787 
     - weight
788 
    """
789 
    pass
790 
 
3469 chandransh 791 
  def changeItem(self, orderId, itemId):
792 
    """
793 
    Change the item to be shipped for this order. Also adjusts the reservation in the inventory accordingly.
794 
    Currently, it also ensures that only a different color of the given item is shipped.
3451 chandransh 795 
 
3469 chandransh 796 
    Parameters:
797 
     - orderId
798 
     - itemId
799 
    """
800 
    pass
801 
 
802 
  def shiftToWarehouse(self, orderId, warehouseId):
803 
    """
804 
    Moves the given order to the given warehouse. Also adjusts the inventory reservations accordingly.
805 
 
806 
    Parameters:
807 
     - orderId
808 
     - warehouseId
809 
    """
810 
    pass
811 
 
4647 rajveer 812 
  def addDelayReason(self, orderId, delayReason, furtherDelay, delayReasonText):
3553 chandransh 813 
    """
814 
    Adds the given delay reason to the given order.
3986 chandransh 815 
    Increases the expected delivery time of the given order by the given no. of days.
3553 chandransh 816 
    Raises an exception if no order with the given id can be found.
3469 chandransh 817 
 
3553 chandransh 818 
    Parameters:
819 
     - orderId
820 
     - delayReason
3986 chandransh 821 
     - furtherDelay
4647 rajveer 822 
     - delayReasonText
3553 chandransh 823 
    """
824 
    pass
825 
 
3956 chandransh 826 
  def reconcileCodCollection(self, collectedAmountMap, xferBy, xferTxnId, xferDate):
827 
    """
828 
    Marks the COD orders with given AWB nos. as having been processed.
829 
    Updates the captured amount for the corresponding payment.
3553 chandransh 830 
 
3956 chandransh 831 
    Returns a map of AWBs which were not processed and the associated reason. An AWB is not processed if:
832 
    1. There is no order corresponding to an AWB number.
833 
    2. The captured amount for a payment exceeds the total payment.
834 
    3. The order corresponding to an AWB no. is in a state prior to DELIVERY_SUCCESS.
835 
 
836 
    Parameters:
837 
     - collectedAmountMap
838 
     - xferBy
839 
     - xferTxnId
840 
     - xferDate
841 
    """
842 
    pass
843 
 
4008 mandeep.dh 844 
  def getTransactionsRequiringExtraProcessing(self, category):
845 
    """
4065 mandeep.dh 846 
    Returns the list of transaction ids that require some extra processing and
4008 mandeep.dh 847 
    which belong to a particular category. This is currently used by CRM
4065 mandeep.dh 848 
    application. If no such transaction ids are present, it returns an empty list.
3956 chandransh 849 
 
4008 mandeep.dh 850 
    Parameters:
851 
     - category
852 
    """
853 
    pass
854 
 
855 
  def markTransactionAsProcessed(self, transactionId, category):
856 
    """
857 
    Marks a particular transaction as processed for a particular cateogory.
4065 mandeep.dh 858 
    It essentially deletes the transaction id record for a particular
859 
    processing type category (if present) from DB.
860 
    This is currently used by CRM application.
4008 mandeep.dh 861 
 
862 
    Parameters:
863 
     - transactionId
864 
     - category
865 
    """
866 
    pass
867 
 
4018 chandransh 868 
  def getItemWiseRiskyOrdersCount(self, ):
869 
    """
870 
    Returns a map containing the number of risky orders keyed by item id. A risky order
871 
    is defined as one whose shipping date is about to expire.
872 
    """
873 
    pass
4008 mandeep.dh 874 
 
4295 varun.gupt 875 
  def getOrdersForItemIds(self, itemIds):
876 
    """
877 
    Returns a list of all orders which have items with given id
878 
 
879 
    Parameters:
880 
     - itemIds
881 
    """
882 
    pass
883 
 
4247 rajveer 884 
  def markOrderCancellationRequestReceived(self, orderId):
885 
    """
886 
    Mark order as cancellation request received. If customer sends request of cancellation of
887 
    a particular order, this method will be called. It will just change status of the order
888 
    depending on its current status. It also records the previous status, so that we can move
889 
    back to that status if cancellation request is denied.
4018 chandransh 890 
 
4247 rajveer 891 
    Parameters:
892 
     - orderId
893 
    """
894 
    pass
895 
 
896 
  def markOrderCancellationRequestConfirmed(self, orderId):
897 
    """
898 
    If we decide to to cancel order, CRM will call this method to move the status of order to
899 
    cancellation request confirmed. After this OM will be able to cancel the order.
900 
 
901 
    Parameters:
902 
     - orderId
903 
    """
904 
    pass
905 
 
906 
  def markOrderCancellationRequestDenied(self, orderId):
907 
    """
908 
    If we decide to not to cancel order, we will move the order ro previous status.
909 
 
910 
    Parameters:
911 
     - orderId
912 
    """
913 
    pass
914 
 
4258 rajveer 915 
  def markTransactionAsPaymentFlagRemoved(self, transactionId):
4247 rajveer 916 
    """
4258 rajveer 917 
    If we and/or payment gateway has decided to accept the payment, this method needs to be called.
918 
    Changed transaction and all orders status to payment accepted.
4247 rajveer 919 
 
920 
    Parameters:
4258 rajveer 921 
     - transactionId
4247 rajveer 922 
    """
923 
    pass
924 
 
4259 anupam.sin 925 
  def refundTransaction(self, transactionId, refundedBy, reason):
926 
    """
927 
    This method is called when a flagged payment is deemed unserviceable and the corresponding orders
928 
    need to be cancelled
4247 rajveer 929 
 
4259 anupam.sin 930 
    Parameters:
931 
     - transactionId
932 
     - refundedBy
933 
     - reason
934 
    """
935 
    pass
936 
 
4324 mandeep.dh 937 
  def updateShipmentAddress(self, orderId, addressId):
938 
    """
939 
    Updates shipment address of an order. Delivery and shipping date estimates
940 
    etc. are also updated here.
941 
 
942 
    Throws TransactionServiceException in case address change is not
943 
    possible due to certain reasons such as new pincode in address is
944 
    not serviceable etc.
945 
 
946 
    Parameters:
947 
     - orderId
948 
     - addressId
949 
    """
950 
    pass
951 
 
4285 rajveer 952 
  def acceptOrdersForItemId(self, itemId, inventory):
953 
    """
954 
    Marks the orders as ACCEPTED for the given itemId and inventory. It also updates the accepted timestamp. If the
955 
    given order is not a COD order, it also captures the payment if the same has not been captured.
4259 anupam.sin 956 
 
4285 rajveer 957 
    Parameters:
958 
     - itemId
959 
     - inventory
960 
    """
961 
    pass
962 
 
4369 rajveer 963 
  def markOrdersAsPORaised(self, vendorId, itemId, quantity, estimate, isReminder):
4303 rajveer 964 
    """
965 
    Parameters:
966 
     - vendorId
967 
     - itemId
968 
     - quantity
969 
     - estimate
4369 rajveer 970 
     - isReminder
4303 rajveer 971 
    """
972 
    pass
4285 rajveer 973 
 
4369 rajveer 974 
  def markOrdersAsReversalInitiated(self, vendorId, itemId, quantity, estimate, isReminder):
4303 rajveer 975 
    """
976 
    Parameters:
977 
     - vendorId
978 
     - itemId
979 
     - quantity
980 
     - estimate
4369 rajveer 981 
     - isReminder
4303 rajveer 982 
    """
983 
    pass
984 
 
4369 rajveer 985 
  def markOrdersAsNotAvailabke(self, vendorId, itemId, quantity, estimate, isReminder):
4303 rajveer 986 
    """
987 
    Parameters:
988 
     - vendorId
989 
     - itemId
990 
     - quantity
991 
     - estimate
4369 rajveer 992 
     - isReminder
4303 rajveer 993 
    """
994 
    pass
995 
 
4369 rajveer 996 
  def markOrdersAsTimeout(self, vendorId):
997 
    """
998 
    Parameters:
999 
     - vendorId
1000 
    """
1001 
    pass
4303 rajveer 1002 
 
4662 rajveer 1003 
  def markOrderAsLostInTransit(self, orderId):
1004 
    """
1005 
    Mark order as LOST_IN_TRANSIT
1006 
 
1007 
    Parameters:
1008 
     - orderId
1009 
    """
1010 
    pass
1011 
 
4386 anupam.sin 1012 
  def getOrderForAwb(self, awb):
1013 
    """
1014 
    Returns the order corresponding to an AWB number
4369 rajveer 1015 
 
4386 anupam.sin 1016 
    Parameters:
1017 
     - awb
1018 
    """
1019 
    pass
1020 
 
4910 phani.kuma 1021 
  def getOrdersForProviderForStatus(self, logistics_provider_id, order_status_list):
4506 phani.kuma 1022 
    """
4910 phani.kuma 1023 
    Returns the order corresponding to a logistics provider id for a given list of order status
4386 anupam.sin 1024 
 
4506 phani.kuma 1025 
    Parameters:
1026 
     - logistics_provider_id
4910 phani.kuma 1027 
     - order_status_list
4506 phani.kuma 1028 
    """
1029 
    pass
1030 
 
4600 varun.gupt 1031 
  def getBilledOrdersForVendor(self, vendorId, billingDateFrom, billingDateTo):
1032 
    """
1033 
    Returns list of orders fullfiled from a certain vendor and billed in a given date range
4506 phani.kuma 1034 
 
4600 varun.gupt 1035 
    Parameters:
1036 
     - vendorId
1037 
     - billingDateFrom
1038 
     - billingDateTo
1039 
    """
1040 
    pass
1041 
 
4607 rajveer 1042 
  def getSlippedSippingDateOrders(self, ):
1043 
    pass
1044 
 
4709 rajveer 1045 
  def getCancelledOrders(self, cancelDateFrom, cancelDateTo):
1046 
    """
1047 
    Parameters:
1048 
     - cancelDateFrom
1049 
     - cancelDateTo
1050 
    """
1051 
    pass
1052 
 
4600 varun.gupt 1053 
  def saveBluedartSettlements(self, mapAWBAndAmount):
1054 
    """
1055 
    Parameters:
1056 
     - mapAWBAndAmount
1057 
    """
1058 
    pass
1059 
 
4905 varun.gupt 1060 
  def savePaymentSettlements(self, settlementDate, paymentGatewayId, referenceId, serviceTax, otherCharges, netCollection):
4600 varun.gupt 1061 
    """
1062 
    Parameters:
1063 
     - settlementDate
1064 
     - paymentGatewayId
4905 varun.gupt 1065 
     - referenceId
4600 varun.gupt 1066 
     - serviceTax
1067 
     - otherCharges
1068 
     - netCollection
1069 
    """
1070 
    pass
1071 
 
1072 
  def saveEBSSettlementSummary(self, settlementId, settlementDate, transactionDateFrom, transactionDateTo, amount):
1073 
    """
1074 
    Parameters:
1075 
     - settlementId
1076 
     - settlementDate
1077 
     - transactionDateFrom
1078 
     - transactionDateTo
1079 
     - amount
1080 
    """
1081 
    pass
1082 
 
5386 phani.kuma 1083 
  def getSettlementForPrepaid(self, referenceId, isRefund):
4600 varun.gupt 1084 
    """
1085 
    Parameters:
5189 varun.gupt 1086 
     - referenceId
1087 
     - isRefund
4600 varun.gupt 1088 
    """
1089 
    pass
1090 
 
5386 phani.kuma 1091 
  def getSettlementForCod(self, orderId, isRefund):
1092 
    """
1093 
    Parameters:
1094 
     - orderId
1095 
     - isRefund
1096 
    """
1097 
    pass
1098 
 
4600 varun.gupt 1099 
  def getEBSSettlementSummaries(self, ):
1100 
    pass
1101 
 
1102 
  def markEBSSettlementUploaded(self, settlementId):
1103 
    """
1104 
    Parameters:
1105 
     - settlementId
1106 
    """
1107 
    pass
1108 
 
1109 
  def getEBSSettlementDate(self, settlementId):
1110 
    """
1111 
    Parameters:
1112 
     - settlementId
1113 
    """
1114 
    pass
1115 
 
4715 varun.gupt 1116 
  def getSettlementsByDate(self, settlementDateFrom, settlementDateTo, isRefund):
1117 
    """
1118 
    Parameters:
1119 
     - settlementDateFrom
1120 
     - settlementDateTo
1121 
     - isRefund
1122 
    """
1123 
    pass
4600 varun.gupt 1124 
 
4715 varun.gupt 1125 
  def getReshippedOrderIds(self, orderIds):
1126 
    """
1127 
    Returns list of Order Ids, which belong to reshiped orders, shortlisted from a given list of Order Ids
1128 
 
1129 
    Parameters:
1130 
     - orderIds
1131 
    """
1132 
    pass
1133 
 
5481 phani.kuma 1134 
  def getBilledOrders(self, vendorId, onlyVendorNotPaid, billingDateFrom, billingDateTo):
4875 varun.gupt 1135 
    """
1136 
    Parameters:
1137 
     - vendorId
5481 phani.kuma 1138 
     - onlyVendorNotPaid
1139 
     - billingDateFrom
1140 
     - billingDateTo
4875 varun.gupt 1141 
    """
1142 
    pass
4757 mandeep.dh 1143 
 
5031 varun.gupt 1144 
  def getStatusDistributionOfOrders(self, startDate, endDate):
1145 
    """
1146 
    Parameters:
1147 
     - startDate
1148 
     - endDate
1149 
    """
1150 
    pass
4875 varun.gupt 1151 
 
5067 varun.gupt 1152 
  def getOrderIdsForStatus(self, status, startDatetime, endDatetime):
1153 
    """
1154 
    Parameters:
1155 
     - status
1156 
     - startDatetime
1157 
     - endDatetime
1158 
    """
1159 
    pass
5031 varun.gupt 1160 
 
5348 anupam.sin 1161 
  def updateCODAgent(self, agent, orderId):
1162 
    """
1163 
    Updates the agent who handled the COD verification call
1164 
 
1165 
    Parameters:
1166 
     - agent
1167 
     - orderId
1168 
    """
1169 
    pass
1170 
 
5099 varun.gupt 1171 
  def updateOrderAsPaidToVendor(self, orderId):
1172 
    """
1173 
    Parameters:
1174 
     - orderId
1175 
    """
1176 
    pass
5067 varun.gupt 1177 
 
5386 phani.kuma 1178 
  def updateOrderOnlyAsPaidToVendor(self, orderId):
1179 
    """
1180 
    Parameters:
1181 
     - orderId
1182 
    """
1183 
    pass
1184 
 
5208 varun.gupt 1185 
  def getRefundedOrdersMarkedPaid(self, ):
1186 
    pass
5099 varun.gupt 1187 
 
5447 anupam.sin 1188 
  def getAllVerificationAgents(self, minOrderId, maxOrderId):
1189 
    """
1190 
    gets all COD Verification Agents for all orderIds from a minId to maxId
5208 varun.gupt 1191 
 
5447 anupam.sin 1192 
 
1193 
    Parameters:
1194 
     - minOrderId
1195 
     - maxOrderId
1196 
    """
1197 
    pass
1198 
 
5527 anupam.sin 1199 
  def getAllAttributesForOrderId(self, orderId):
1200 
    """
1201 
    gets all attributes for a given orderId
5447 anupam.sin 1202 
 
5527 anupam.sin 1203 
    Parameters:
1204 
     - orderId
1205 
    """
1206 
    pass
1207 
 
5676 rajveer 1208 
  def setOrderAttributes(self, orderId, attributes):
1209 
    """
1210 
    sets attributes for an order
1211 
 
1212 
    Parameters:
1213 
     - orderId
1214 
     - attributes
1215 
    """
1216 
    pass
1217 
 
5527 anupam.sin 1218 
  def setOrderAttributeForTransaction(self, transactionId, attribute):
1219 
    """
1220 
    sets attributes for all orders in a transaction
1221 
 
1222 
    Parameters:
1223 
     - transactionId
1224 
     - attribute
1225 
    """
1226 
    pass
1227 
 
5553 rajveer 1228 
  def getReceivePendingOrders(self, storeId):
1229 
    """
1230 
    Parameters:
1231 
     - storeId
1232 
    """
1233 
    pass
5527 anupam.sin 1234 
 
5553 rajveer 1235 
  def getReceivedAtStoreOrders(self, storeId):
1236 
    """
1237 
    Parameters:
1238 
     - storeId
1239 
    """
1240 
    pass
1241 
 
5593 mandeep.dh 1242 
  def acceptOrderForItem(self, itemId, quantity, fulfilmentWarehouseId, billingWarehouseId):
1243 
    """
1244 
    Accepts appropriate order for an item in a given billingWarehouse. Usually
1245 
    invoked while scanning IN of items.
5553 rajveer 1246 
 
5593 mandeep.dh 1247 
    Parameters:
1248 
     - itemId
1249 
     - quantity
1250 
     - fulfilmentWarehouseId
1251 
     - billingWarehouseId
1252 
    """
1253 
    pass
1254 
 
1255 
 
3376 rajveer 1256 
class Client(shop2020.thriftpy.generic.GenericService.Client, Iface):
94 ashish 1257 
  def __init__(self, iprot, oprot=None):
3376 rajveer 1258 
    shop2020.thriftpy.generic.GenericService.Client.__init__(self, iprot, oprot)
94 ashish 1259 
 
1260 
  def createTransaction(self, transaction):
1261 
    """
1262 
    Parameters:
1263 
     - transaction
1264 
    """
1265 
    self.send_createTransaction(transaction)
132 ashish 1266 
    return self.recv_createTransaction()
94 ashish 1267 
 
1268 
  def send_createTransaction(self, transaction):
1269 
    self._oprot.writeMessageBegin('createTransaction', TMessageType.CALL, self._seqid)
1270 
    args = createTransaction_args()
1271 
    args.transaction = transaction
1272 
    args.write(self._oprot)
1273 
    self._oprot.writeMessageEnd()
1274 
    self._oprot.trans.flush()
1275 
 
1276 
  def recv_createTransaction(self, ):
1277 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1278 
    if mtype == TMessageType.EXCEPTION:
1279 
      x = TApplicationException()
1280 
      x.read(self._iprot)
1281 
      self._iprot.readMessageEnd()
1282 
      raise x
1283 
    result = createTransaction_result()
1284 
    result.read(self._iprot)
1285 
    self._iprot.readMessageEnd()
3431 rajveer 1286 
    if result.success is not None:
132 ashish 1287 
      return result.success
3431 rajveer 1288 
    if result.ex is not None:
94 ashish 1289 
      raise result.ex
132 ashish 1290 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "createTransaction failed: unknown result");
94 ashish 1291 
 
1292 
  def getTransaction(self, id):
1293 
    """
1294 
    Parameters:
1295 
     - id
1296 
    """
1297 
    self.send_getTransaction(id)
1298 
    return self.recv_getTransaction()
1299 
 
1300 
  def send_getTransaction(self, id):
1301 
    self._oprot.writeMessageBegin('getTransaction', TMessageType.CALL, self._seqid)
1302 
    args = getTransaction_args()
1303 
    args.id = id
1304 
    args.write(self._oprot)
1305 
    self._oprot.writeMessageEnd()
1306 
    self._oprot.trans.flush()
1307 
 
1308 
  def recv_getTransaction(self, ):
1309 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1310 
    if mtype == TMessageType.EXCEPTION:
1311 
      x = TApplicationException()
1312 
      x.read(self._iprot)
1313 
      self._iprot.readMessageEnd()
1314 
      raise x
1315 
    result = getTransaction_result()
1316 
    result.read(self._iprot)
1317 
    self._iprot.readMessageEnd()
3431 rajveer 1318 
    if result.success is not None:
94 ashish 1319 
      return result.success
3431 rajveer 1320 
    if result.ex is not None:
94 ashish 1321 
      raise result.ex
1322 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getTransaction failed: unknown result");
1323 
 
1324 
  def getTransactionsForCustomer(self, customerId, from_date, to_date, status):
1325 
    """
1326 
    Parameters:
1327 
     - customerId
1328 
     - from_date
1329 
     - to_date
1330 
     - status
1331 
    """
1332 
    self.send_getTransactionsForCustomer(customerId, from_date, to_date, status)
1333 
    return self.recv_getTransactionsForCustomer()
1334 
 
1335 
  def send_getTransactionsForCustomer(self, customerId, from_date, to_date, status):
1336 
    self._oprot.writeMessageBegin('getTransactionsForCustomer', TMessageType.CALL, self._seqid)
1337 
    args = getTransactionsForCustomer_args()
1338 
    args.customerId = customerId
1339 
    args.from_date = from_date
1340 
    args.to_date = to_date
1341 
    args.status = status
1342 
    args.write(self._oprot)
1343 
    self._oprot.writeMessageEnd()
1344 
    self._oprot.trans.flush()
1345 
 
1346 
  def recv_getTransactionsForCustomer(self, ):
1347 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1348 
    if mtype == TMessageType.EXCEPTION:
1349 
      x = TApplicationException()
1350 
      x.read(self._iprot)
1351 
      self._iprot.readMessageEnd()
1352 
      raise x
1353 
    result = getTransactionsForCustomer_result()
1354 
    result.read(self._iprot)
1355 
    self._iprot.readMessageEnd()
3431 rajveer 1356 
    if result.success is not None:
94 ashish 1357 
      return result.success
3431 rajveer 1358 
    if result.ex is not None:
94 ashish 1359 
      raise result.ex
1360 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getTransactionsForCustomer failed: unknown result");
1361 
 
132 ashish 1362 
  def getTransactionsForShoppingCartId(self, shoppingCartId):
1363 
    """
1364 
    Parameters:
1365 
     - shoppingCartId
1366 
    """
1367 
    self.send_getTransactionsForShoppingCartId(shoppingCartId)
1368 
    return self.recv_getTransactionsForShoppingCartId()
1369 
 
1370 
  def send_getTransactionsForShoppingCartId(self, shoppingCartId):
1371 
    self._oprot.writeMessageBegin('getTransactionsForShoppingCartId', TMessageType.CALL, self._seqid)
1372 
    args = getTransactionsForShoppingCartId_args()
1373 
    args.shoppingCartId = shoppingCartId
1374 
    args.write(self._oprot)
1375 
    self._oprot.writeMessageEnd()
1376 
    self._oprot.trans.flush()
1377 
 
1378 
  def recv_getTransactionsForShoppingCartId(self, ):
1379 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1380 
    if mtype == TMessageType.EXCEPTION:
1381 
      x = TApplicationException()
1382 
      x.read(self._iprot)
1383 
      self._iprot.readMessageEnd()
1384 
      raise x
1385 
    result = getTransactionsForShoppingCartId_result()
1386 
    result.read(self._iprot)
1387 
    self._iprot.readMessageEnd()
3431 rajveer 1388 
    if result.success is not None:
132 ashish 1389 
      return result.success
3431 rajveer 1390 
    if result.ex is not None:
132 ashish 1391 
      raise result.ex
1392 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getTransactionsForShoppingCartId failed: unknown result");
1393 
 
94 ashish 1394 
  def getTransactionStatus(self, transactionId):
1395 
    """
1396 
    Parameters:
1397 
     - transactionId
1398 
    """
1399 
    self.send_getTransactionStatus(transactionId)
1400 
    return self.recv_getTransactionStatus()
1401 
 
1402 
  def send_getTransactionStatus(self, transactionId):
1403 
    self._oprot.writeMessageBegin('getTransactionStatus', TMessageType.CALL, self._seqid)
1404 
    args = getTransactionStatus_args()
1405 
    args.transactionId = transactionId
1406 
    args.write(self._oprot)
1407 
    self._oprot.writeMessageEnd()
1408 
    self._oprot.trans.flush()
1409 
 
1410 
  def recv_getTransactionStatus(self, ):
1411 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1412 
    if mtype == TMessageType.EXCEPTION:
1413 
      x = TApplicationException()
1414 
      x.read(self._iprot)
1415 
      self._iprot.readMessageEnd()
1416 
      raise x
1417 
    result = getTransactionStatus_result()
1418 
    result.read(self._iprot)
1419 
    self._iprot.readMessageEnd()
3431 rajveer 1420 
    if result.success is not None:
94 ashish 1421 
      return result.success
3431 rajveer 1422 
    if result.ex is not None:
94 ashish 1423 
      raise result.ex
1424 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getTransactionStatus failed: unknown result");
1425 
 
5527 anupam.sin 1426 
  def changeTransactionStatus(self, transactionId, status, description, pickUp, orderType):
94 ashish 1427 
    """
1428 
    Parameters:
1429 
     - transactionId
1430 
     - status
1431 
     - description
5527 anupam.sin 1432 
     - pickUp
1433 
     - orderType
94 ashish 1434 
    """
5527 anupam.sin 1435 
    self.send_changeTransactionStatus(transactionId, status, description, pickUp, orderType)
94 ashish 1436 
    return self.recv_changeTransactionStatus()
1437 
 
5527 anupam.sin 1438 
  def send_changeTransactionStatus(self, transactionId, status, description, pickUp, orderType):
94 ashish 1439 
    self._oprot.writeMessageBegin('changeTransactionStatus', TMessageType.CALL, self._seqid)
1440 
    args = changeTransactionStatus_args()
1441 
    args.transactionId = transactionId
1442 
    args.status = status
1443 
    args.description = description
5527 anupam.sin 1444 
    args.pickUp = pickUp
1445 
    args.orderType = orderType
94 ashish 1446 
    args.write(self._oprot)
1447 
    self._oprot.writeMessageEnd()
1448 
    self._oprot.trans.flush()
1449 
 
1450 
  def recv_changeTransactionStatus(self, ):
1451 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1452 
    if mtype == TMessageType.EXCEPTION:
1453 
      x = TApplicationException()
1454 
      x.read(self._iprot)
1455 
      self._iprot.readMessageEnd()
1456 
      raise x
1457 
    result = changeTransactionStatus_result()
1458 
    result.read(self._iprot)
1459 
    self._iprot.readMessageEnd()
3431 rajveer 1460 
    if result.success is not None:
94 ashish 1461 
      return result.success
3431 rajveer 1462 
    if result.ex is not None:
94 ashish 1463 
      raise result.ex
1464 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "changeTransactionStatus failed: unknown result");
1465 
 
1398 varun.gupt 1466 
  def enqueueTransactionInfoEmail(self, transactionId):
1382 varun.gupt 1467 
    """
1468 
    Parameters:
1469 
     - transactionId
1470 
    """
1398 varun.gupt 1471 
    self.send_enqueueTransactionInfoEmail(transactionId)
1472 
    return self.recv_enqueueTransactionInfoEmail()
1382 varun.gupt 1473 
 
1398 varun.gupt 1474 
  def send_enqueueTransactionInfoEmail(self, transactionId):
1475 
    self._oprot.writeMessageBegin('enqueueTransactionInfoEmail', TMessageType.CALL, self._seqid)
1476 
    args = enqueueTransactionInfoEmail_args()
1382 varun.gupt 1477 
    args.transactionId = transactionId
1478 
    args.write(self._oprot)
1479 
    self._oprot.writeMessageEnd()
1480 
    self._oprot.trans.flush()
1481 
 
1398 varun.gupt 1482 
  def recv_enqueueTransactionInfoEmail(self, ):
1382 varun.gupt 1483 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1484 
    if mtype == TMessageType.EXCEPTION:
1485 
      x = TApplicationException()
1486 
      x.read(self._iprot)
1487 
      self._iprot.readMessageEnd()
1488 
      raise x
1398 varun.gupt 1489 
    result = enqueueTransactionInfoEmail_result()
1382 varun.gupt 1490 
    result.read(self._iprot)
1491 
    self._iprot.readMessageEnd()
3431 rajveer 1492 
    if result.success is not None:
1382 varun.gupt 1493 
      return result.success
3431 rajveer 1494 
    if result.ex is not None:
1382 varun.gupt 1495 
      raise result.ex
1398 varun.gupt 1496 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "enqueueTransactionInfoEmail failed: unknown result");
1382 varun.gupt 1497 
 
4801 anupam.sin 1498 
  def getAllOrders(self, statuses, from_date, to_date, warehouse_id):
94 ashish 1499 
    """
1500 
    Parameters:
4801 anupam.sin 1501 
     - statuses
483 rajveer 1502 
     - from_date
1503 
     - to_date
1504 
     - warehouse_id
94 ashish 1505 
    """
4801 anupam.sin 1506 
    self.send_getAllOrders(statuses, from_date, to_date, warehouse_id)
483 rajveer 1507 
    return self.recv_getAllOrders()
94 ashish 1508 
 
4801 anupam.sin 1509 
  def send_getAllOrders(self, statuses, from_date, to_date, warehouse_id):
483 rajveer 1510 
    self._oprot.writeMessageBegin('getAllOrders', TMessageType.CALL, self._seqid)
1511 
    args = getAllOrders_args()
4801 anupam.sin 1512 
    args.statuses = statuses
483 rajveer 1513 
    args.from_date = from_date
1514 
    args.to_date = to_date
1515 
    args.warehouse_id = warehouse_id
94 ashish 1516 
    args.write(self._oprot)
1517 
    self._oprot.writeMessageEnd()
1518 
    self._oprot.trans.flush()
1519 
 
483 rajveer 1520 
  def recv_getAllOrders(self, ):
94 ashish 1521 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1522 
    if mtype == TMessageType.EXCEPTION:
1523 
      x = TApplicationException()
1524 
      x.read(self._iprot)
1525 
      self._iprot.readMessageEnd()
1526 
      raise x
483 rajveer 1527 
    result = getAllOrders_result()
94 ashish 1528 
    result.read(self._iprot)
1529 
    self._iprot.readMessageEnd()
3431 rajveer 1530 
    if result.success is not None:
94 ashish 1531 
      return result.success
3431 rajveer 1532 
    if result.ex is not None:
94 ashish 1533 
      raise result.ex
483 rajveer 1534 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAllOrders failed: unknown result");
94 ashish 1535 
 
4133 chandransh 1536 
  def getOrdersInBatch(self, statuses, offset, limit, warehouse_id):
1537 
    """
1538 
    Returns at most 'limit' orders with the given statuses for the given warehouse starting from the given offset.
1539 
    Pass the status as null and the limit as 0 to ignore them.
1540 
 
1541 
    Parameters:
1542 
     - statuses
1543 
     - offset
1544 
     - limit
1545 
     - warehouse_id
1546 
    """
1547 
    self.send_getOrdersInBatch(statuses, offset, limit, warehouse_id)
1548 
    return self.recv_getOrdersInBatch()
1549 
 
1550 
  def send_getOrdersInBatch(self, statuses, offset, limit, warehouse_id):
1551 
    self._oprot.writeMessageBegin('getOrdersInBatch', TMessageType.CALL, self._seqid)
1552 
    args = getOrdersInBatch_args()
1553 
    args.statuses = statuses
1554 
    args.offset = offset
1555 
    args.limit = limit
1556 
    args.warehouse_id = warehouse_id
1557 
    args.write(self._oprot)
1558 
    self._oprot.writeMessageEnd()
1559 
    self._oprot.trans.flush()
1560 
 
1561 
  def recv_getOrdersInBatch(self, ):
1562 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1563 
    if mtype == TMessageType.EXCEPTION:
1564 
      x = TApplicationException()
1565 
      x.read(self._iprot)
1566 
      self._iprot.readMessageEnd()
1567 
      raise x
1568 
    result = getOrdersInBatch_result()
1569 
    result.read(self._iprot)
1570 
    self._iprot.readMessageEnd()
1571 
    if result.success is not None:
1572 
      return result.success
1573 
    if result.ex is not None:
1574 
      raise result.ex
1575 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getOrdersInBatch failed: unknown result");
1576 
 
1577 
  def getOrderCount(self, statuses, warehouseId):
1578 
    """
1579 
    Returns the count of orders with the given statuses assigned to the given warehouse.
1580 
 
1581 
    Parameters:
1582 
     - statuses
1583 
     - warehouseId
1584 
    """
1585 
    self.send_getOrderCount(statuses, warehouseId)
1586 
    return self.recv_getOrderCount()
1587 
 
1588 
  def send_getOrderCount(self, statuses, warehouseId):
1589 
    self._oprot.writeMessageBegin('getOrderCount', TMessageType.CALL, self._seqid)
1590 
    args = getOrderCount_args()
1591 
    args.statuses = statuses
1592 
    args.warehouseId = warehouseId
1593 
    args.write(self._oprot)
1594 
    self._oprot.writeMessageEnd()
1595 
    self._oprot.trans.flush()
1596 
 
1597 
  def recv_getOrderCount(self, ):
1598 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1599 
    if mtype == TMessageType.EXCEPTION:
1600 
      x = TApplicationException()
1601 
      x.read(self._iprot)
1602 
      self._iprot.readMessageEnd()
1603 
      raise x
1604 
    result = getOrderCount_result()
1605 
    result.read(self._iprot)
1606 
    self._iprot.readMessageEnd()
1607 
    if result.success is not None:
1608 
      return result.success
1609 
    if result.ex is not None:
1610 
      raise result.ex
1611 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getOrderCount failed: unknown result");
1612 
 
999 varun.gupt 1613 
  def getOrdersByBillingDate(self, status, start_billing_date, end_billing_date, warehouse_id):
1614 
    """
1132 chandransh 1615 
    Returns orders within a range of their billing dates
3431 rajveer 1616 
 
999 varun.gupt 1617 
    Parameters:
1618 
     - status
1619 
     - start_billing_date
1620 
     - end_billing_date
1621 
     - warehouse_id
1622 
    """
1623 
    self.send_getOrdersByBillingDate(status, start_billing_date, end_billing_date, warehouse_id)
1624 
    return self.recv_getOrdersByBillingDate()
1625 
 
1626 
  def send_getOrdersByBillingDate(self, status, start_billing_date, end_billing_date, warehouse_id):
1627 
    self._oprot.writeMessageBegin('getOrdersByBillingDate', TMessageType.CALL, self._seqid)
1628 
    args = getOrdersByBillingDate_args()
1629 
    args.status = status
1630 
    args.start_billing_date = start_billing_date
1631 
    args.end_billing_date = end_billing_date
1632 
    args.warehouse_id = warehouse_id
1633 
    args.write(self._oprot)
1634 
    self._oprot.writeMessageEnd()
1635 
    self._oprot.trans.flush()
1636 
 
1637 
  def recv_getOrdersByBillingDate(self, ):
1638 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1639 
    if mtype == TMessageType.EXCEPTION:
1640 
      x = TApplicationException()
1641 
      x.read(self._iprot)
1642 
      self._iprot.readMessageEnd()
1643 
      raise x
1644 
    result = getOrdersByBillingDate_result()
1645 
    result.read(self._iprot)
1646 
    self._iprot.readMessageEnd()
3431 rajveer 1647 
    if result.success is not None:
999 varun.gupt 1648 
      return result.success
3431 rajveer 1649 
    if result.ex is not None:
999 varun.gupt 1650 
      raise result.ex
1651 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getOrdersByBillingDate failed: unknown result");
1652 
 
3451 chandransh 1653 
  def getOrdersByShippingDate(self, fromShippingDate, toShippingDate, providerId, warehouseId, cod):
3427 chandransh 1654 
    """
1655 
    Returns orders for a particular provider and warehouse which were shipped between the given dates.
3451 chandransh 1656 
    Returned orders comprise of COD orders if cod parameter is true. It comprises of prepaid orders otherwise.
1657 
    Pass providerId and warehouseId as -1 to ignore both these parameters.
3431 rajveer 1658 
 
3427 chandransh 1659 
    Parameters:
1660 
     - fromShippingDate
1661 
     - toShippingDate
1662 
     - providerId
1663 
     - warehouseId
3451 chandransh 1664 
     - cod
3427 chandransh 1665 
    """
3451 chandransh 1666 
    self.send_getOrdersByShippingDate(fromShippingDate, toShippingDate, providerId, warehouseId, cod)
3427 chandransh 1667 
    return self.recv_getOrdersByShippingDate()
1668 
 
3451 chandransh 1669 
  def send_getOrdersByShippingDate(self, fromShippingDate, toShippingDate, providerId, warehouseId, cod):
3427 chandransh 1670 
    self._oprot.writeMessageBegin('getOrdersByShippingDate', TMessageType.CALL, self._seqid)
1671 
    args = getOrdersByShippingDate_args()
1672 
    args.fromShippingDate = fromShippingDate
1673 
    args.toShippingDate = toShippingDate
1674 
    args.providerId = providerId
1675 
    args.warehouseId = warehouseId
3451 chandransh 1676 
    args.cod = cod
3427 chandransh 1677 
    args.write(self._oprot)
1678 
    self._oprot.writeMessageEnd()
1679 
    self._oprot.trans.flush()
1680 
 
1681 
  def recv_getOrdersByShippingDate(self, ):
1682 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1683 
    if mtype == TMessageType.EXCEPTION:
1684 
      x = TApplicationException()
1685 
      x.read(self._iprot)
1686 
      self._iprot.readMessageEnd()
1687 
      raise x
1688 
    result = getOrdersByShippingDate_result()
1689 
    result.read(self._iprot)
1690 
    self._iprot.readMessageEnd()
3431 rajveer 1691 
    if result.success is not None:
3427 chandransh 1692 
      return result.success
3431 rajveer 1693 
    if result.ex is not None:
3427 chandransh 1694 
      raise result.ex
1695 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getOrdersByShippingDate failed: unknown result");
1696 
 
1382 varun.gupt 1697 
  def getReturnableOrdersForCustomer(self, customer_id, limit):
1698 
    """
1699 
    Returns order ids for orders which can be returned
3431 rajveer 1700 
 
1382 varun.gupt 1701 
    Parameters:
1702 
     - customer_id
1703 
     - limit
1704 
    """
1705 
    self.send_getReturnableOrdersForCustomer(customer_id, limit)
1706 
    return self.recv_getReturnableOrdersForCustomer()
1707 
 
1708 
  def send_getReturnableOrdersForCustomer(self, customer_id, limit):
1709 
    self._oprot.writeMessageBegin('getReturnableOrdersForCustomer', TMessageType.CALL, self._seqid)
1710 
    args = getReturnableOrdersForCustomer_args()
1711 
    args.customer_id = customer_id
1712 
    args.limit = limit
1713 
    args.write(self._oprot)
1714 
    self._oprot.writeMessageEnd()
1715 
    self._oprot.trans.flush()
1716 
 
1717 
  def recv_getReturnableOrdersForCustomer(self, ):
1718 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1719 
    if mtype == TMessageType.EXCEPTION:
1720 
      x = TApplicationException()
1721 
      x.read(self._iprot)
1722 
      self._iprot.readMessageEnd()
1723 
      raise x
1724 
    result = getReturnableOrdersForCustomer_result()
1725 
    result.read(self._iprot)
1726 
    self._iprot.readMessageEnd()
3431 rajveer 1727 
    if result.success is not None:
1382 varun.gupt 1728 
      return result.success
3431 rajveer 1729 
    if result.ex is not None:
1382 varun.gupt 1730 
      raise result.ex
1731 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getReturnableOrdersForCustomer failed: unknown result");
1732 
 
1733 
  def getCancellableOrdersForCustomer(self, customer_id, limit):
1734 
    """
1735 
    Returns order ids for orders which can be cancelled
3431 rajveer 1736 
 
1382 varun.gupt 1737 
    Parameters:
1738 
     - customer_id
1739 
     - limit
1740 
    """
1741 
    self.send_getCancellableOrdersForCustomer(customer_id, limit)
1742 
    return self.recv_getCancellableOrdersForCustomer()
1743 
 
1744 
  def send_getCancellableOrdersForCustomer(self, customer_id, limit):
1745 
    self._oprot.writeMessageBegin('getCancellableOrdersForCustomer', TMessageType.CALL, self._seqid)
1746 
    args = getCancellableOrdersForCustomer_args()
1747 
    args.customer_id = customer_id
1748 
    args.limit = limit
1749 
    args.write(self._oprot)
1750 
    self._oprot.writeMessageEnd()
1751 
    self._oprot.trans.flush()
1752 
 
1753 
  def recv_getCancellableOrdersForCustomer(self, ):
1754 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1755 
    if mtype == TMessageType.EXCEPTION:
1756 
      x = TApplicationException()
1757 
      x.read(self._iprot)
1758 
      self._iprot.readMessageEnd()
1759 
      raise x
1760 
    result = getCancellableOrdersForCustomer_result()
1761 
    result.read(self._iprot)
1762 
    self._iprot.readMessageEnd()
3431 rajveer 1763 
    if result.success is not None:
1382 varun.gupt 1764 
      return result.success
3431 rajveer 1765 
    if result.ex is not None:
1382 varun.gupt 1766 
      raise result.ex
1767 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getCancellableOrdersForCustomer failed: unknown result");
1768 
 
483 rajveer 1769 
  def changeOrderStatus(self, orderId, status, description):
94 ashish 1770 
    """
1771 
    Parameters:
483 rajveer 1772 
     - orderId
1773 
     - status
1774 
     - description
94 ashish 1775 
    """
483 rajveer 1776 
    self.send_changeOrderStatus(orderId, status, description)
1777 
    return self.recv_changeOrderStatus()
94 ashish 1778 
 
483 rajveer 1779 
  def send_changeOrderStatus(self, orderId, status, description):
1780 
    self._oprot.writeMessageBegin('changeOrderStatus', TMessageType.CALL, self._seqid)
1781 
    args = changeOrderStatus_args()
1782 
    args.orderId = orderId
1783 
    args.status = status
1784 
    args.description = description
94 ashish 1785 
    args.write(self._oprot)
1786 
    self._oprot.writeMessageEnd()
1787 
    self._oprot.trans.flush()
1788 
 
483 rajveer 1789 
  def recv_changeOrderStatus(self, ):
94 ashish 1790 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1791 
    if mtype == TMessageType.EXCEPTION:
1792 
      x = TApplicationException()
1793 
      x.read(self._iprot)
1794 
      self._iprot.readMessageEnd()
1795 
      raise x
483 rajveer 1796 
    result = changeOrderStatus_result()
94 ashish 1797 
    result.read(self._iprot)
1798 
    self._iprot.readMessageEnd()
3431 rajveer 1799 
    if result.success is not None:
94 ashish 1800 
      return result.success
3431 rajveer 1801 
    if result.ex is not None:
94 ashish 1802 
      raise result.ex
483 rajveer 1803 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "changeOrderStatus failed: unknown result");
94 ashish 1804 
 
1528 ankur.sing 1805 
  def getOrdersForTransaction(self, transactionId, customerId):
94 ashish 1806 
    """
1528 ankur.sing 1807 
    Returns list of orders for given transaction Id. Also filters based on customer Id so that
1808 
    only user who owns the transaction can view its order details.
3431 rajveer 1809 
 
94 ashish 1810 
    Parameters:
1811 
     - transactionId
1528 ankur.sing 1812 
     - customerId
94 ashish 1813 
    """
1528 ankur.sing 1814 
    self.send_getOrdersForTransaction(transactionId, customerId)
483 rajveer 1815 
    return self.recv_getOrdersForTransaction()
94 ashish 1816 
 
1528 ankur.sing 1817 
  def send_getOrdersForTransaction(self, transactionId, customerId):
483 rajveer 1818 
    self._oprot.writeMessageBegin('getOrdersForTransaction', TMessageType.CALL, self._seqid)
1819 
    args = getOrdersForTransaction_args()
94 ashish 1820 
    args.transactionId = transactionId
1528 ankur.sing 1821 
    args.customerId = customerId
94 ashish 1822 
    args.write(self._oprot)
1823 
    self._oprot.writeMessageEnd()
1824 
    self._oprot.trans.flush()
1825 
 
483 rajveer 1826 
  def recv_getOrdersForTransaction(self, ):
94 ashish 1827 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1828 
    if mtype == TMessageType.EXCEPTION:
1829 
      x = TApplicationException()
1830 
      x.read(self._iprot)
1831 
      self._iprot.readMessageEnd()
1832 
      raise x
483 rajveer 1833 
    result = getOrdersForTransaction_result()
94 ashish 1834 
    result.read(self._iprot)
1835 
    self._iprot.readMessageEnd()
3431 rajveer 1836 
    if result.success is not None:
94 ashish 1837 
      return result.success
3431 rajveer 1838 
    if result.ex is not None:
94 ashish 1839 
      raise result.ex
483 rajveer 1840 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getOrdersForTransaction failed: unknown result");
94 ashish 1841 
 
3014 chandransh 1842 
  def getOrdersForCustomer(self, customerId, from_date, to_date, statuses):
94 ashish 1843 
    """
3014 chandransh 1844 
    Returns list of orders for the given customer created between the given dates and having the given statuses.
1845 
    Pass and empty list to ignore filtering on statuses.
3431 rajveer 1846 
 
94 ashish 1847 
    Parameters:
483 rajveer 1848 
     - customerId
1849 
     - from_date
1850 
     - to_date
3014 chandransh 1851 
     - statuses
94 ashish 1852 
    """
3014 chandransh 1853 
    self.send_getOrdersForCustomer(customerId, from_date, to_date, statuses)
483 rajveer 1854 
    return self.recv_getOrdersForCustomer()
94 ashish 1855 
 
3014 chandransh 1856 
  def send_getOrdersForCustomer(self, customerId, from_date, to_date, statuses):
483 rajveer 1857 
    self._oprot.writeMessageBegin('getOrdersForCustomer', TMessageType.CALL, self._seqid)
1858 
    args = getOrdersForCustomer_args()
1859 
    args.customerId = customerId
1860 
    args.from_date = from_date
1861 
    args.to_date = to_date
3014 chandransh 1862 
    args.statuses = statuses
94 ashish 1863 
    args.write(self._oprot)
1864 
    self._oprot.writeMessageEnd()
1865 
    self._oprot.trans.flush()
1866 
 
483 rajveer 1867 
  def recv_getOrdersForCustomer(self, ):
94 ashish 1868 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1869 
    if mtype == TMessageType.EXCEPTION:
1870 
      x = TApplicationException()
1871 
      x.read(self._iprot)
1872 
      self._iprot.readMessageEnd()
1873 
      raise x
483 rajveer 1874 
    result = getOrdersForCustomer_result()
94 ashish 1875 
    result.read(self._iprot)
1876 
    self._iprot.readMessageEnd()
3431 rajveer 1877 
    if result.success is not None:
94 ashish 1878 
      return result.success
3431 rajveer 1879 
    if result.ex is not None:
94 ashish 1880 
      raise result.ex
483 rajveer 1881 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getOrdersForCustomer failed: unknown result");
94 ashish 1882 
 
483 rajveer 1883 
  def createOrder(self, order):
94 ashish 1884 
    """
1885 
    Parameters:
483 rajveer 1886 
     - order
94 ashish 1887 
    """
483 rajveer 1888 
    self.send_createOrder(order)
1889 
    return self.recv_createOrder()
94 ashish 1890 
 
483 rajveer 1891 
  def send_createOrder(self, order):
1892 
    self._oprot.writeMessageBegin('createOrder', TMessageType.CALL, self._seqid)
1893 
    args = createOrder_args()
1894 
    args.order = order
94 ashish 1895 
    args.write(self._oprot)
1896 
    self._oprot.writeMessageEnd()
1897 
    self._oprot.trans.flush()
1898 
 
483 rajveer 1899 
  def recv_createOrder(self, ):
94 ashish 1900 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1901 
    if mtype == TMessageType.EXCEPTION:
1902 
      x = TApplicationException()
1903 
      x.read(self._iprot)
1904 
      self._iprot.readMessageEnd()
1905 
      raise x
483 rajveer 1906 
    result = createOrder_result()
94 ashish 1907 
    result.read(self._iprot)
1908 
    self._iprot.readMessageEnd()
3431 rajveer 1909 
    if result.success is not None:
94 ashish 1910 
      return result.success
3431 rajveer 1911 
    if result.ex is not None:
94 ashish 1912 
      raise result.ex
483 rajveer 1913 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "createOrder failed: unknown result");
94 ashish 1914 
 
483 rajveer 1915 
  def getOrder(self, id):
94 ashish 1916 
    """
1917 
    Parameters:
483 rajveer 1918 
     - id
94 ashish 1919 
    """
483 rajveer 1920 
    self.send_getOrder(id)
1921 
    return self.recv_getOrder()
94 ashish 1922 
 
483 rajveer 1923 
  def send_getOrder(self, id):
1924 
    self._oprot.writeMessageBegin('getOrder', TMessageType.CALL, self._seqid)
1925 
    args = getOrder_args()
1926 
    args.id = id
94 ashish 1927 
    args.write(self._oprot)
1928 
    self._oprot.writeMessageEnd()
1929 
    self._oprot.trans.flush()
1930 
 
483 rajveer 1931 
  def recv_getOrder(self, ):
94 ashish 1932 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1933 
    if mtype == TMessageType.EXCEPTION:
1934 
      x = TApplicationException()
1935 
      x.read(self._iprot)
1936 
      self._iprot.readMessageEnd()
1937 
      raise x
483 rajveer 1938 
    result = getOrder_result()
94 ashish 1939 
    result.read(self._iprot)
1940 
    self._iprot.readMessageEnd()
3431 rajveer 1941 
    if result.success is not None:
94 ashish 1942 
      return result.success
3431 rajveer 1943 
    if result.ex is not None:
94 ashish 1944 
      raise result.ex
483 rajveer 1945 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getOrder failed: unknown result");
94 ashish 1946 
 
483 rajveer 1947 
  def getLineItemsForOrder(self, orderId):
94 ashish 1948 
    """
1949 
    Parameters:
483 rajveer 1950 
     - orderId
94 ashish 1951 
    """
483 rajveer 1952 
    self.send_getLineItemsForOrder(orderId)
1953 
    return self.recv_getLineItemsForOrder()
94 ashish 1954 
 
483 rajveer 1955 
  def send_getLineItemsForOrder(self, orderId):
1956 
    self._oprot.writeMessageBegin('getLineItemsForOrder', TMessageType.CALL, self._seqid)
1957 
    args = getLineItemsForOrder_args()
1958 
    args.orderId = orderId
94 ashish 1959 
    args.write(self._oprot)
1960 
    self._oprot.writeMessageEnd()
1961 
    self._oprot.trans.flush()
1962 
 
483 rajveer 1963 
  def recv_getLineItemsForOrder(self, ):
94 ashish 1964 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1965 
    if mtype == TMessageType.EXCEPTION:
1966 
      x = TApplicationException()
1967 
      x.read(self._iprot)
1968 
      self._iprot.readMessageEnd()
1969 
      raise x
483 rajveer 1970 
    result = getLineItemsForOrder_result()
94 ashish 1971 
    result.read(self._iprot)
1972 
    self._iprot.readMessageEnd()
3431 rajveer 1973 
    if result.success is not None:
94 ashish 1974 
      return result.success
3431 rajveer 1975 
    if result.ex is not None:
94 ashish 1976 
      raise result.ex
483 rajveer 1977 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getLineItemsForOrder failed: unknown result");
94 ashish 1978 
 
4999 phani.kuma 1979 
  def getOrderList(self, order_ids):
1980 
    """
1981 
    Parameters:
1982 
     - order_ids
1983 
    """
1984 
    self.send_getOrderList(order_ids)
1985 
    return self.recv_getOrderList()
1986 
 
1987 
  def send_getOrderList(self, order_ids):
1988 
    self._oprot.writeMessageBegin('getOrderList', TMessageType.CALL, self._seqid)
1989 
    args = getOrderList_args()
1990 
    args.order_ids = order_ids
1991 
    args.write(self._oprot)
1992 
    self._oprot.writeMessageEnd()
1993 
    self._oprot.trans.flush()
1994 
 
1995 
  def recv_getOrderList(self, ):
1996 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1997 
    if mtype == TMessageType.EXCEPTION:
1998 
      x = TApplicationException()
1999 
      x.read(self._iprot)
2000 
      self._iprot.readMessageEnd()
2001 
      raise x
2002 
    result = getOrderList_result()
2003 
    result.read(self._iprot)
2004 
    self._iprot.readMessageEnd()
2005 
    if result.success is not None:
2006 
      return result.success
2007 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getOrderList failed: unknown result");
2008 
 
5386 phani.kuma 2009 
  def getOrderListForVendor(self, order_ids, vendorId):
2010 
    """
2011 
    Parameters:
2012 
     - order_ids
2013 
     - vendorId
2014 
    """
2015 
    self.send_getOrderListForVendor(order_ids, vendorId)
2016 
    return self.recv_getOrderListForVendor()
2017 
 
2018 
  def send_getOrderListForVendor(self, order_ids, vendorId):
2019 
    self._oprot.writeMessageBegin('getOrderListForVendor', TMessageType.CALL, self._seqid)
2020 
    args = getOrderListForVendor_args()
2021 
    args.order_ids = order_ids
2022 
    args.vendorId = vendorId
2023 
    args.write(self._oprot)
2024 
    self._oprot.writeMessageEnd()
2025 
    self._oprot.trans.flush()
2026 
 
2027 
  def recv_getOrderListForVendor(self, ):
2028 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2029 
    if mtype == TMessageType.EXCEPTION:
2030 
      x = TApplicationException()
2031 
      x.read(self._iprot)
2032 
      self._iprot.readMessageEnd()
2033 
      raise x
2034 
    result = getOrderListForVendor_result()
2035 
    result.read(self._iprot)
2036 
    self._iprot.readMessageEnd()
2037 
    if result.success is not None:
2038 
      return result.success
2039 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getOrderListForVendor failed: unknown result");
2040 
 
1528 ankur.sing 2041 
  def getOrderForCustomer(self, orderId, customerId):
2042 
    """
2043 
    Returns an order for the order Id. Also checks if the order belongs to the customer whose Id is passed.
2044 
    Throws exception if either order Id is invalid or order does not below to the customer whose Id is passed.
3431 rajveer 2045 
 
1528 ankur.sing 2046 
    Parameters:
2047 
     - orderId
2048 
     - customerId
2049 
    """
2050 
    self.send_getOrderForCustomer(orderId, customerId)
2051 
    return self.recv_getOrderForCustomer()
2052 
 
2053 
  def send_getOrderForCustomer(self, orderId, customerId):
2054 
    self._oprot.writeMessageBegin('getOrderForCustomer', TMessageType.CALL, self._seqid)
2055 
    args = getOrderForCustomer_args()
2056 
    args.orderId = orderId
2057 
    args.customerId = customerId
2058 
    args.write(self._oprot)
2059 
    self._oprot.writeMessageEnd()
2060 
    self._oprot.trans.flush()
2061 
 
2062 
  def recv_getOrderForCustomer(self, ):
2063 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2064 
    if mtype == TMessageType.EXCEPTION:
2065 
      x = TApplicationException()
2066 
      x.read(self._iprot)
2067 
      self._iprot.readMessageEnd()
2068 
      raise x
2069 
    result = getOrderForCustomer_result()
2070 
    result.read(self._iprot)
2071 
    self._iprot.readMessageEnd()
3431 rajveer 2072 
    if result.success is not None:
1528 ankur.sing 2073 
      return result.success
3431 rajveer 2074 
    if result.ex is not None:
1528 ankur.sing 2075 
      raise result.ex
2076 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getOrderForCustomer failed: unknown result");
2077 
 
4444 rajveer 2078 
  def getAlerts(self, type, warehouseId, status, timestamp):
3064 chandransh 2079 
    """
2080 
    Parameters:
4394 rajveer 2081 
     - type
4444 rajveer 2082 
     - warehouseId
4394 rajveer 2083 
     - status
2084 
     - timestamp
3064 chandransh 2085 
    """
4444 rajveer 2086 
    self.send_getAlerts(type, warehouseId, status, timestamp)
3064 chandransh 2087 
    return self.recv_getAlerts()
2088 
 
4444 rajveer 2089 
  def send_getAlerts(self, type, warehouseId, status, timestamp):
3064 chandransh 2090 
    self._oprot.writeMessageBegin('getAlerts', TMessageType.CALL, self._seqid)
2091 
    args = getAlerts_args()
4394 rajveer 2092 
    args.type = type
4444 rajveer 2093 
    args.warehouseId = warehouseId
4394 rajveer 2094 
    args.status = status
2095 
    args.timestamp = timestamp
3064 chandransh 2096 
    args.write(self._oprot)
2097 
    self._oprot.writeMessageEnd()
2098 
    self._oprot.trans.flush()
2099 
 
2100 
  def recv_getAlerts(self, ):
2101 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2102 
    if mtype == TMessageType.EXCEPTION:
2103 
      x = TApplicationException()
2104 
      x.read(self._iprot)
2105 
      self._iprot.readMessageEnd()
2106 
      raise x
2107 
    result = getAlerts_result()
2108 
    result.read(self._iprot)
2109 
    self._iprot.readMessageEnd()
3431 rajveer 2110 
    if result.success is not None:
3064 chandransh 2111 
      return result.success
2112 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAlerts failed: unknown result");
2113 
 
4444 rajveer 2114 
  def addAlert(self, type, warehouseId, description):
3064 chandransh 2115 
    """
2116 
    Parameters:
2117 
     - type
4444 rajveer 2118 
     - warehouseId
4394 rajveer 2119 
     - description
3064 chandransh 2120 
    """
4444 rajveer 2121 
    self.send_addAlert(type, warehouseId, description)
4394 rajveer 2122 
    self.recv_addAlert()
3064 chandransh 2123 
 
4444 rajveer 2124 
  def send_addAlert(self, type, warehouseId, description):
4394 rajveer 2125 
    self._oprot.writeMessageBegin('addAlert', TMessageType.CALL, self._seqid)
2126 
    args = addAlert_args()
3064 chandransh 2127 
    args.type = type
4444 rajveer 2128 
    args.warehouseId = warehouseId
4394 rajveer 2129 
    args.description = description
3064 chandransh 2130 
    args.write(self._oprot)
2131 
    self._oprot.writeMessageEnd()
2132 
    self._oprot.trans.flush()
2133 
 
4394 rajveer 2134 
  def recv_addAlert(self, ):
3064 chandransh 2135 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2136 
    if mtype == TMessageType.EXCEPTION:
2137 
      x = TApplicationException()
2138 
      x.read(self._iprot)
2139 
      self._iprot.readMessageEnd()
2140 
      raise x
4394 rajveer 2141 
    result = addAlert_result()
3064 chandransh 2142 
    result.read(self._iprot)
2143 
    self._iprot.readMessageEnd()
2144 
    return
2145 
 
4444 rajveer 2146 
  def markAlertsAsSeen(self, warehouseId):
2147 
    """
2148 
    Parameters:
2149 
     - warehouseId
2150 
    """
2151 
    self.send_markAlertsAsSeen(warehouseId)
2152 
    self.recv_markAlertsAsSeen()
2153 
 
2154 
  def send_markAlertsAsSeen(self, warehouseId):
2155 
    self._oprot.writeMessageBegin('markAlertsAsSeen', TMessageType.CALL, self._seqid)
2156 
    args = markAlertsAsSeen_args()
2157 
    args.warehouseId = warehouseId
2158 
    args.write(self._oprot)
2159 
    self._oprot.writeMessageEnd()
2160 
    self._oprot.trans.flush()
2161 
 
2162 
  def recv_markAlertsAsSeen(self, ):
2163 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2164 
    if mtype == TMessageType.EXCEPTION:
2165 
      x = TApplicationException()
2166 
      x.read(self._iprot)
2167 
      self._iprot.readMessageEnd()
2168 
      raise x
2169 
    result = markAlertsAsSeen_result()
2170 
    result.read(self._iprot)
2171 
    self._iprot.readMessageEnd()
2172 
    return
2173 
 
3064 chandransh 2174 
  def getValidOrderCount(self, ):
2175 
    """
2176 
    Return the number of valid orders. (OrderStatus >= OrderStatus.SUBMITTED_FOR_PROCESSING)
2177 
    """
2178 
    self.send_getValidOrderCount()
2179 
    return self.recv_getValidOrderCount()
2180 
 
2181 
  def send_getValidOrderCount(self, ):
2182 
    self._oprot.writeMessageBegin('getValidOrderCount', TMessageType.CALL, self._seqid)
2183 
    args = getValidOrderCount_args()
2184 
    args.write(self._oprot)
2185 
    self._oprot.writeMessageEnd()
2186 
    self._oprot.trans.flush()
2187 
 
2188 
  def recv_getValidOrderCount(self, ):
2189 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2190 
    if mtype == TMessageType.EXCEPTION:
2191 
      x = TApplicationException()
2192 
      x.read(self._iprot)
2193 
      self._iprot.readMessageEnd()
2194 
      raise x
2195 
    result = getValidOrderCount_result()
2196 
    result.read(self._iprot)
2197 
    self._iprot.readMessageEnd()
3431 rajveer 2198 
    if result.success is not None:
3064 chandransh 2199 
      return result.success
2200 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getValidOrderCount failed: unknown result");
2201 
 
2202 
  def getNoOfCustomersWithSuccessfulTransaction(self, ):
2203 
    """
2204 
    Returns the number of distinct customers who have done successful transactions
2205 
    """
2206 
    self.send_getNoOfCustomersWithSuccessfulTransaction()
2207 
    return self.recv_getNoOfCustomersWithSuccessfulTransaction()
2208 
 
2209 
  def send_getNoOfCustomersWithSuccessfulTransaction(self, ):
2210 
    self._oprot.writeMessageBegin('getNoOfCustomersWithSuccessfulTransaction', TMessageType.CALL, self._seqid)
2211 
    args = getNoOfCustomersWithSuccessfulTransaction_args()
2212 
    args.write(self._oprot)
2213 
    self._oprot.writeMessageEnd()
2214 
    self._oprot.trans.flush()
2215 
 
2216 
  def recv_getNoOfCustomersWithSuccessfulTransaction(self, ):
2217 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2218 
    if mtype == TMessageType.EXCEPTION:
2219 
      x = TApplicationException()
2220 
      x.read(self._iprot)
2221 
      self._iprot.readMessageEnd()
2222 
      raise x
2223 
    result = getNoOfCustomersWithSuccessfulTransaction_result()
2224 
    result.read(self._iprot)
2225 
    self._iprot.readMessageEnd()
3431 rajveer 2226 
    if result.success is not None:
3064 chandransh 2227 
      return result.success
2228 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getNoOfCustomersWithSuccessfulTransaction failed: unknown result");
2229 
 
2230 
  def getValidOrdersAmountRange(self, ):
2231 
    """
2232 
    Returns the minimum and maximum amounts of a valid order. (OrderStatus >= OrderStatus.SUBMITTED_FOR_PROCESSING)
2233 
    List contains two values, first minimum amount and second maximum amount.
2234 
    """
2235 
    self.send_getValidOrdersAmountRange()
2236 
    return self.recv_getValidOrdersAmountRange()
2237 
 
2238 
  def send_getValidOrdersAmountRange(self, ):
2239 
    self._oprot.writeMessageBegin('getValidOrdersAmountRange', TMessageType.CALL, self._seqid)
2240 
    args = getValidOrdersAmountRange_args()
2241 
    args.write(self._oprot)
2242 
    self._oprot.writeMessageEnd()
2243 
    self._oprot.trans.flush()
2244 
 
2245 
  def recv_getValidOrdersAmountRange(self, ):
2246 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2247 
    if mtype == TMessageType.EXCEPTION:
2248 
      x = TApplicationException()
2249 
      x.read(self._iprot)
2250 
      self._iprot.readMessageEnd()
2251 
      raise x
2252 
    result = getValidOrdersAmountRange_result()
2253 
    result.read(self._iprot)
2254 
    self._iprot.readMessageEnd()
3431 rajveer 2255 
    if result.success is not None:
3064 chandransh 2256 
      return result.success
2257 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getValidOrdersAmountRange failed: unknown result");
2258 
 
2259 
  def getValidOrders(self, limit):
2260 
    """
2261 
    Returns list of Orders in descending order by Order creation date. List is restricted to limit Orders.
2262 
    If limit is passed as 0, then all valid Orders are returned.
3431 rajveer 2263 
 
3064 chandransh 2264 
    Parameters:
2265 
     - limit
2266 
    """
2267 
    self.send_getValidOrders(limit)
2268 
    return self.recv_getValidOrders()
2269 
 
2270 
  def send_getValidOrders(self, limit):
2271 
    self._oprot.writeMessageBegin('getValidOrders', TMessageType.CALL, self._seqid)
2272 
    args = getValidOrders_args()
2273 
    args.limit = limit
2274 
    args.write(self._oprot)
2275 
    self._oprot.writeMessageEnd()
2276 
    self._oprot.trans.flush()
2277 
 
2278 
  def recv_getValidOrders(self, ):
2279 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2280 
    if mtype == TMessageType.EXCEPTION:
2281 
      x = TApplicationException()
2282 
      x.read(self._iprot)
2283 
      self._iprot.readMessageEnd()
2284 
      raise x
2285 
    result = getValidOrders_result()
2286 
    result.read(self._iprot)
2287 
    self._iprot.readMessageEnd()
3431 rajveer 2288 
    if result.success is not None:
3064 chandransh 2289 
      return result.success
2290 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getValidOrders failed: unknown result");
2291 
 
1220 chandransh 2292 
  def batchOrders(self, warehouseId):
2293 
    """
2294 
    Create a batch of all the pending orders for the given warehouse.
2295 
    The returned list is orderd by created_timestamp.
2296 
    If there are no pending orders, an empty list is returned.
3431 rajveer 2297 
 
1220 chandransh 2298 
    Parameters:
2299 
     - warehouseId
2300 
    """
2301 
    self.send_batchOrders(warehouseId)
2302 
    return self.recv_batchOrders()
2303 
 
2304 
  def send_batchOrders(self, warehouseId):
2305 
    self._oprot.writeMessageBegin('batchOrders', TMessageType.CALL, self._seqid)
2306 
    args = batchOrders_args()
2307 
    args.warehouseId = warehouseId
2308 
    args.write(self._oprot)
2309 
    self._oprot.writeMessageEnd()
2310 
    self._oprot.trans.flush()
2311 
 
2312 
  def recv_batchOrders(self, ):
2313 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2314 
    if mtype == TMessageType.EXCEPTION:
2315 
      x = TApplicationException()
2316 
      x.read(self._iprot)
2317 
      self._iprot.readMessageEnd()
2318 
      raise x
2319 
    result = batchOrders_result()
2320 
    result.read(self._iprot)
2321 
    self._iprot.readMessageEnd()
3431 rajveer 2322 
    if result.success is not None:
1220 chandransh 2323 
      return result.success
3431 rajveer 2324 
    if result.ex is not None:
1220 chandransh 2325 
      raise result.ex
2326 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "batchOrders failed: unknown result");
2327 
 
1208 chandransh 2328 
  def markOrderAsOutOfStock(self, orderId):
2329 
    """
2330 
    Mark the given order as out of stock. Throws an exception if the order with the given Id couldn't be found.
3431 rajveer 2331 
 
1208 chandransh 2332 
    Parameters:
2333 
     - orderId
2334 
    """
2335 
    self.send_markOrderAsOutOfStock(orderId)
2336 
    return self.recv_markOrderAsOutOfStock()
2337 
 
2338 
  def send_markOrderAsOutOfStock(self, orderId):
2339 
    self._oprot.writeMessageBegin('markOrderAsOutOfStock', TMessageType.CALL, self._seqid)
2340 
    args = markOrderAsOutOfStock_args()
2341 
    args.orderId = orderId
2342 
    args.write(self._oprot)
2343 
    self._oprot.writeMessageEnd()
2344 
    self._oprot.trans.flush()
2345 
 
2346 
  def recv_markOrderAsOutOfStock(self, ):
2347 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2348 
    if mtype == TMessageType.EXCEPTION:
2349 
      x = TApplicationException()
2350 
      x.read(self._iprot)
2351 
      self._iprot.readMessageEnd()
2352 
      raise x
2353 
    result = markOrderAsOutOfStock_result()
2354 
    result.read(self._iprot)
2355 
    self._iprot.readMessageEnd()
3431 rajveer 2356 
    if result.success is not None:
1208 chandransh 2357 
      return result.success
3431 rajveer 2358 
    if result.ex is not None:
1208 chandransh 2359 
      raise result.ex
2360 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "markOrderAsOutOfStock failed: unknown result");
2361 
 
3064 chandransh 2362 
  def verifyOrder(self, orderId):
759 chandransh 2363 
    """
3064 chandransh 2364 
    Marks the given order as SUBMITTED_FOR_PROCESSING and updates the verified
2365 
    timestamp. It is intended to be used for COD orders but can be harmlessly
2366 
    used for all other orders as well.
2367 
    Throws an exception if no such order exists.
3431 rajveer 2368 
 
759 chandransh 2369 
    Parameters:
3064 chandransh 2370 
     - orderId
759 chandransh 2371 
    """
3064 chandransh 2372 
    self.send_verifyOrder(orderId)
2373 
    return self.recv_verifyOrder()
759 chandransh 2374 
 
3064 chandransh 2375 
  def send_verifyOrder(self, orderId):
2376 
    self._oprot.writeMessageBegin('verifyOrder', TMessageType.CALL, self._seqid)
2377 
    args = verifyOrder_args()
2378 
    args.orderId = orderId
759 chandransh 2379 
    args.write(self._oprot)
2380 
    self._oprot.writeMessageEnd()
2381 
    self._oprot.trans.flush()
2382 
 
3064 chandransh 2383 
  def recv_verifyOrder(self, ):
759 chandransh 2384 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2385 
    if mtype == TMessageType.EXCEPTION:
2386 
      x = TApplicationException()
2387 
      x.read(self._iprot)
2388 
      self._iprot.readMessageEnd()
2389 
      raise x
3064 chandransh 2390 
    result = verifyOrder_result()
759 chandransh 2391 
    result.read(self._iprot)
2392 
    self._iprot.readMessageEnd()
3431 rajveer 2393 
    if result.success is not None:
759 chandransh 2394 
      return result.success
3431 rajveer 2395 
    if result.ex is not None:
759 chandransh 2396 
      raise result.ex
3064 chandransh 2397 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "verifyOrder failed: unknown result");
759 chandransh 2398 
 
3064 chandransh 2399 
  def acceptOrder(self, orderId):
1113 chandransh 2400 
    """
3064 chandransh 2401 
    Marks the given order as ACCEPTED and updates the accepted timestamp. If the
2402 
    given order is not a COD order, it also captures the payment if the same has
2403 
    not been captured.
2404 
    Throws an exception if no such order exists.
3431 rajveer 2405 
 
1113 chandransh 2406 
    Parameters:
3064 chandransh 2407 
     - orderId
1113 chandransh 2408 
    """
3064 chandransh 2409 
    self.send_acceptOrder(orderId)
2410 
    return self.recv_acceptOrder()
1113 chandransh 2411 
 
3064 chandransh 2412 
  def send_acceptOrder(self, orderId):
2413 
    self._oprot.writeMessageBegin('acceptOrder', TMessageType.CALL, self._seqid)
2414 
    args = acceptOrder_args()
2415 
    args.orderId = orderId
1113 chandransh 2416 
    args.write(self._oprot)
2417 
    self._oprot.writeMessageEnd()
2418 
    self._oprot.trans.flush()
2419 
 
3064 chandransh 2420 
  def recv_acceptOrder(self, ):
1113 chandransh 2421 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2422 
    if mtype == TMessageType.EXCEPTION:
2423 
      x = TApplicationException()
2424 
      x.read(self._iprot)
2425 
      self._iprot.readMessageEnd()
2426 
      raise x
3064 chandransh 2427 
    result = acceptOrder_result()
1113 chandransh 2428 
    result.read(self._iprot)
2429 
    self._iprot.readMessageEnd()
3431 rajveer 2430 
    if result.success is not None:
1113 chandransh 2431 
      return result.success
3431 rajveer 2432 
    if result.ex is not None:
1113 chandransh 2433 
      raise result.ex
3064 chandransh 2434 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "acceptOrder failed: unknown result");
1113 chandransh 2435 
 
5110 mandeep.dh 2436 
  def addBillingDetails(self, orderId, invoice_number, serialNumber, itemNumber, billed_by, jacketNumber, billingType, fulfilmentWarehouseId, authorize):
1132 chandransh 2437 
    """
3064 chandransh 2438 
    Add billing details such as the bill number and the biller to the Order.
4658 mandeep.dh 2439 
    Adds jacket number, item number and Serial no. to the order. Doesn't update
4283 anupam.sin 2440 
    the IMEI no. if a -1 is supplied.
2441 
    Also, it generates an invoice number for the order, marks the order as
2442 
    BILLED and sets the billing timestamp.
2443 
    Returns false if it doesn't find the order with the given ID.
3431 rajveer 2444 
 
1135 chandransh 2445 
    Parameters:
3064 chandransh 2446 
     - orderId
2447 
     - invoice_number
4658 mandeep.dh 2448 
     - serialNumber
4283 anupam.sin 2449 
     - itemNumber
3064 chandransh 2450 
     - billed_by
4264 rajveer 2451 
     - jacketNumber
4283 anupam.sin 2452 
     - billingType
5110 mandeep.dh 2453 
     - fulfilmentWarehouseId
4763 rajveer 2454 
     - authorize
1135 chandransh 2455 
    """
5110 mandeep.dh 2456 
    self.send_addBillingDetails(orderId, invoice_number, serialNumber, itemNumber, billed_by, jacketNumber, billingType, fulfilmentWarehouseId, authorize)
3064 chandransh 2457 
    return self.recv_addBillingDetails()
1135 chandransh 2458 
 
5110 mandeep.dh 2459 
  def send_addBillingDetails(self, orderId, invoice_number, serialNumber, itemNumber, billed_by, jacketNumber, billingType, fulfilmentWarehouseId, authorize):
3064 chandransh 2460 
    self._oprot.writeMessageBegin('addBillingDetails', TMessageType.CALL, self._seqid)
2461 
    args = addBillingDetails_args()
2462 
    args.orderId = orderId
2463 
    args.invoice_number = invoice_number
4658 mandeep.dh 2464 
    args.serialNumber = serialNumber
4283 anupam.sin 2465 
    args.itemNumber = itemNumber
3064 chandransh 2466 
    args.billed_by = billed_by
4264 rajveer 2467 
    args.jacketNumber = jacketNumber
4283 anupam.sin 2468 
    args.billingType = billingType
5110 mandeep.dh 2469 
    args.fulfilmentWarehouseId = fulfilmentWarehouseId
4763 rajveer 2470 
    args.authorize = authorize
1135 chandransh 2471 
    args.write(self._oprot)
2472 
    self._oprot.writeMessageEnd()
2473 
    self._oprot.trans.flush()
2474 
 
3064 chandransh 2475 
  def recv_addBillingDetails(self, ):
1135 chandransh 2476 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2477 
    if mtype == TMessageType.EXCEPTION:
2478 
      x = TApplicationException()
2479 
      x.read(self._iprot)
2480 
      self._iprot.readMessageEnd()
2481 
      raise x
3064 chandransh 2482 
    result = addBillingDetails_result()
1135 chandransh 2483 
    result.read(self._iprot)
2484 
    self._iprot.readMessageEnd()
3431 rajveer 2485 
    if result.success is not None:
3064 chandransh 2486 
      return result.success
3431 rajveer 2487 
    if result.ex is not None:
1135 chandransh 2488 
      raise result.ex
3064 chandransh 2489 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "addBillingDetails failed: unknown result");
1135 chandransh 2490 
 
4763 rajveer 2491 
  def addInvoiceNumber(self, orderId, invoiceNumber, color):
4579 rajveer 2492 
    """
2493 
    Add the invoice number to the order.
2494 
 
2495 
    Parameters:
2496 
     - orderId
2497 
     - invoiceNumber
4763 rajveer 2498 
     - color
4579 rajveer 2499 
    """
4763 rajveer 2500 
    self.send_addInvoiceNumber(orderId, invoiceNumber, color)
4579 rajveer 2501 
    self.recv_addInvoiceNumber()
2502 
 
4763 rajveer 2503 
  def send_addInvoiceNumber(self, orderId, invoiceNumber, color):
4579 rajveer 2504 
    self._oprot.writeMessageBegin('addInvoiceNumber', TMessageType.CALL, self._seqid)
2505 
    args = addInvoiceNumber_args()
2506 
    args.orderId = orderId
2507 
    args.invoiceNumber = invoiceNumber
4763 rajveer 2508 
    args.color = color
4579 rajveer 2509 
    args.write(self._oprot)
2510 
    self._oprot.writeMessageEnd()
2511 
    self._oprot.trans.flush()
2512 
 
2513 
  def recv_addInvoiceNumber(self, ):
2514 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2515 
    if mtype == TMessageType.EXCEPTION:
2516 
      x = TApplicationException()
2517 
      x.read(self._iprot)
2518 
      self._iprot.readMessageEnd()
2519 
      raise x
2520 
    result = addInvoiceNumber_result()
2521 
    result.read(self._iprot)
2522 
    self._iprot.readMessageEnd()
2523 
    if result.ex is not None:
2524 
      raise result.ex
2525 
    return
2526 
 
4910 phani.kuma 2527 
  def markOrdersAsShippedFromWarehouse(self, warehouseId, providerId, cod, orderIds):
1408 ankur.sing 2528 
    """
3064 chandransh 2529 
    Depending on the third parameter, marks either all prepaid or all cod orders BILLED by the
4910 phani.kuma 2530 
    given warehouse and were picked up by the given provider as SHIPPED_FROM_WH.
3431 rajveer 2531 
 
1408 ankur.sing 2532 
    Parameters:
3064 chandransh 2533 
     - warehouseId
1408 ankur.sing 2534 
     - providerId
3064 chandransh 2535 
     - cod
4910 phani.kuma 2536 
     - orderIds
1408 ankur.sing 2537 
    """
4910 phani.kuma 2538 
    self.send_markOrdersAsShippedFromWarehouse(warehouseId, providerId, cod, orderIds)
2539 
    return self.recv_markOrdersAsShippedFromWarehouse()
1408 ankur.sing 2540 
 
4910 phani.kuma 2541 
  def send_markOrdersAsShippedFromWarehouse(self, warehouseId, providerId, cod, orderIds):
2542 
    self._oprot.writeMessageBegin('markOrdersAsShippedFromWarehouse', TMessageType.CALL, self._seqid)
2543 
    args = markOrdersAsShippedFromWarehouse_args()
3064 chandransh 2544 
    args.warehouseId = warehouseId
1408 ankur.sing 2545 
    args.providerId = providerId
3064 chandransh 2546 
    args.cod = cod
4910 phani.kuma 2547 
    args.orderIds = orderIds
1408 ankur.sing 2548 
    args.write(self._oprot)
2549 
    self._oprot.writeMessageEnd()
2550 
    self._oprot.trans.flush()
2551 
 
4910 phani.kuma 2552 
  def recv_markOrdersAsShippedFromWarehouse(self, ):
1408 ankur.sing 2553 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2554 
    if mtype == TMessageType.EXCEPTION:
2555 
      x = TApplicationException()
2556 
      x.read(self._iprot)
2557 
      self._iprot.readMessageEnd()
2558 
      raise x
4910 phani.kuma 2559 
    result = markOrdersAsShippedFromWarehouse_result()
1408 ankur.sing 2560 
    result.read(self._iprot)
2561 
    self._iprot.readMessageEnd()
3431 rajveer 2562 
    if result.success is not None:
1408 ankur.sing 2563 
      return result.success
3431 rajveer 2564 
    if result.ex is not None:
3064 chandransh 2565 
      raise result.ex
4910 phani.kuma 2566 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "markOrdersAsShippedFromWarehouse failed: unknown result");
1408 ankur.sing 2567 
 
5676 rajveer 2568 
  def markOrdersAsReturnedFromStore(self, providerId, orderIds):
2569 
    """
2570 
    Parameters:
2571 
     - providerId
2572 
     - orderIds
2573 
    """
2574 
    self.send_markOrdersAsReturnedFromStore(providerId, orderIds)
2575 
    return self.recv_markOrdersAsReturnedFromStore()
2576 
 
2577 
  def send_markOrdersAsReturnedFromStore(self, providerId, orderIds):
2578 
    self._oprot.writeMessageBegin('markOrdersAsReturnedFromStore', TMessageType.CALL, self._seqid)
2579 
    args = markOrdersAsReturnedFromStore_args()
2580 
    args.providerId = providerId
2581 
    args.orderIds = orderIds
2582 
    args.write(self._oprot)
2583 
    self._oprot.writeMessageEnd()
2584 
    self._oprot.trans.flush()
2585 
 
2586 
  def recv_markOrdersAsReturnedFromStore(self, ):
2587 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2588 
    if mtype == TMessageType.EXCEPTION:
2589 
      x = TApplicationException()
2590 
      x.read(self._iprot)
2591 
      self._iprot.readMessageEnd()
2592 
      raise x
2593 
    result = markOrdersAsReturnedFromStore_result()
2594 
    result.read(self._iprot)
2595 
    self._iprot.readMessageEnd()
2596 
    if result.success is not None:
2597 
      return result.success
2598 
    if result.ex is not None:
2599 
      raise result.ex
2600 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "markOrdersAsReturnedFromStore failed: unknown result");
2601 
 
4910 phani.kuma 2602 
  def markOrdersAsPickedUp(self, providerId, pickupDetails):
4410 rajveer 2603 
    """
4910 phani.kuma 2604 
    Marks all SHIPPED_FROM_WH orders of the previous day for a provider as SHIPPED_TO_LOGISTICS.
2605 
    Raises an exception if we encounter report for an AWB number that we did not ship.
4410 rajveer 2606 
 
2607 
    Parameters:
2608 
     - providerId
4910 phani.kuma 2609 
     - pickupDetails
4410 rajveer 2610 
    """
4910 phani.kuma 2611 
    self.send_markOrdersAsPickedUp(providerId, pickupDetails)
2612 
    self.recv_markOrdersAsPickedUp()
4410 rajveer 2613 
 
4910 phani.kuma 2614 
  def send_markOrdersAsPickedUp(self, providerId, pickupDetails):
2615 
    self._oprot.writeMessageBegin('markOrdersAsPickedUp', TMessageType.CALL, self._seqid)
2616 
    args = markOrdersAsPickedUp_args()
4410 rajveer 2617 
    args.providerId = providerId
4910 phani.kuma 2618 
    args.pickupDetails = pickupDetails
4410 rajveer 2619 
    args.write(self._oprot)
2620 
    self._oprot.writeMessageEnd()
2621 
    self._oprot.trans.flush()
2622 
 
4910 phani.kuma 2623 
  def recv_markOrdersAsPickedUp(self, ):
4410 rajveer 2624 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2625 
    if mtype == TMessageType.EXCEPTION:
2626 
      x = TApplicationException()
2627 
      x.read(self._iprot)
2628 
      self._iprot.readMessageEnd()
2629 
      raise x
4910 phani.kuma 2630 
    result = markOrdersAsPickedUp_result()
4410 rajveer 2631 
    result.read(self._iprot)
2632 
    self._iprot.readMessageEnd()
2633 
    if result.ex is not None:
2634 
      raise result.ex
4910 phani.kuma 2635 
    return
4410 rajveer 2636 
 
4910 phani.kuma 2637 
  def getOrdersNotPickedUp(self, providerId):
94 ashish 2638 
    """
3064 chandransh 2639 
    Returns a list of orders that were shipped from warehouse but did not appear in the pick-up report.
3431 rajveer 2640 
 
94 ashish 2641 
    Parameters:
3064 chandransh 2642 
     - providerId
304 ashish 2643 
    """
4910 phani.kuma 2644 
    self.send_getOrdersNotPickedUp(providerId)
2645 
    return self.recv_getOrdersNotPickedUp()
94 ashish 2646 
 
4910 phani.kuma 2647 
  def send_getOrdersNotPickedUp(self, providerId):
2648 
    self._oprot.writeMessageBegin('getOrdersNotPickedUp', TMessageType.CALL, self._seqid)
2649 
    args = getOrdersNotPickedUp_args()
3064 chandransh 2650 
    args.providerId = providerId
304 ashish 2651 
    args.write(self._oprot)
2652 
    self._oprot.writeMessageEnd()
2653 
    self._oprot.trans.flush()
2654 
 
4910 phani.kuma 2655 
  def recv_getOrdersNotPickedUp(self, ):
304 ashish 2656 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2657 
    if mtype == TMessageType.EXCEPTION:
2658 
      x = TApplicationException()
2659 
      x.read(self._iprot)
2660 
      self._iprot.readMessageEnd()
2661 
      raise x
4910 phani.kuma 2662 
    result = getOrdersNotPickedUp_result()
304 ashish 2663 
    result.read(self._iprot)
2664 
    self._iprot.readMessageEnd()
3431 rajveer 2665 
    if result.success is not None:
304 ashish 2666 
      return result.success
4910 phani.kuma 2667 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getOrdersNotPickedUp failed: unknown result");
304 ashish 2668 
 
3064 chandransh 2669 
  def markOrdersAsDelivered(self, providerId, deliveredOrders):
304 ashish 2670 
    """
3064 chandransh 2671 
    Marks all orders with AWBs in the given map as delivered. Also sets the delivery timestamp and
2672 
    the name of the receiver.
2673 
    Raises an exception if we encounter report for an AWB number that we did not ship.
3431 rajveer 2674 
 
304 ashish 2675 
    Parameters:
3064 chandransh 2676 
     - providerId
2677 
     - deliveredOrders
304 ashish 2678 
    """
3064 chandransh 2679 
    self.send_markOrdersAsDelivered(providerId, deliveredOrders)
2680 
    self.recv_markOrdersAsDelivered()
304 ashish 2681 
 
3064 chandransh 2682 
  def send_markOrdersAsDelivered(self, providerId, deliveredOrders):
2683 
    self._oprot.writeMessageBegin('markOrdersAsDelivered', TMessageType.CALL, self._seqid)
2684 
    args = markOrdersAsDelivered_args()
2685 
    args.providerId = providerId
2686 
    args.deliveredOrders = deliveredOrders
304 ashish 2687 
    args.write(self._oprot)
2688 
    self._oprot.writeMessageEnd()
2689 
    self._oprot.trans.flush()
2690 
 
3064 chandransh 2691 
  def recv_markOrdersAsDelivered(self, ):
304 ashish 2692 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2693 
    if mtype == TMessageType.EXCEPTION:
2694 
      x = TApplicationException()
2695 
      x.read(self._iprot)
2696 
      self._iprot.readMessageEnd()
2697 
      raise x
3064 chandransh 2698 
    result = markOrdersAsDelivered_result()
304 ashish 2699 
    result.read(self._iprot)
2700 
    self._iprot.readMessageEnd()
3431 rajveer 2701 
    if result.ex is not None:
3064 chandransh 2702 
      raise result.ex
304 ashish 2703 
    return
2704 
 
4910 phani.kuma 2705 
  def markAsRTOrders(self, providerId, returnedOrders):
1596 ankur.sing 2706 
    """
4910 phani.kuma 2707 
    Mark all orders with AWBs in the given map as RTO. Also sets the delivery timestamp.
3064 chandransh 2708 
    Raises an exception if we encounter report for an AWB number that we did not ship.
3431 rajveer 2709 
 
3064 chandransh 2710 
    Parameters:
2711 
     - providerId
2712 
     - returnedOrders
1596 ankur.sing 2713 
    """
4910 phani.kuma 2714 
    self.send_markAsRTOrders(providerId, returnedOrders)
2715 
    self.recv_markAsRTOrders()
304 ashish 2716 
 
4910 phani.kuma 2717 
  def send_markAsRTOrders(self, providerId, returnedOrders):
2718 
    self._oprot.writeMessageBegin('markAsRTOrders', TMessageType.CALL, self._seqid)
2719 
    args = markAsRTOrders_args()
3064 chandransh 2720 
    args.providerId = providerId
2721 
    args.returnedOrders = returnedOrders
1596 ankur.sing 2722 
    args.write(self._oprot)
2723 
    self._oprot.writeMessageEnd()
2724 
    self._oprot.trans.flush()
2725 
 
4910 phani.kuma 2726 
  def recv_markAsRTOrders(self, ):
1596 ankur.sing 2727 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2728 
    if mtype == TMessageType.EXCEPTION:
2729 
      x = TApplicationException()
2730 
      x.read(self._iprot)
2731 
      self._iprot.readMessageEnd()
2732 
      raise x
4910 phani.kuma 2733 
    result = markAsRTOrders_result()
1596 ankur.sing 2734 
    result.read(self._iprot)
2735 
    self._iprot.readMessageEnd()
3431 rajveer 2736 
    if result.ex is not None:
3064 chandransh 2737 
      raise result.ex
2738 
    return
1596 ankur.sing 2739 
 
4910 phani.kuma 2740 
  def getRTOrders(self, providerId):
2741 
    """
2742 
    Returns a list of orders that were returned by courier.
2743 
 
2744 
    Parameters:
2745 
     - providerId
2746 
    """
2747 
    self.send_getRTOrders(providerId)
2748 
    return self.recv_getRTOrders()
2749 
 
2750 
  def send_getRTOrders(self, providerId):
2751 
    self._oprot.writeMessageBegin('getRTOrders', TMessageType.CALL, self._seqid)
2752 
    args = getRTOrders_args()
2753 
    args.providerId = providerId
2754 
    args.write(self._oprot)
2755 
    self._oprot.writeMessageEnd()
2756 
    self._oprot.trans.flush()
2757 
 
2758 
  def recv_getRTOrders(self, ):
2759 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2760 
    if mtype == TMessageType.EXCEPTION:
2761 
      x = TApplicationException()
2762 
      x.read(self._iprot)
2763 
      self._iprot.readMessageEnd()
2764 
      raise x
2765 
    result = getRTOrders_result()
2766 
    result.read(self._iprot)
2767 
    self._iprot.readMessageEnd()
2768 
    if result.success is not None:
2769 
      return result.success
2770 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getRTOrders failed: unknown result");
2771 
 
3064 chandransh 2772 
  def updateNonDeliveryReason(self, providerId, undeliveredOrders):
1627 ankur.sing 2773 
    """
3064 chandransh 2774 
    Update the status description of orders whose AWB numbers are keys of the Map.
3431 rajveer 2775 
 
3064 chandransh 2776 
    Parameters:
2777 
     - providerId
2778 
     - undeliveredOrders
1627 ankur.sing 2779 
    """
3064 chandransh 2780 
    self.send_updateNonDeliveryReason(providerId, undeliveredOrders)
4910 phani.kuma 2781 
    self.recv_updateNonDeliveryReason()
1596 ankur.sing 2782 
 
3064 chandransh 2783 
  def send_updateNonDeliveryReason(self, providerId, undeliveredOrders):
2784 
    self._oprot.writeMessageBegin('updateNonDeliveryReason', TMessageType.CALL, self._seqid)
2785 
    args = updateNonDeliveryReason_args()
2786 
    args.providerId = providerId
2787 
    args.undeliveredOrders = undeliveredOrders
1627 ankur.sing 2788 
    args.write(self._oprot)
2789 
    self._oprot.writeMessageEnd()
2790 
    self._oprot.trans.flush()
2791 
 
3064 chandransh 2792 
  def recv_updateNonDeliveryReason(self, ):
1627 ankur.sing 2793 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2794 
    if mtype == TMessageType.EXCEPTION:
2795 
      x = TApplicationException()
2796 
      x.read(self._iprot)
2797 
      self._iprot.readMessageEnd()
2798 
      raise x
3064 chandransh 2799 
    result = updateNonDeliveryReason_result()
1627 ankur.sing 2800 
    result.read(self._iprot)
2801 
    self._iprot.readMessageEnd()
4910 phani.kuma 2802 
    if result.ex is not None:
2803 
      raise result.ex
2804 
    return
2805 
 
2806 
  def getNonDeliveredOrdersbyCourier(self, providerId):
2807 
    """
2808 
    Returns a list of orders that were picked up or shipped four days ago but did not get delivered.
2809 
 
2810 
    Parameters:
2811 
     - providerId
2812 
    """
2813 
    self.send_getNonDeliveredOrdersbyCourier(providerId)
2814 
    return self.recv_getNonDeliveredOrdersbyCourier()
2815 
 
2816 
  def send_getNonDeliveredOrdersbyCourier(self, providerId):
2817 
    self._oprot.writeMessageBegin('getNonDeliveredOrdersbyCourier', TMessageType.CALL, self._seqid)
2818 
    args = getNonDeliveredOrdersbyCourier_args()
2819 
    args.providerId = providerId
2820 
    args.write(self._oprot)
2821 
    self._oprot.writeMessageEnd()
2822 
    self._oprot.trans.flush()
2823 
 
2824 
  def recv_getNonDeliveredOrdersbyCourier(self, ):
2825 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2826 
    if mtype == TMessageType.EXCEPTION:
2827 
      x = TApplicationException()
2828 
      x.read(self._iprot)
2829 
      self._iprot.readMessageEnd()
2830 
      raise x
2831 
    result = getNonDeliveredOrdersbyCourier_result()
2832 
    result.read(self._iprot)
2833 
    self._iprot.readMessageEnd()
4581 phani.kuma 2834 
    if result.success is not None:
2835 
      return result.success
4910 phani.kuma 2836 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getNonDeliveredOrdersbyCourier failed: unknown result");
2837 
 
2838 
  def markOrdersAsLocalConnected(self, providerId, local_connected_orders):
2839 
    """
2840 
    Mark all orders with AWBs in the given map as local connected. Also sets the local connected timestamp.
2841 
 
2842 
    Parameters:
2843 
     - providerId
2844 
     - local_connected_orders
2845 
    """
2846 
    self.send_markOrdersAsLocalConnected(providerId, local_connected_orders)
2847 
    self.recv_markOrdersAsLocalConnected()
2848 
 
2849 
  def send_markOrdersAsLocalConnected(self, providerId, local_connected_orders):
2850 
    self._oprot.writeMessageBegin('markOrdersAsLocalConnected', TMessageType.CALL, self._seqid)
2851 
    args = markOrdersAsLocalConnected_args()
2852 
    args.providerId = providerId
2853 
    args.local_connected_orders = local_connected_orders
2854 
    args.write(self._oprot)
2855 
    self._oprot.writeMessageEnd()
2856 
    self._oprot.trans.flush()
2857 
 
2858 
  def recv_markOrdersAsLocalConnected(self, ):
2859 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2860 
    if mtype == TMessageType.EXCEPTION:
2861 
      x = TApplicationException()
2862 
      x.read(self._iprot)
2863 
      self._iprot.readMessageEnd()
2864 
      raise x
2865 
    result = markOrdersAsLocalConnected_result()
2866 
    result.read(self._iprot)
2867 
    self._iprot.readMessageEnd()
3431 rajveer 2868 
    if result.ex is not None:
3064 chandransh 2869 
      raise result.ex
4910 phani.kuma 2870 
    return
1627 ankur.sing 2871 
 
4910 phani.kuma 2872 
  def getOrdersNotLocalConnected(self, providerId):
2873 
    """
2874 
    Returns a list of orders that were picked up or shipped but pending local connection.
2875 
 
2876 
    Parameters:
2877 
     - providerId
2878 
    """
2879 
    self.send_getOrdersNotLocalConnected(providerId)
2880 
    return self.recv_getOrdersNotLocalConnected()
2881 
 
2882 
  def send_getOrdersNotLocalConnected(self, providerId):
2883 
    self._oprot.writeMessageBegin('getOrdersNotLocalConnected', TMessageType.CALL, self._seqid)
2884 
    args = getOrdersNotLocalConnected_args()
2885 
    args.providerId = providerId
2886 
    args.write(self._oprot)
2887 
    self._oprot.writeMessageEnd()
2888 
    self._oprot.trans.flush()
2889 
 
2890 
  def recv_getOrdersNotLocalConnected(self, ):
2891 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2892 
    if mtype == TMessageType.EXCEPTION:
2893 
      x = TApplicationException()
2894 
      x.read(self._iprot)
2895 
      self._iprot.readMessageEnd()
2896 
      raise x
2897 
    result = getOrdersNotLocalConnected_result()
2898 
    result.read(self._iprot)
2899 
    self._iprot.readMessageEnd()
2900 
    if result.success is not None:
2901 
      return result.success
2902 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getOrdersNotLocalConnected failed: unknown result");
2903 
 
2904 
  def markOrdersAsDestinationCityReached(self, providerId, destination_city_reached_orders):
2905 
    """
2906 
    Mark all orders with AWBs in the given map as reached destination city. Also sets the reached destination timestamp.
2907 
 
2908 
    Parameters:
2909 
     - providerId
2910 
     - destination_city_reached_orders
2911 
    """
2912 
    self.send_markOrdersAsDestinationCityReached(providerId, destination_city_reached_orders)
2913 
    self.recv_markOrdersAsDestinationCityReached()
2914 
 
2915 
  def send_markOrdersAsDestinationCityReached(self, providerId, destination_city_reached_orders):
2916 
    self._oprot.writeMessageBegin('markOrdersAsDestinationCityReached', TMessageType.CALL, self._seqid)
2917 
    args = markOrdersAsDestinationCityReached_args()
2918 
    args.providerId = providerId
2919 
    args.destination_city_reached_orders = destination_city_reached_orders
2920 
    args.write(self._oprot)
2921 
    self._oprot.writeMessageEnd()
2922 
    self._oprot.trans.flush()
2923 
 
2924 
  def recv_markOrdersAsDestinationCityReached(self, ):
2925 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2926 
    if mtype == TMessageType.EXCEPTION:
2927 
      x = TApplicationException()
2928 
      x.read(self._iprot)
2929 
      self._iprot.readMessageEnd()
2930 
      raise x
2931 
    result = markOrdersAsDestinationCityReached_result()
2932 
    result.read(self._iprot)
2933 
    self._iprot.readMessageEnd()
2934 
    if result.ex is not None:
2935 
      raise result.ex
2936 
    return
2937 
 
2938 
  def markOrdersAsFirstDeliveryAttempted(self, providerId, first_atdl_orders):
2939 
    """
2940 
    Mark all orders with AWBs in the given map as first delivery attempt made. Also sets the first delivery attempted timestamp.
2941 
 
2942 
    Parameters:
2943 
     - providerId
2944 
     - first_atdl_orders
2945 
    """
2946 
    self.send_markOrdersAsFirstDeliveryAttempted(providerId, first_atdl_orders)
2947 
    self.recv_markOrdersAsFirstDeliveryAttempted()
2948 
 
2949 
  def send_markOrdersAsFirstDeliveryAttempted(self, providerId, first_atdl_orders):
2950 
    self._oprot.writeMessageBegin('markOrdersAsFirstDeliveryAttempted', TMessageType.CALL, self._seqid)
2951 
    args = markOrdersAsFirstDeliveryAttempted_args()
2952 
    args.providerId = providerId
2953 
    args.first_atdl_orders = first_atdl_orders
2954 
    args.write(self._oprot)
2955 
    self._oprot.writeMessageEnd()
2956 
    self._oprot.trans.flush()
2957 
 
2958 
  def recv_markOrdersAsFirstDeliveryAttempted(self, ):
2959 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2960 
    if mtype == TMessageType.EXCEPTION:
2961 
      x = TApplicationException()
2962 
      x.read(self._iprot)
2963 
      self._iprot.readMessageEnd()
2964 
      raise x
2965 
    result = markOrdersAsFirstDeliveryAttempted_result()
2966 
    result.read(self._iprot)
2967 
    self._iprot.readMessageEnd()
2968 
    if result.ex is not None:
2969 
      raise result.ex
2970 
    return
2971 
 
3064 chandransh 2972 
  def getUndeliveredOrders(self, providerId, warehouseId):
1627 ankur.sing 2973 
    """
3064 chandransh 2974 
    Returns the list of orders whose delivery time has passed but have not been
2975 
    delivered yet for the given provider and warehouse. To get a complete list of
2976 
    undelivered orders, pass them as -1.
2977 
    Returns an empty list if no such orders exist.
3431 rajveer 2978 
 
1886 ankur.sing 2979 
    Parameters:
3064 chandransh 2980 
     - providerId
2981 
     - warehouseId
1886 ankur.sing 2982 
    """
3064 chandransh 2983 
    self.send_getUndeliveredOrders(providerId, warehouseId)
2984 
    return self.recv_getUndeliveredOrders()
1627 ankur.sing 2985 
 
3064 chandransh 2986 
  def send_getUndeliveredOrders(self, providerId, warehouseId):
2987 
    self._oprot.writeMessageBegin('getUndeliveredOrders', TMessageType.CALL, self._seqid)
2988 
    args = getUndeliveredOrders_args()
2989 
    args.providerId = providerId
2990 
    args.warehouseId = warehouseId
1886 ankur.sing 2991 
    args.write(self._oprot)
2992 
    self._oprot.writeMessageEnd()
2993 
    self._oprot.trans.flush()
2994 
 
3064 chandransh 2995 
  def recv_getUndeliveredOrders(self, ):
1886 ankur.sing 2996 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2997 
    if mtype == TMessageType.EXCEPTION:
2998 
      x = TApplicationException()
2999 
      x.read(self._iprot)
3000 
      self._iprot.readMessageEnd()
3001 
      raise x
3064 chandransh 3002 
    result = getUndeliveredOrders_result()
1886 ankur.sing 3003 
    result.read(self._iprot)
3004 
    self._iprot.readMessageEnd()
3431 rajveer 3005 
    if result.success is not None:
1886 ankur.sing 3006 
      return result.success
3064 chandransh 3007 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getUndeliveredOrders failed: unknown result");
1886 ankur.sing 3008 
 
4783 phani.kuma 3009 
  def getUndeliveredOrdersExpectedDeliveryDateNotMet(self, ):
3010 
    """
3011 
    Returns the list of orders whose expected delivery date has passed but have not been
3012 
    delivered yet.
3013 
    Returns an empty list if no such orders exist.
3014 
    """
3015 
    self.send_getUndeliveredOrdersExpectedDeliveryDateNotMet()
3016 
    return self.recv_getUndeliveredOrdersExpectedDeliveryDateNotMet()
3017 
 
3018 
  def send_getUndeliveredOrdersExpectedDeliveryDateNotMet(self, ):
3019 
    self._oprot.writeMessageBegin('getUndeliveredOrdersExpectedDeliveryDateNotMet', TMessageType.CALL, self._seqid)
3020 
    args = getUndeliveredOrdersExpectedDeliveryDateNotMet_args()
3021 
    args.write(self._oprot)
3022 
    self._oprot.writeMessageEnd()
3023 
    self._oprot.trans.flush()
3024 
 
3025 
  def recv_getUndeliveredOrdersExpectedDeliveryDateNotMet(self, ):
3026 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3027 
    if mtype == TMessageType.EXCEPTION:
3028 
      x = TApplicationException()
3029 
      x.read(self._iprot)
3030 
      self._iprot.readMessageEnd()
3031 
      raise x
3032 
    result = getUndeliveredOrdersExpectedDeliveryDateNotMet_result()
3033 
    result.read(self._iprot)
3034 
    self._iprot.readMessageEnd()
3035 
    if result.success is not None:
3036 
      return result.success
3037 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getUndeliveredOrdersExpectedDeliveryDateNotMet failed: unknown result");
3038 
 
2536 chandransh 3039 
  def toggleDOAFlag(self, orderId):
3040 
    """
3041 
    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.
3042 
    Returns the final flag status.
3043 
    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 3044 
 
2536 chandransh 3045 
    Parameters:
3046 
     - orderId
3047 
    """
3048 
    self.send_toggleDOAFlag(orderId)
3049 
    return self.recv_toggleDOAFlag()
1886 ankur.sing 3050 
 
2536 chandransh 3051 
  def send_toggleDOAFlag(self, orderId):
3052 
    self._oprot.writeMessageBegin('toggleDOAFlag', TMessageType.CALL, self._seqid)
3053 
    args = toggleDOAFlag_args()
3054 
    args.orderId = orderId
3055 
    args.write(self._oprot)
3056 
    self._oprot.writeMessageEnd()
3057 
    self._oprot.trans.flush()
3058 
 
3059 
  def recv_toggleDOAFlag(self, ):
3060 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3061 
    if mtype == TMessageType.EXCEPTION:
3062 
      x = TApplicationException()
3063 
      x.read(self._iprot)
3064 
      self._iprot.readMessageEnd()
3065 
      raise x
3066 
    result = toggleDOAFlag_result()
3067 
    result.read(self._iprot)
3068 
    self._iprot.readMessageEnd()
3431 rajveer 3069 
    if result.success is not None:
2536 chandransh 3070 
      return result.success
3431 rajveer 3071 
    if result.ex is not None:
2536 chandransh 3072 
      raise result.ex
3073 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "toggleDOAFlag failed: unknown result");
3074 
 
4712 rajveer 3075 
  def markOrderAsDelivered(self, orderId, deliveryTimestamp, receiver):
3076 
    """
3077 
    Parameters:
3078 
     - orderId
3079 
     - deliveryTimestamp
3080 
     - receiver
3081 
    """
3082 
    self.send_markOrderAsDelivered(orderId, deliveryTimestamp, receiver)
3083 
    self.recv_markOrderAsDelivered()
3084 
 
3085 
  def send_markOrderAsDelivered(self, orderId, deliveryTimestamp, receiver):
3086 
    self._oprot.writeMessageBegin('markOrderAsDelivered', TMessageType.CALL, self._seqid)
3087 
    args = markOrderAsDelivered_args()
3088 
    args.orderId = orderId
3089 
    args.deliveryTimestamp = deliveryTimestamp
3090 
    args.receiver = receiver
3091 
    args.write(self._oprot)
3092 
    self._oprot.writeMessageEnd()
3093 
    self._oprot.trans.flush()
3094 
 
3095 
  def recv_markOrderAsDelivered(self, ):
3096 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3097 
    if mtype == TMessageType.EXCEPTION:
3098 
      x = TApplicationException()
3099 
      x.read(self._iprot)
3100 
      self._iprot.readMessageEnd()
3101 
      raise x
3102 
    result = markOrderAsDelivered_result()
3103 
    result.read(self._iprot)
3104 
    self._iprot.readMessageEnd()
3105 
    if result.ex is not None:
3106 
      raise result.ex
3107 
    return
3108 
 
5553 rajveer 3109 
  def markOrderAsReceivedAtStore(self, orderId, deliveryTimestamp):
3110 
    """
3111 
    Parameters:
3112 
     - orderId
3113 
     - deliveryTimestamp
3114 
    """
3115 
    self.send_markOrderAsReceivedAtStore(orderId, deliveryTimestamp)
3116 
    self.recv_markOrderAsReceivedAtStore()
3117 
 
3118 
  def send_markOrderAsReceivedAtStore(self, orderId, deliveryTimestamp):
3119 
    self._oprot.writeMessageBegin('markOrderAsReceivedAtStore', TMessageType.CALL, self._seqid)
3120 
    args = markOrderAsReceivedAtStore_args()
3121 
    args.orderId = orderId
3122 
    args.deliveryTimestamp = deliveryTimestamp
3123 
    args.write(self._oprot)
3124 
    self._oprot.writeMessageEnd()
3125 
    self._oprot.trans.flush()
3126 
 
3127 
  def recv_markOrderAsReceivedAtStore(self, ):
3128 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3129 
    if mtype == TMessageType.EXCEPTION:
3130 
      x = TApplicationException()
3131 
      x.read(self._iprot)
3132 
      self._iprot.readMessageEnd()
3133 
      raise x
3134 
    result = markOrderAsReceivedAtStore_result()
3135 
    result.read(self._iprot)
3136 
    self._iprot.readMessageEnd()
3137 
    if result.ex is not None:
3138 
      raise result.ex
3139 
    return
3140 
 
4454 rajveer 3141 
  def markOrderDoaRequestReceived(self, orderId):
3142 
    """
3143 
    Once user raise the request for a DOA, order status will be changed from DELVIERY_SUCCESS to DOA_REQUEST_RECEIVED
3144 
 
3145 
    Parameters:
3146 
     - orderId
3147 
    """
3148 
    self.send_markOrderDoaRequestReceived(orderId)
3149 
    return self.recv_markOrderDoaRequestReceived()
3150 
 
3151 
  def send_markOrderDoaRequestReceived(self, orderId):
3152 
    self._oprot.writeMessageBegin('markOrderDoaRequestReceived', TMessageType.CALL, self._seqid)
3153 
    args = markOrderDoaRequestReceived_args()
3154 
    args.orderId = orderId
3155 
    args.write(self._oprot)
3156 
    self._oprot.writeMessageEnd()
3157 
    self._oprot.trans.flush()
3158 
 
3159 
  def recv_markOrderDoaRequestReceived(self, ):
3160 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3161 
    if mtype == TMessageType.EXCEPTION:
3162 
      x = TApplicationException()
3163 
      x.read(self._iprot)
3164 
      self._iprot.readMessageEnd()
3165 
      raise x
3166 
    result = markOrderDoaRequestReceived_result()
3167 
    result.read(self._iprot)
3168 
    self._iprot.readMessageEnd()
3169 
    if result.success is not None:
3170 
      return result.success
3171 
    if result.ex is not None:
3172 
      raise result.ex
3173 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "markOrderDoaRequestReceived failed: unknown result");
3174 
 
3175 
  def markOrderDoaRequestAuthorized(self, orderId, isAuthorized):
3176 
    """
3177 
    CRM person can authorize or deny the request reised by customer. If he authorizes order will change from DOA_REQUEST_RECEIVED
3178 
    to DOA_REQUEST_AUTHORIZED. If he denies, status will be changed back to DELVIERY_SUCCESS.
3179 
 
3180 
    Parameters:
3181 
     - orderId
3182 
     - isAuthorized
3183 
    """
3184 
    self.send_markOrderDoaRequestAuthorized(orderId, isAuthorized)
3185 
    return self.recv_markOrderDoaRequestAuthorized()
3186 
 
3187 
  def send_markOrderDoaRequestAuthorized(self, orderId, isAuthorized):
3188 
    self._oprot.writeMessageBegin('markOrderDoaRequestAuthorized', TMessageType.CALL, self._seqid)
3189 
    args = markOrderDoaRequestAuthorized_args()
3190 
    args.orderId = orderId
3191 
    args.isAuthorized = isAuthorized
3192 
    args.write(self._oprot)
3193 
    self._oprot.writeMessageEnd()
3194 
    self._oprot.trans.flush()
3195 
 
3196 
  def recv_markOrderDoaRequestAuthorized(self, ):
3197 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3198 
    if mtype == TMessageType.EXCEPTION:
3199 
      x = TApplicationException()
3200 
      x.read(self._iprot)
3201 
      self._iprot.readMessageEnd()
3202 
      raise x
3203 
    result = markOrderDoaRequestAuthorized_result()
3204 
    result.read(self._iprot)
3205 
    self._iprot.readMessageEnd()
3206 
    if result.success is not None:
3207 
      return result.success
3208 
    if result.ex is not None:
3209 
      raise result.ex
3210 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "markOrderDoaRequestAuthorized failed: unknown result");
3211 
 
4488 rajveer 3212 
  def markOrderReturnRequestReceived(self, orderId):
3213 
    """
3214 
    Once user raise the request for a RET, order status will be changed from DELVIERY_SUCCESS to RET_REQUEST_RECEIVED
3215 
 
3216 
    Parameters:
3217 
     - orderId
3218 
    """
3219 
    self.send_markOrderReturnRequestReceived(orderId)
3220 
    return self.recv_markOrderReturnRequestReceived()
3221 
 
3222 
  def send_markOrderReturnRequestReceived(self, orderId):
3223 
    self._oprot.writeMessageBegin('markOrderReturnRequestReceived', TMessageType.CALL, self._seqid)
3224 
    args = markOrderReturnRequestReceived_args()
3225 
    args.orderId = orderId
3226 
    args.write(self._oprot)
3227 
    self._oprot.writeMessageEnd()
3228 
    self._oprot.trans.flush()
3229 
 
3230 
  def recv_markOrderReturnRequestReceived(self, ):
3231 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3232 
    if mtype == TMessageType.EXCEPTION:
3233 
      x = TApplicationException()
3234 
      x.read(self._iprot)
3235 
      self._iprot.readMessageEnd()
3236 
      raise x
3237 
    result = markOrderReturnRequestReceived_result()
3238 
    result.read(self._iprot)
3239 
    self._iprot.readMessageEnd()
3240 
    if result.success is not None:
3241 
      return result.success
3242 
    if result.ex is not None:
3243 
      raise result.ex
3244 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "markOrderReturnRequestReceived failed: unknown result");
3245 
 
3246 
  def markOrderReturnRequestAuthorized(self, orderId, isAuthorized):
3247 
    """
3248 
    CRM person can authorize or deny the request reised by customer. If he authorizes order will change from RET_REQUEST_RECEIVED
3249 
    to RET_REQUEST_AUTHORIZED. If he denies, status will be changed back to DELVIERY_SUCCESS.
3250 
 
3251 
    Parameters:
3252 
     - orderId
3253 
     - isAuthorized
3254 
    """
3255 
    self.send_markOrderReturnRequestAuthorized(orderId, isAuthorized)
3256 
    return self.recv_markOrderReturnRequestAuthorized()
3257 
 
3258 
  def send_markOrderReturnRequestAuthorized(self, orderId, isAuthorized):
3259 
    self._oprot.writeMessageBegin('markOrderReturnRequestAuthorized', TMessageType.CALL, self._seqid)
3260 
    args = markOrderReturnRequestAuthorized_args()
3261 
    args.orderId = orderId
3262 
    args.isAuthorized = isAuthorized
3263 
    args.write(self._oprot)
3264 
    self._oprot.writeMessageEnd()
3265 
    self._oprot.trans.flush()
3266 
 
3267 
  def recv_markOrderReturnRequestAuthorized(self, ):
3268 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3269 
    if mtype == TMessageType.EXCEPTION:
3270 
      x = TApplicationException()
3271 
      x.read(self._iprot)
3272 
      self._iprot.readMessageEnd()
3273 
      raise x
3274 
    result = markOrderReturnRequestAuthorized_result()
3275 
    result.read(self._iprot)
3276 
    self._iprot.readMessageEnd()
3277 
    if result.success is not None:
3278 
      return result.success
3279 
    if result.ex is not None:
3280 
      raise result.ex
3281 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "markOrderReturnRequestAuthorized failed: unknown result");
3282 
 
4579 rajveer 3283 
  def requestPickupNumber(self, orderId, providerId):
2536 chandransh 3284 
    """
3285 
    Sends out an email to the account manager of the original courier provider used to ship the order.
4452 rajveer 3286 
    If the order status was DELIVERY_SUCCESS, it is changed to be DOA_PICKUP_REQUEST_RAISED.
3287 
    If the order status was DOA_PICKUP_REQUEST_RAISED, it is left unchanged.
2536 chandransh 3288 
    For any other status, it returns false.
3289 
    Throws an exception if the order with the given id couldn't be found.
3431 rajveer 3290 
 
2536 chandransh 3291 
    Parameters:
3292 
     - orderId
4579 rajveer 3293 
     - providerId
2536 chandransh 3294 
    """
4579 rajveer 3295 
    self.send_requestPickupNumber(orderId, providerId)
2536 chandransh 3296 
    return self.recv_requestPickupNumber()
3297 
 
4579 rajveer 3298 
  def send_requestPickupNumber(self, orderId, providerId):
2536 chandransh 3299 
    self._oprot.writeMessageBegin('requestPickupNumber', TMessageType.CALL, self._seqid)
3300 
    args = requestPickupNumber_args()
3301 
    args.orderId = orderId
4579 rajveer 3302 
    args.providerId = providerId
2536 chandransh 3303 
    args.write(self._oprot)
3304 
    self._oprot.writeMessageEnd()
3305 
    self._oprot.trans.flush()
3306 
 
3307 
  def recv_requestPickupNumber(self, ):
3308 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3309 
    if mtype == TMessageType.EXCEPTION:
3310 
      x = TApplicationException()
3311 
      x.read(self._iprot)
3312 
      self._iprot.readMessageEnd()
3313 
      raise x
3314 
    result = requestPickupNumber_result()
3315 
    result.read(self._iprot)
3316 
    self._iprot.readMessageEnd()
3431 rajveer 3317 
    if result.success is not None:
2536 chandransh 3318 
      return result.success
3431 rajveer 3319 
    if result.ex is not None:
2536 chandransh 3320 
      raise result.ex
3321 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "requestPickupNumber failed: unknown result");
3322 
 
4602 rajveer 3323 
  def authorizePickup(self, orderId, pickupNumber, providerId):
2536 chandransh 3324 
    """
4452 rajveer 3325 
    If the order status is DOA_PICKUP_REQUEST_RAISED, it does the following
2536 chandransh 3326 
    	1. Sends out an email to the customer with the dispatch advice that he has to print as an attachment.
3327 
    	2. Changes order status to be DOA_PICKUP_AUTHORIZED.
3328 
    	3. Returns true
2591 chandransh 3329 
    If the order is in any other status, it returns false.
2536 chandransh 3330 
    Throws an exception if the order with the given id couldn't be found.
3431 rajveer 3331 
 
2536 chandransh 3332 
    Parameters:
3333 
     - orderId
3334 
     - pickupNumber
4602 rajveer 3335 
     - providerId
2536 chandransh 3336 
    """
4602 rajveer 3337 
    self.send_authorizePickup(orderId, pickupNumber, providerId)
2536 chandransh 3338 
    return self.recv_authorizePickup()
3339 
 
4602 rajveer 3340 
  def send_authorizePickup(self, orderId, pickupNumber, providerId):
2536 chandransh 3341 
    self._oprot.writeMessageBegin('authorizePickup', TMessageType.CALL, self._seqid)
3342 
    args = authorizePickup_args()
3343 
    args.orderId = orderId
3344 
    args.pickupNumber = pickupNumber
4602 rajveer 3345 
    args.providerId = providerId
2536 chandransh 3346 
    args.write(self._oprot)
3347 
    self._oprot.writeMessageEnd()
3348 
    self._oprot.trans.flush()
3349 
 
3350 
  def recv_authorizePickup(self, ):
3351 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3352 
    if mtype == TMessageType.EXCEPTION:
3353 
      x = TApplicationException()
3354 
      x.read(self._iprot)
3355 
      self._iprot.readMessageEnd()
3356 
      raise x
3357 
    result = authorizePickup_result()
3358 
    result.read(self._iprot)
3359 
    self._iprot.readMessageEnd()
3431 rajveer 3360 
    if result.success is not None:
2536 chandransh 3361 
      return result.success
3431 rajveer 3362 
    if result.ex is not None:
2536 chandransh 3363 
      raise result.ex
3364 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "authorizePickup failed: unknown result");
3365 
 
2764 chandransh 3366 
  def markDoasAsPickedUp(self, providerId, pickupDetails):
3367 
    """
3368 
    Marks all DOA_PICKUP_AUTHORIZED orders of the previous day for a provider as DOA_RETURN_IN_TRANSIT.
3431 rajveer 3369 
 
2764 chandransh 3370 
    Parameters:
3371 
     - providerId
3372 
     - pickupDetails
3373 
    """
3374 
    self.send_markDoasAsPickedUp(providerId, pickupDetails)
4910 phani.kuma 3375 
    self.recv_markDoasAsPickedUp()
2764 chandransh 3376 
 
3377 
  def send_markDoasAsPickedUp(self, providerId, pickupDetails):
3378 
    self._oprot.writeMessageBegin('markDoasAsPickedUp', TMessageType.CALL, self._seqid)
3379 
    args = markDoasAsPickedUp_args()
3380 
    args.providerId = providerId
3381 
    args.pickupDetails = pickupDetails
3382 
    args.write(self._oprot)
3383 
    self._oprot.writeMessageEnd()
3384 
    self._oprot.trans.flush()
3385 
 
3386 
  def recv_markDoasAsPickedUp(self, ):
3387 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3388 
    if mtype == TMessageType.EXCEPTION:
3389 
      x = TApplicationException()
3390 
      x.read(self._iprot)
3391 
      self._iprot.readMessageEnd()
3392 
      raise x
3393 
    result = markDoasAsPickedUp_result()
3394 
    result.read(self._iprot)
3395 
    self._iprot.readMessageEnd()
4910 phani.kuma 3396 
    return
3397 
 
3398 
  def getDoasNotPickedUp(self, providerId):
3399 
    """
3400 
    Returns a list of orders that were authorized for pickup but did not appear in the pick-up report.
3401 
 
3402 
    Parameters:
3403 
     - providerId
3404 
    """
3405 
    self.send_getDoasNotPickedUp(providerId)
3406 
    return self.recv_getDoasNotPickedUp()
3407 
 
3408 
  def send_getDoasNotPickedUp(self, providerId):
3409 
    self._oprot.writeMessageBegin('getDoasNotPickedUp', TMessageType.CALL, self._seqid)
3410 
    args = getDoasNotPickedUp_args()
3411 
    args.providerId = providerId
3412 
    args.write(self._oprot)
3413 
    self._oprot.writeMessageEnd()
3414 
    self._oprot.trans.flush()
3415 
 
3416 
  def recv_getDoasNotPickedUp(self, ):
3417 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3418 
    if mtype == TMessageType.EXCEPTION:
3419 
      x = TApplicationException()
3420 
      x.read(self._iprot)
3421 
      self._iprot.readMessageEnd()
3422 
      raise x
3423 
    result = getDoasNotPickedUp_result()
3424 
    result.read(self._iprot)
3425 
    self._iprot.readMessageEnd()
3431 rajveer 3426 
    if result.success is not None:
2764 chandransh 3427 
      return result.success
4910 phani.kuma 3428 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getDoasNotPickedUp failed: unknown result");
2764 chandransh 3429 
 
4741 phani.kuma 3430 
  def markReturnOrdersAsPickedUp(self, providerId, pickupDetails):
3431 
    """
3432 
    Marks all RET_PICKUP_CONFIRMED orders of the previous day for a provider as RET_RETURN_IN_TRANSIT.
3433 
 
3434 
    Parameters:
3435 
     - providerId
3436 
     - pickupDetails
3437 
    """
3438 
    self.send_markReturnOrdersAsPickedUp(providerId, pickupDetails)
4910 phani.kuma 3439 
    self.recv_markReturnOrdersAsPickedUp()
4741 phani.kuma 3440 
 
3441 
  def send_markReturnOrdersAsPickedUp(self, providerId, pickupDetails):
3442 
    self._oprot.writeMessageBegin('markReturnOrdersAsPickedUp', TMessageType.CALL, self._seqid)
3443 
    args = markReturnOrdersAsPickedUp_args()
3444 
    args.providerId = providerId
3445 
    args.pickupDetails = pickupDetails
3446 
    args.write(self._oprot)
3447 
    self._oprot.writeMessageEnd()
3448 
    self._oprot.trans.flush()
3449 
 
3450 
  def recv_markReturnOrdersAsPickedUp(self, ):
3451 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3452 
    if mtype == TMessageType.EXCEPTION:
3453 
      x = TApplicationException()
3454 
      x.read(self._iprot)
3455 
      self._iprot.readMessageEnd()
3456 
      raise x
3457 
    result = markReturnOrdersAsPickedUp_result()
3458 
    result.read(self._iprot)
3459 
    self._iprot.readMessageEnd()
4910 phani.kuma 3460 
    return
3461 
 
3462 
  def getReturnOrdersNotPickedUp(self, providerId):
3463 
    """
3464 
    Returns a list of orders that were authorized for pickup but did not appear in the pick-up report.
3465 
 
3466 
    Parameters:
3467 
     - providerId
3468 
    """
3469 
    self.send_getReturnOrdersNotPickedUp(providerId)
3470 
    return self.recv_getReturnOrdersNotPickedUp()
3471 
 
3472 
  def send_getReturnOrdersNotPickedUp(self, providerId):
3473 
    self._oprot.writeMessageBegin('getReturnOrdersNotPickedUp', TMessageType.CALL, self._seqid)
3474 
    args = getReturnOrdersNotPickedUp_args()
3475 
    args.providerId = providerId
3476 
    args.write(self._oprot)
3477 
    self._oprot.writeMessageEnd()
3478 
    self._oprot.trans.flush()
3479 
 
3480 
  def recv_getReturnOrdersNotPickedUp(self, ):
3481 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3482 
    if mtype == TMessageType.EXCEPTION:
3483 
      x = TApplicationException()
3484 
      x.read(self._iprot)
3485 
      self._iprot.readMessageEnd()
3486 
      raise x
3487 
    result = getReturnOrdersNotPickedUp_result()
3488 
    result.read(self._iprot)
3489 
    self._iprot.readMessageEnd()
4741 phani.kuma 3490 
    if result.success is not None:
3491 
      return result.success
4910 phani.kuma 3492 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getReturnOrdersNotPickedUp failed: unknown result");
4741 phani.kuma 3493 
 
4479 rajveer 3494 
  def receiveReturn(self, orderId, receiveCondition):
2591 chandransh 3495 
    """
4452 rajveer 3496 
    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 3497 
    If the order status is RTO_IN_TRANSIT, marks the order status as RTO_RECEIVED_PRESTINE and returns true.
2591 chandransh 3498 
    If the order is in any other state, it returns false.
3499 
    Throws an exception if the order with the given id couldn't be found.
3431 rajveer 3500 
 
2591 chandransh 3501 
    Parameters:
3502 
     - orderId
4479 rajveer 3503 
     - receiveCondition
2591 chandransh 3504 
    """
4479 rajveer 3505 
    self.send_receiveReturn(orderId, receiveCondition)
2616 chandransh 3506 
    return self.recv_receiveReturn()
2536 chandransh 3507 
 
4479 rajveer 3508 
  def send_receiveReturn(self, orderId, receiveCondition):
2616 chandransh 3509 
    self._oprot.writeMessageBegin('receiveReturn', TMessageType.CALL, self._seqid)
3510 
    args = receiveReturn_args()
2591 chandransh 3511 
    args.orderId = orderId
4479 rajveer 3512 
    args.receiveCondition = receiveCondition
2591 chandransh 3513 
    args.write(self._oprot)
3514 
    self._oprot.writeMessageEnd()
3515 
    self._oprot.trans.flush()
3516 
 
2616 chandransh 3517 
  def recv_receiveReturn(self, ):
2591 chandransh 3518 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3519 
    if mtype == TMessageType.EXCEPTION:
3520 
      x = TApplicationException()
3521 
      x.read(self._iprot)
3522 
      self._iprot.readMessageEnd()
3523 
      raise x
2616 chandransh 3524 
    result = receiveReturn_result()
2591 chandransh 3525 
    result.read(self._iprot)
3526 
    self._iprot.readMessageEnd()
3431 rajveer 3527 
    if result.success is not None:
2591 chandransh 3528 
      return result.success
3431 rajveer 3529 
    if result.ex is not None:
2591 chandransh 3530 
      raise result.ex
2616 chandransh 3531 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "receiveReturn failed: unknown result");
2591 chandransh 3532 
 
3533 
  def validateDoa(self, orderId, isValid):
3534 
    """
4452 rajveer 3535 
    Used to validate the DOA certificate for an order in the DOA_RECEIVED_PRESTINE state. If the certificate is valid,
2616 chandransh 3536 
    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 3537 
    If the order is in any other state, it returns false.
3538 
    Throws an exception if the order with the given id couldn't be found.
3431 rajveer 3539 
 
2591 chandransh 3540 
    Parameters:
3541 
     - orderId
3542 
     - isValid
3543 
    """
3544 
    self.send_validateDoa(orderId, isValid)
3545 
    return self.recv_validateDoa()
3546 
 
3547 
  def send_validateDoa(self, orderId, isValid):
3548 
    self._oprot.writeMessageBegin('validateDoa', TMessageType.CALL, self._seqid)
3549 
    args = validateDoa_args()
3550 
    args.orderId = orderId
3551 
    args.isValid = isValid
3552 
    args.write(self._oprot)
3553 
    self._oprot.writeMessageEnd()
3554 
    self._oprot.trans.flush()
3555 
 
3556 
  def recv_validateDoa(self, ):
3557 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3558 
    if mtype == TMessageType.EXCEPTION:
3559 
      x = TApplicationException()
3560 
      x.read(self._iprot)
3561 
      self._iprot.readMessageEnd()
3562 
      raise x
3563 
    result = validateDoa_result()
3564 
    result.read(self._iprot)
3565 
    self._iprot.readMessageEnd()
3431 rajveer 3566 
    if result.success is not None:
2591 chandransh 3567 
      return result.success
3431 rajveer 3568 
    if result.ex is not None:
2591 chandransh 3569 
      raise result.ex
3570 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "validateDoa failed: unknown result");
3571 
 
4495 rajveer 3572 
  def validateReturnProduct(self, orderId, isUsable):
3573 
    """
3574 
    Parameters:
3575 
     - orderId
3576 
     - isUsable
3577 
    """
3578 
    self.send_validateReturnProduct(orderId, isUsable)
3579 
    return self.recv_validateReturnProduct()
3580 
 
3581 
  def send_validateReturnProduct(self, orderId, isUsable):
3582 
    self._oprot.writeMessageBegin('validateReturnProduct', TMessageType.CALL, self._seqid)
3583 
    args = validateReturnProduct_args()
3584 
    args.orderId = orderId
3585 
    args.isUsable = isUsable
3586 
    args.write(self._oprot)
3587 
    self._oprot.writeMessageEnd()
3588 
    self._oprot.trans.flush()
3589 
 
3590 
  def recv_validateReturnProduct(self, ):
3591 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3592 
    if mtype == TMessageType.EXCEPTION:
3593 
      x = TApplicationException()
3594 
      x.read(self._iprot)
3595 
      self._iprot.readMessageEnd()
3596 
      raise x
3597 
    result = validateReturnProduct_result()
3598 
    result.read(self._iprot)
3599 
    self._iprot.readMessageEnd()
3600 
    if result.success is not None:
3601 
      return result.success
3602 
    if result.ex is not None:
3603 
      raise result.ex
3604 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "validateReturnProduct failed: unknown result");
3605 
 
2616 chandransh 3606 
  def reshipOrder(self, orderId):
3607 
    """
4484 rajveer 3608 
    If the order is in RTO_RECEIVED_PRESTINE or DOA_CERT_INVALID state, it does the following:
2616 chandransh 3609 
    	1. Creates a new order for processing in the BILLED state. All billing information is saved.
4484 rajveer 3610 
    	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 3611 
 
3612 
    If the order is in DOA_CERT_VALID state, it does the following:
3613 
    	1. Creates a new order for processing in the SUBMITTED_FOR_PROCESSING state.
3614 
    	2. Creates a return order for the warehouse executive to return the DOA material.
4452 rajveer 3615 
    	3. Marks the current order as the final DOA_VALID_RESHIPPED state.
3431 rajveer 3616 
 
2616 chandransh 3617 
    Returns the id of the newly created order.
3431 rajveer 3618 
 
2616 chandransh 3619 
    Throws an exception if the order with the given id couldn't be found.
3431 rajveer 3620 
 
2616 chandransh 3621 
    Parameters:
3622 
     - orderId
3623 
    """
3624 
    self.send_reshipOrder(orderId)
3625 
    return self.recv_reshipOrder()
2591 chandransh 3626 
 
2616 chandransh 3627 
  def send_reshipOrder(self, orderId):
3628 
    self._oprot.writeMessageBegin('reshipOrder', TMessageType.CALL, self._seqid)
3629 
    args = reshipOrder_args()
3630 
    args.orderId = orderId
3631 
    args.write(self._oprot)
3632 
    self._oprot.writeMessageEnd()
3633 
    self._oprot.trans.flush()
3634 
 
3635 
  def recv_reshipOrder(self, ):
3636 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3637 
    if mtype == TMessageType.EXCEPTION:
3638 
      x = TApplicationException()
3639 
      x.read(self._iprot)
3640 
      self._iprot.readMessageEnd()
3641 
      raise x
3642 
    result = reshipOrder_result()
3643 
    result.read(self._iprot)
3644 
    self._iprot.readMessageEnd()
3431 rajveer 3645 
    if result.success is not None:
2616 chandransh 3646 
      return result.success
3431 rajveer 3647 
    if result.ex is not None:
2616 chandransh 3648 
      raise result.ex
3649 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "reshipOrder failed: unknown result");
3650 
 
3226 chandransh 3651 
  def refundOrder(self, orderId, refundedBy, reason):
2616 chandransh 3652 
    """
4484 rajveer 3653 
    If the order is in RTO_RECEIVED_PRESTINE, DOA_CERT_VALID or DOA_CERT_INVALID state, it does the following:
2616 chandransh 3654 
    	1. Creates a refund request for batch processing.
3655 
    	2. Creates a return order for the warehouse executive to return the shipped material.
4484 rajveer 3656 
    	3. Marks the current order as RTO_REFUNDED, DOA_VALID_REFUNDED or DOA_INVALID_REFUNDED final states.
3431 rajveer 3657 
 
2616 chandransh 3658 
    If the order is in SUBMITTED_FOR_PROCESSING or INVENTORY_LOW state, it does the following:
3659 
    	1. Creates a refund request for batch processing.
3226 chandransh 3660 
    	2. Cancels the reservation of the item in the warehouse.
3661 
    	3. Marks the current order as the REFUNDED final state.
3431 rajveer 3662 
 
3226 chandransh 3663 
    For all COD orders, if the order is in INIT, SUBMITTED_FOR_PROCESSING or INVENTORY_LOW state, it does the following:
3664 
    	1. Cancels the reservation of the item in the warehouse.
3665 
    	2. Marks the current order as CANCELED.
3666 
 
3667 
    In all cases, it updates the reason for cancellation or refund and the person who performed the action.
3668 
 
2616 chandransh 3669 
    Returns True if it is successful, False otherwise.
3431 rajveer 3670 
 
2616 chandransh 3671 
    Throws an exception if the order with the given id couldn't be found.
3431 rajveer 3672 
 
2616 chandransh 3673 
    Parameters:
3674 
     - orderId
3226 chandransh 3675 
     - refundedBy
3676 
     - reason
2616 chandransh 3677 
    """
3226 chandransh 3678 
    self.send_refundOrder(orderId, refundedBy, reason)
2616 chandransh 3679 
    return self.recv_refundOrder()
3680 
 
3226 chandransh 3681 
  def send_refundOrder(self, orderId, refundedBy, reason):
2616 chandransh 3682 
    self._oprot.writeMessageBegin('refundOrder', TMessageType.CALL, self._seqid)
3683 
    args = refundOrder_args()
3684 
    args.orderId = orderId
3226 chandransh 3685 
    args.refundedBy = refundedBy
3686 
    args.reason = reason
2616 chandransh 3687 
    args.write(self._oprot)
3688 
    self._oprot.writeMessageEnd()
3689 
    self._oprot.trans.flush()
3690 
 
3691 
  def recv_refundOrder(self, ):
3692 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3693 
    if mtype == TMessageType.EXCEPTION:
3694 
      x = TApplicationException()
3695 
      x.read(self._iprot)
3696 
      self._iprot.readMessageEnd()
3697 
      raise x
3698 
    result = refundOrder_result()
3699 
    result.read(self._iprot)
3700 
    self._iprot.readMessageEnd()
3431 rajveer 3701 
    if result.success is not None:
2616 chandransh 3702 
      return result.success
3431 rajveer 3703 
    if result.ex is not None:
2616 chandransh 3704 
      raise result.ex
3705 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "refundOrder failed: unknown result");
3706 
 
2690 chandransh 3707 
  def getReturnOrders(self, warehouseId, fromDate, toDate):
3708 
    """
3709 
    Get all return orders created between the from and to dates for the given warehouse.
3710 
    Ignores the warehouse if it is passed as -1.
3431 rajveer 3711 
 
2690 chandransh 3712 
    Parameters:
3713 
     - warehouseId
3714 
     - fromDate
3715 
     - toDate
3716 
    """
3717 
    self.send_getReturnOrders(warehouseId, fromDate, toDate)
3718 
    return self.recv_getReturnOrders()
2616 chandransh 3719 
 
2690 chandransh 3720 
  def send_getReturnOrders(self, warehouseId, fromDate, toDate):
3721 
    self._oprot.writeMessageBegin('getReturnOrders', TMessageType.CALL, self._seqid)
3722 
    args = getReturnOrders_args()
3723 
    args.warehouseId = warehouseId
3724 
    args.fromDate = fromDate
3725 
    args.toDate = toDate
3726 
    args.write(self._oprot)
3727 
    self._oprot.writeMessageEnd()
3728 
    self._oprot.trans.flush()
3729 
 
3730 
  def recv_getReturnOrders(self, ):
3731 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3732 
    if mtype == TMessageType.EXCEPTION:
3733 
      x = TApplicationException()
3734 
      x.read(self._iprot)
3735 
      self._iprot.readMessageEnd()
3736 
      raise x
3737 
    result = getReturnOrders_result()
3738 
    result.read(self._iprot)
3739 
    self._iprot.readMessageEnd()
3431 rajveer 3740 
    if result.success is not None:
2690 chandransh 3741 
      return result.success
3742 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getReturnOrders failed: unknown result");
3743 
 
5481 phani.kuma 3744 
  def getAllReturnOrders(self, onlyNotProcessed, fromDate, toDate):
3745 
    """
3746 
    Get all return orders created between the from and to dates.
3747 
 
3748 
    Parameters:
3749 
     - onlyNotProcessed
3750 
     - fromDate
3751 
     - toDate
3752 
    """
3753 
    self.send_getAllReturnOrders(onlyNotProcessed, fromDate, toDate)
3754 
    return self.recv_getAllReturnOrders()
3755 
 
3756 
  def send_getAllReturnOrders(self, onlyNotProcessed, fromDate, toDate):
3757 
    self._oprot.writeMessageBegin('getAllReturnOrders', TMessageType.CALL, self._seqid)
3758 
    args = getAllReturnOrders_args()
3759 
    args.onlyNotProcessed = onlyNotProcessed
3760 
    args.fromDate = fromDate
3761 
    args.toDate = toDate
3762 
    args.write(self._oprot)
3763 
    self._oprot.writeMessageEnd()
3764 
    self._oprot.trans.flush()
3765 
 
3766 
  def recv_getAllReturnOrders(self, ):
3767 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3768 
    if mtype == TMessageType.EXCEPTION:
3769 
      x = TApplicationException()
3770 
      x.read(self._iprot)
3771 
      self._iprot.readMessageEnd()
3772 
      raise x
3773 
    result = getAllReturnOrders_result()
3774 
    result.read(self._iprot)
3775 
    self._iprot.readMessageEnd()
3776 
    if result.success is not None:
3777 
      return result.success
3778 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAllReturnOrders failed: unknown result");
3779 
 
2700 chandransh 3780 
  def getReturnOrder(self, id):
3781 
    """
3782 
    Returns the ReturnOrder corresponding to the given id.
3783 
    Throws an exception if the return order with the given id couldn't be found.
3431 rajveer 3784 
 
2700 chandransh 3785 
    Parameters:
3786 
     - id
3787 
    """
3788 
    self.send_getReturnOrder(id)
3789 
    return self.recv_getReturnOrder()
3790 
 
3791 
  def send_getReturnOrder(self, id):
3792 
    self._oprot.writeMessageBegin('getReturnOrder', TMessageType.CALL, self._seqid)
3793 
    args = getReturnOrder_args()
3794 
    args.id = id
3795 
    args.write(self._oprot)
3796 
    self._oprot.writeMessageEnd()
3797 
    self._oprot.trans.flush()
3798 
 
3799 
  def recv_getReturnOrder(self, ):
3800 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3801 
    if mtype == TMessageType.EXCEPTION:
3802 
      x = TApplicationException()
3803 
      x.read(self._iprot)
3804 
      self._iprot.readMessageEnd()
3805 
      raise x
3806 
    result = getReturnOrder_result()
3807 
    result.read(self._iprot)
3808 
    self._iprot.readMessageEnd()
3431 rajveer 3809 
    if result.success is not None:
2700 chandransh 3810 
      return result.success
3431 rajveer 3811 
    if result.ex is not None:
2700 chandransh 3812 
      raise result.ex
3813 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getReturnOrder failed: unknown result");
3814 
 
2690 chandransh 3815 
  def processReturn(self, returnOrderId):
3816 
    """
3817 
    Marks the return order with the given id as processed. Raises an exception if no such return order exists.
3431 rajveer 3818 
 
2690 chandransh 3819 
    Parameters:
3820 
     - returnOrderId
3821 
    """
3822 
    self.send_processReturn(returnOrderId)
3823 
    self.recv_processReturn()
3824 
 
3825 
  def send_processReturn(self, returnOrderId):
3826 
    self._oprot.writeMessageBegin('processReturn', TMessageType.CALL, self._seqid)
3827 
    args = processReturn_args()
3828 
    args.returnOrderId = returnOrderId
3829 
    args.write(self._oprot)
3830 
    self._oprot.writeMessageEnd()
3831 
    self._oprot.trans.flush()
3832 
 
3833 
  def recv_processReturn(self, ):
3834 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3835 
    if mtype == TMessageType.EXCEPTION:
3836 
      x = TApplicationException()
3837 
      x.read(self._iprot)
3838 
      self._iprot.readMessageEnd()
3839 
      raise x
3840 
    result = processReturn_result()
3841 
    result.read(self._iprot)
3842 
    self._iprot.readMessageEnd()
3431 rajveer 3843 
    if result.ex is not None:
2690 chandransh 3844 
      raise result.ex
3845 
    return
3846 
 
3451 chandransh 3847 
  def updateWeight(self, orderId, weight):
3848 
    """
3849 
    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 3850 
 
3451 chandransh 3851 
    Parameters:
3852 
     - orderId
3853 
     - weight
3854 
    """
3855 
    self.send_updateWeight(orderId, weight)
3856 
    return self.recv_updateWeight()
3857 
 
3858 
  def send_updateWeight(self, orderId, weight):
3859 
    self._oprot.writeMessageBegin('updateWeight', TMessageType.CALL, self._seqid)
3860 
    args = updateWeight_args()
3861 
    args.orderId = orderId
3862 
    args.weight = weight
3863 
    args.write(self._oprot)
3864 
    self._oprot.writeMessageEnd()
3865 
    self._oprot.trans.flush()
3866 
 
3867 
  def recv_updateWeight(self, ):
3868 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3869 
    if mtype == TMessageType.EXCEPTION:
3870 
      x = TApplicationException()
3871 
      x.read(self._iprot)
3872 
      self._iprot.readMessageEnd()
3873 
      raise x
3874 
    result = updateWeight_result()
3875 
    result.read(self._iprot)
3876 
    self._iprot.readMessageEnd()
3877 
    if result.success is not None:
3878 
      return result.success
3879 
    if result.ex is not None:
3880 
      raise result.ex
3881 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "updateWeight failed: unknown result");
3882 
 
3469 chandransh 3883 
  def changeItem(self, orderId, itemId):
3884 
    """
3885 
    Change the item to be shipped for this order. Also adjusts the reservation in the inventory accordingly.
3886 
    Currently, it also ensures that only a different color of the given item is shipped.
3451 chandransh 3887 
 
3469 chandransh 3888 
    Parameters:
3889 
     - orderId
3890 
     - itemId
3891 
    """
3892 
    self.send_changeItem(orderId, itemId)
3893 
    return self.recv_changeItem()
3894 
 
3895 
  def send_changeItem(self, orderId, itemId):
3896 
    self._oprot.writeMessageBegin('changeItem', TMessageType.CALL, self._seqid)
3897 
    args = changeItem_args()
3898 
    args.orderId = orderId
3899 
    args.itemId = itemId
3900 
    args.write(self._oprot)
3901 
    self._oprot.writeMessageEnd()
3902 
    self._oprot.trans.flush()
3903 
 
3904 
  def recv_changeItem(self, ):
3905 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3906 
    if mtype == TMessageType.EXCEPTION:
3907 
      x = TApplicationException()
3908 
      x.read(self._iprot)
3909 
      self._iprot.readMessageEnd()
3910 
      raise x
3911 
    result = changeItem_result()
3912 
    result.read(self._iprot)
3913 
    self._iprot.readMessageEnd()
3914 
    if result.success is not None:
3915 
      return result.success
3916 
    if result.ex is not None:
3917 
      raise result.ex
3918 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "changeItem failed: unknown result");
3919 
 
3920 
  def shiftToWarehouse(self, orderId, warehouseId):
3921 
    """
3922 
    Moves the given order to the given warehouse. Also adjusts the inventory reservations accordingly.
3923 
 
3924 
    Parameters:
3925 
     - orderId
3926 
     - warehouseId
3927 
    """
3928 
    self.send_shiftToWarehouse(orderId, warehouseId)
3929 
    return self.recv_shiftToWarehouse()
3930 
 
3931 
  def send_shiftToWarehouse(self, orderId, warehouseId):
3932 
    self._oprot.writeMessageBegin('shiftToWarehouse', TMessageType.CALL, self._seqid)
3933 
    args = shiftToWarehouse_args()
3934 
    args.orderId = orderId
3935 
    args.warehouseId = warehouseId
3936 
    args.write(self._oprot)
3937 
    self._oprot.writeMessageEnd()
3938 
    self._oprot.trans.flush()
3939 
 
3940 
  def recv_shiftToWarehouse(self, ):
3941 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3942 
    if mtype == TMessageType.EXCEPTION:
3943 
      x = TApplicationException()
3944 
      x.read(self._iprot)
3945 
      self._iprot.readMessageEnd()
3946 
      raise x
3947 
    result = shiftToWarehouse_result()
3948 
    result.read(self._iprot)
3949 
    self._iprot.readMessageEnd()
3950 
    if result.success is not None:
3951 
      return result.success
3952 
    if result.ex is not None:
3953 
      raise result.ex
3954 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "shiftToWarehouse failed: unknown result");
3955 
 
4647 rajveer 3956 
  def addDelayReason(self, orderId, delayReason, furtherDelay, delayReasonText):
3553 chandransh 3957 
    """
3958 
    Adds the given delay reason to the given order.
3986 chandransh 3959 
    Increases the expected delivery time of the given order by the given no. of days.
3553 chandransh 3960 
    Raises an exception if no order with the given id can be found.
3469 chandransh 3961 
 
3553 chandransh 3962 
    Parameters:
3963 
     - orderId
3964 
     - delayReason
3986 chandransh 3965 
     - furtherDelay
4647 rajveer 3966 
     - delayReasonText
3553 chandransh 3967 
    """
4647 rajveer 3968 
    self.send_addDelayReason(orderId, delayReason, furtherDelay, delayReasonText)
3553 chandransh 3969 
    return self.recv_addDelayReason()
3970 
 
4647 rajveer 3971 
  def send_addDelayReason(self, orderId, delayReason, furtherDelay, delayReasonText):
3553 chandransh 3972 
    self._oprot.writeMessageBegin('addDelayReason', TMessageType.CALL, self._seqid)
3973 
    args = addDelayReason_args()
3974 
    args.orderId = orderId
3975 
    args.delayReason = delayReason
3986 chandransh 3976 
    args.furtherDelay = furtherDelay
4647 rajveer 3977 
    args.delayReasonText = delayReasonText
3553 chandransh 3978 
    args.write(self._oprot)
3979 
    self._oprot.writeMessageEnd()
3980 
    self._oprot.trans.flush()
3981 
 
3982 
  def recv_addDelayReason(self, ):
3983 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3984 
    if mtype == TMessageType.EXCEPTION:
3985 
      x = TApplicationException()
3986 
      x.read(self._iprot)
3987 
      self._iprot.readMessageEnd()
3988 
      raise x
3989 
    result = addDelayReason_result()
3990 
    result.read(self._iprot)
3991 
    self._iprot.readMessageEnd()
3992 
    if result.success is not None:
3993 
      return result.success
3994 
    if result.ex is not None:
3995 
      raise result.ex
3996 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "addDelayReason failed: unknown result");
3997 
 
3956 chandransh 3998 
  def reconcileCodCollection(self, collectedAmountMap, xferBy, xferTxnId, xferDate):
3999 
    """
4000 
    Marks the COD orders with given AWB nos. as having been processed.
4001 
    Updates the captured amount for the corresponding payment.
3553 chandransh 4002 
 
3956 chandransh 4003 
    Returns a map of AWBs which were not processed and the associated reason. An AWB is not processed if:
4004 
    1. There is no order corresponding to an AWB number.
4005 
    2. The captured amount for a payment exceeds the total payment.
4006 
    3. The order corresponding to an AWB no. is in a state prior to DELIVERY_SUCCESS.
4007 
 
4008 
    Parameters:
4009 
     - collectedAmountMap
4010 
     - xferBy
4011 
     - xferTxnId
4012 
     - xferDate
4013 
    """
4014 
    self.send_reconcileCodCollection(collectedAmountMap, xferBy, xferTxnId, xferDate)
4015 
    return self.recv_reconcileCodCollection()
4016 
 
4017 
  def send_reconcileCodCollection(self, collectedAmountMap, xferBy, xferTxnId, xferDate):
4018 
    self._oprot.writeMessageBegin('reconcileCodCollection', TMessageType.CALL, self._seqid)
4019 
    args = reconcileCodCollection_args()
4020 
    args.collectedAmountMap = collectedAmountMap
4021 
    args.xferBy = xferBy
4022 
    args.xferTxnId = xferTxnId
4023 
    args.xferDate = xferDate
4024 
    args.write(self._oprot)
4025 
    self._oprot.writeMessageEnd()
4026 
    self._oprot.trans.flush()
4027 
 
4028 
  def recv_reconcileCodCollection(self, ):
4029 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4030 
    if mtype == TMessageType.EXCEPTION:
4031 
      x = TApplicationException()
4032 
      x.read(self._iprot)
4033 
      self._iprot.readMessageEnd()
4034 
      raise x
4035 
    result = reconcileCodCollection_result()
4036 
    result.read(self._iprot)
4037 
    self._iprot.readMessageEnd()
4038 
    if result.success is not None:
4039 
      return result.success
4040 
    if result.ex is not None:
4041 
      raise result.ex
4042 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "reconcileCodCollection failed: unknown result");
4043 
 
4008 mandeep.dh 4044 
  def getTransactionsRequiringExtraProcessing(self, category):
4045 
    """
4065 mandeep.dh 4046 
    Returns the list of transaction ids that require some extra processing and
4008 mandeep.dh 4047 
    which belong to a particular category. This is currently used by CRM
4065 mandeep.dh 4048 
    application. If no such transaction ids are present, it returns an empty list.
3956 chandransh 4049 
 
4008 mandeep.dh 4050 
    Parameters:
4051 
     - category
4052 
    """
4053 
    self.send_getTransactionsRequiringExtraProcessing(category)
4054 
    return self.recv_getTransactionsRequiringExtraProcessing()
4055 
 
4056 
  def send_getTransactionsRequiringExtraProcessing(self, category):
4057 
    self._oprot.writeMessageBegin('getTransactionsRequiringExtraProcessing', TMessageType.CALL, self._seqid)
4058 
    args = getTransactionsRequiringExtraProcessing_args()
4059 
    args.category = category
4060 
    args.write(self._oprot)
4061 
    self._oprot.writeMessageEnd()
4062 
    self._oprot.trans.flush()
4063 
 
4064 
  def recv_getTransactionsRequiringExtraProcessing(self, ):
4065 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4066 
    if mtype == TMessageType.EXCEPTION:
4067 
      x = TApplicationException()
4068 
      x.read(self._iprot)
4069 
      self._iprot.readMessageEnd()
4070 
      raise x
4071 
    result = getTransactionsRequiringExtraProcessing_result()
4072 
    result.read(self._iprot)
4073 
    self._iprot.readMessageEnd()
4074 
    if result.success is not None:
4075 
      return result.success
4076 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getTransactionsRequiringExtraProcessing failed: unknown result");
4077 
 
4078 
  def markTransactionAsProcessed(self, transactionId, category):
4079 
    """
4080 
    Marks a particular transaction as processed for a particular cateogory.
4065 mandeep.dh 4081 
    It essentially deletes the transaction id record for a particular
4082 
    processing type category (if present) from DB.
4083 
    This is currently used by CRM application.
4008 mandeep.dh 4084 
 
4085 
    Parameters:
4086 
     - transactionId
4087 
     - category
4088 
    """
4089 
    self.send_markTransactionAsProcessed(transactionId, category)
4090 
    self.recv_markTransactionAsProcessed()
4091 
 
4092 
  def send_markTransactionAsProcessed(self, transactionId, category):
4093 
    self._oprot.writeMessageBegin('markTransactionAsProcessed', TMessageType.CALL, self._seqid)
4094 
    args = markTransactionAsProcessed_args()
4095 
    args.transactionId = transactionId
4096 
    args.category = category
4097 
    args.write(self._oprot)
4098 
    self._oprot.writeMessageEnd()
4099 
    self._oprot.trans.flush()
4100 
 
4101 
  def recv_markTransactionAsProcessed(self, ):
4102 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4103 
    if mtype == TMessageType.EXCEPTION:
4104 
      x = TApplicationException()
4105 
      x.read(self._iprot)
4106 
      self._iprot.readMessageEnd()
4107 
      raise x
4108 
    result = markTransactionAsProcessed_result()
4109 
    result.read(self._iprot)
4110 
    self._iprot.readMessageEnd()
4111 
    return
4112 
 
4018 chandransh 4113 
  def getItemWiseRiskyOrdersCount(self, ):
4114 
    """
4115 
    Returns a map containing the number of risky orders keyed by item id. A risky order
4116 
    is defined as one whose shipping date is about to expire.
4117 
    """
4118 
    self.send_getItemWiseRiskyOrdersCount()
4119 
    return self.recv_getItemWiseRiskyOrdersCount()
4008 mandeep.dh 4120 
 
4018 chandransh 4121 
  def send_getItemWiseRiskyOrdersCount(self, ):
4122 
    self._oprot.writeMessageBegin('getItemWiseRiskyOrdersCount', TMessageType.CALL, self._seqid)
4123 
    args = getItemWiseRiskyOrdersCount_args()
4124 
    args.write(self._oprot)
4125 
    self._oprot.writeMessageEnd()
4126 
    self._oprot.trans.flush()
4127 
 
4128 
  def recv_getItemWiseRiskyOrdersCount(self, ):
4129 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4130 
    if mtype == TMessageType.EXCEPTION:
4131 
      x = TApplicationException()
4132 
      x.read(self._iprot)
4133 
      self._iprot.readMessageEnd()
4134 
      raise x
4135 
    result = getItemWiseRiskyOrdersCount_result()
4136 
    result.read(self._iprot)
4137 
    self._iprot.readMessageEnd()
4138 
    if result.success is not None:
4139 
      return result.success
4140 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getItemWiseRiskyOrdersCount failed: unknown result");
4141 
 
4295 varun.gupt 4142 
  def getOrdersForItemIds(self, itemIds):
4143 
    """
4144 
    Returns a list of all orders which have items with given id
4145 
 
4146 
    Parameters:
4147 
     - itemIds
4148 
    """
4149 
    self.send_getOrdersForItemIds(itemIds)
4150 
    return self.recv_getOrdersForItemIds()
4151 
 
4152 
  def send_getOrdersForItemIds(self, itemIds):
4153 
    self._oprot.writeMessageBegin('getOrdersForItemIds', TMessageType.CALL, self._seqid)
4154 
    args = getOrdersForItemIds_args()
4155 
    args.itemIds = itemIds
4156 
    args.write(self._oprot)
4157 
    self._oprot.writeMessageEnd()
4158 
    self._oprot.trans.flush()
4159 
 
4160 
  def recv_getOrdersForItemIds(self, ):
4161 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4162 
    if mtype == TMessageType.EXCEPTION:
4163 
      x = TApplicationException()
4164 
      x.read(self._iprot)
4165 
      self._iprot.readMessageEnd()
4166 
      raise x
4167 
    result = getOrdersForItemIds_result()
4168 
    result.read(self._iprot)
4169 
    self._iprot.readMessageEnd()
4170 
    if result.success is not None:
4171 
      return result.success
4172 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getOrdersForItemIds failed: unknown result");
4173 
 
4247 rajveer 4174 
  def markOrderCancellationRequestReceived(self, orderId):
4175 
    """
4176 
    Mark order as cancellation request received. If customer sends request of cancellation of
4177 
    a particular order, this method will be called. It will just change status of the order
4178 
    depending on its current status. It also records the previous status, so that we can move
4179 
    back to that status if cancellation request is denied.
4018 chandransh 4180 
 
4247 rajveer 4181 
    Parameters:
4182 
     - orderId
4183 
    """
4184 
    self.send_markOrderCancellationRequestReceived(orderId)
4185 
    self.recv_markOrderCancellationRequestReceived()
4186 
 
4187 
  def send_markOrderCancellationRequestReceived(self, orderId):
4188 
    self._oprot.writeMessageBegin('markOrderCancellationRequestReceived', TMessageType.CALL, self._seqid)
4189 
    args = markOrderCancellationRequestReceived_args()
4190 
    args.orderId = orderId
4191 
    args.write(self._oprot)
4192 
    self._oprot.writeMessageEnd()
4193 
    self._oprot.trans.flush()
4194 
 
4195 
  def recv_markOrderCancellationRequestReceived(self, ):
4196 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4197 
    if mtype == TMessageType.EXCEPTION:
4198 
      x = TApplicationException()
4199 
      x.read(self._iprot)
4200 
      self._iprot.readMessageEnd()
4201 
      raise x
4202 
    result = markOrderCancellationRequestReceived_result()
4203 
    result.read(self._iprot)
4204 
    self._iprot.readMessageEnd()
4205 
    if result.ex is not None:
4206 
      raise result.ex
4207 
    return
4208 
 
4209 
  def markOrderCancellationRequestConfirmed(self, orderId):
4210 
    """
4211 
    If we decide to to cancel order, CRM will call this method to move the status of order to
4212 
    cancellation request confirmed. After this OM will be able to cancel the order.
4213 
 
4214 
    Parameters:
4215 
     - orderId
4216 
    """
4217 
    self.send_markOrderCancellationRequestConfirmed(orderId)
4218 
    self.recv_markOrderCancellationRequestConfirmed()
4219 
 
4220 
  def send_markOrderCancellationRequestConfirmed(self, orderId):
4221 
    self._oprot.writeMessageBegin('markOrderCancellationRequestConfirmed', TMessageType.CALL, self._seqid)
4222 
    args = markOrderCancellationRequestConfirmed_args()
4223 
    args.orderId = orderId
4224 
    args.write(self._oprot)
4225 
    self._oprot.writeMessageEnd()
4226 
    self._oprot.trans.flush()
4227 
 
4228 
  def recv_markOrderCancellationRequestConfirmed(self, ):
4229 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4230 
    if mtype == TMessageType.EXCEPTION:
4231 
      x = TApplicationException()
4232 
      x.read(self._iprot)
4233 
      self._iprot.readMessageEnd()
4234 
      raise x
4235 
    result = markOrderCancellationRequestConfirmed_result()
4236 
    result.read(self._iprot)
4237 
    self._iprot.readMessageEnd()
4238 
    if result.ex is not None:
4239 
      raise result.ex
4240 
    return
4241 
 
4242 
  def markOrderCancellationRequestDenied(self, orderId):
4243 
    """
4244 
    If we decide to not to cancel order, we will move the order ro previous status.
4245 
 
4246 
    Parameters:
4247 
     - orderId
4248 
    """
4249 
    self.send_markOrderCancellationRequestDenied(orderId)
4250 
    self.recv_markOrderCancellationRequestDenied()
4251 
 
4252 
  def send_markOrderCancellationRequestDenied(self, orderId):
4253 
    self._oprot.writeMessageBegin('markOrderCancellationRequestDenied', TMessageType.CALL, self._seqid)
4254 
    args = markOrderCancellationRequestDenied_args()
4255 
    args.orderId = orderId
4256 
    args.write(self._oprot)
4257 
    self._oprot.writeMessageEnd()
4258 
    self._oprot.trans.flush()
4259 
 
4260 
  def recv_markOrderCancellationRequestDenied(self, ):
4261 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4262 
    if mtype == TMessageType.EXCEPTION:
4263 
      x = TApplicationException()
4264 
      x.read(self._iprot)
4265 
      self._iprot.readMessageEnd()
4266 
      raise x
4267 
    result = markOrderCancellationRequestDenied_result()
4268 
    result.read(self._iprot)
4269 
    self._iprot.readMessageEnd()
4270 
    if result.ex is not None:
4271 
      raise result.ex
4272 
    return
4273 
 
4258 rajveer 4274 
  def markTransactionAsPaymentFlagRemoved(self, transactionId):
4247 rajveer 4275 
    """
4258 rajveer 4276 
    If we and/or payment gateway has decided to accept the payment, this method needs to be called.
4277 
    Changed transaction and all orders status to payment accepted.
4247 rajveer 4278 
 
4279 
    Parameters:
4258 rajveer 4280 
     - transactionId
4247 rajveer 4281 
    """
4258 rajveer 4282 
    self.send_markTransactionAsPaymentFlagRemoved(transactionId)
4283 
    self.recv_markTransactionAsPaymentFlagRemoved()
4247 rajveer 4284 
 
4258 rajveer 4285 
  def send_markTransactionAsPaymentFlagRemoved(self, transactionId):
4286 
    self._oprot.writeMessageBegin('markTransactionAsPaymentFlagRemoved', TMessageType.CALL, self._seqid)
4287 
    args = markTransactionAsPaymentFlagRemoved_args()
4288 
    args.transactionId = transactionId
4247 rajveer 4289 
    args.write(self._oprot)
4290 
    self._oprot.writeMessageEnd()
4291 
    self._oprot.trans.flush()
4292 
 
4258 rajveer 4293 
  def recv_markTransactionAsPaymentFlagRemoved(self, ):
4247 rajveer 4294 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4295 
    if mtype == TMessageType.EXCEPTION:
4296 
      x = TApplicationException()
4297 
      x.read(self._iprot)
4298 
      self._iprot.readMessageEnd()
4299 
      raise x
4258 rajveer 4300 
    result = markTransactionAsPaymentFlagRemoved_result()
4247 rajveer 4301 
    result.read(self._iprot)
4302 
    self._iprot.readMessageEnd()
4303 
    if result.ex is not None:
4304 
      raise result.ex
4305 
    return
4306 
 
4259 anupam.sin 4307 
  def refundTransaction(self, transactionId, refundedBy, reason):
4308 
    """
4309 
    This method is called when a flagged payment is deemed unserviceable and the corresponding orders
4310 
    need to be cancelled
4247 rajveer 4311 
 
4259 anupam.sin 4312 
    Parameters:
4313 
     - transactionId
4314 
     - refundedBy
4315 
     - reason
4316 
    """
4317 
    self.send_refundTransaction(transactionId, refundedBy, reason)
4318 
    self.recv_refundTransaction()
4319 
 
4320 
  def send_refundTransaction(self, transactionId, refundedBy, reason):
4321 
    self._oprot.writeMessageBegin('refundTransaction', TMessageType.CALL, self._seqid)
4322 
    args = refundTransaction_args()
4323 
    args.transactionId = transactionId
4324 
    args.refundedBy = refundedBy
4325 
    args.reason = reason
4326 
    args.write(self._oprot)
4327 
    self._oprot.writeMessageEnd()
4328 
    self._oprot.trans.flush()
4329 
 
4330 
  def recv_refundTransaction(self, ):
4331 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4332 
    if mtype == TMessageType.EXCEPTION:
4333 
      x = TApplicationException()
4334 
      x.read(self._iprot)
4335 
      self._iprot.readMessageEnd()
4336 
      raise x
4337 
    result = refundTransaction_result()
4338 
    result.read(self._iprot)
4339 
    self._iprot.readMessageEnd()
4340 
    if result.ex is not None:
4341 
      raise result.ex
4342 
    return
4343 
 
4324 mandeep.dh 4344 
  def updateShipmentAddress(self, orderId, addressId):
4345 
    """
4346 
    Updates shipment address of an order. Delivery and shipping date estimates
4347 
    etc. are also updated here.
4348 
 
4349 
    Throws TransactionServiceException in case address change is not
4350 
    possible due to certain reasons such as new pincode in address is
4351 
    not serviceable etc.
4352 
 
4353 
    Parameters:
4354 
     - orderId
4355 
     - addressId
4356 
    """
4357 
    self.send_updateShipmentAddress(orderId, addressId)
4358 
    self.recv_updateShipmentAddress()
4359 
 
4360 
  def send_updateShipmentAddress(self, orderId, addressId):
4361 
    self._oprot.writeMessageBegin('updateShipmentAddress', TMessageType.CALL, self._seqid)
4362 
    args = updateShipmentAddress_args()
4363 
    args.orderId = orderId
4364 
    args.addressId = addressId
4365 
    args.write(self._oprot)
4366 
    self._oprot.writeMessageEnd()
4367 
    self._oprot.trans.flush()
4368 
 
4369 
  def recv_updateShipmentAddress(self, ):
4370 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4371 
    if mtype == TMessageType.EXCEPTION:
4372 
      x = TApplicationException()
4373 
      x.read(self._iprot)
4374 
      self._iprot.readMessageEnd()
4375 
      raise x
4376 
    result = updateShipmentAddress_result()
4377 
    result.read(self._iprot)
4378 
    self._iprot.readMessageEnd()
4379 
    if result.ex is not None:
4380 
      raise result.ex
4381 
    return
4382 
 
4285 rajveer 4383 
  def acceptOrdersForItemId(self, itemId, inventory):
4384 
    """
4385 
    Marks the orders as ACCEPTED for the given itemId and inventory. It also updates the accepted timestamp. If the
4386 
    given order is not a COD order, it also captures the payment if the same has not been captured.
4259 anupam.sin 4387 
 
4285 rajveer 4388 
    Parameters:
4389 
     - itemId
4390 
     - inventory
4391 
    """
4392 
    self.send_acceptOrdersForItemId(itemId, inventory)
4393 
    return self.recv_acceptOrdersForItemId()
4394 
 
4395 
  def send_acceptOrdersForItemId(self, itemId, inventory):
4396 
    self._oprot.writeMessageBegin('acceptOrdersForItemId', TMessageType.CALL, self._seqid)
4397 
    args = acceptOrdersForItemId_args()
4398 
    args.itemId = itemId
4399 
    args.inventory = inventory
4400 
    args.write(self._oprot)
4401 
    self._oprot.writeMessageEnd()
4402 
    self._oprot.trans.flush()
4403 
 
4404 
  def recv_acceptOrdersForItemId(self, ):
4405 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4406 
    if mtype == TMessageType.EXCEPTION:
4407 
      x = TApplicationException()
4408 
      x.read(self._iprot)
4409 
      self._iprot.readMessageEnd()
4410 
      raise x
4411 
    result = acceptOrdersForItemId_result()
4412 
    result.read(self._iprot)
4413 
    self._iprot.readMessageEnd()
4414 
    if result.success is not None:
4415 
      return result.success
4416 
    if result.ex is not None:
4417 
      raise result.ex
4418 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "acceptOrdersForItemId failed: unknown result");
4419 
 
4369 rajveer 4420 
  def markOrdersAsPORaised(self, vendorId, itemId, quantity, estimate, isReminder):
4303 rajveer 4421 
    """
4422 
    Parameters:
4423 
     - vendorId
4424 
     - itemId
4425 
     - quantity
4426 
     - estimate
4369 rajveer 4427 
     - isReminder
4303 rajveer 4428 
    """
4369 rajveer 4429 
    self.send_markOrdersAsPORaised(vendorId, itemId, quantity, estimate, isReminder)
4303 rajveer 4430 
    self.recv_markOrdersAsPORaised()
4285 rajveer 4431 
 
4369 rajveer 4432 
  def send_markOrdersAsPORaised(self, vendorId, itemId, quantity, estimate, isReminder):
4303 rajveer 4433 
    self._oprot.writeMessageBegin('markOrdersAsPORaised', TMessageType.CALL, self._seqid)
4434 
    args = markOrdersAsPORaised_args()
4435 
    args.vendorId = vendorId
4436 
    args.itemId = itemId
4437 
    args.quantity = quantity
4438 
    args.estimate = estimate
4369 rajveer 4439 
    args.isReminder = isReminder
4303 rajveer 4440 
    args.write(self._oprot)
4441 
    self._oprot.writeMessageEnd()
4442 
    self._oprot.trans.flush()
4443 
 
4444 
  def recv_markOrdersAsPORaised(self, ):
4445 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4446 
    if mtype == TMessageType.EXCEPTION:
4447 
      x = TApplicationException()
4448 
      x.read(self._iprot)
4449 
      self._iprot.readMessageEnd()
4450 
      raise x
4451 
    result = markOrdersAsPORaised_result()
4452 
    result.read(self._iprot)
4453 
    self._iprot.readMessageEnd()
4454 
    if result.ex is not None:
4455 
      raise result.ex
4456 
    return
4457 
 
4369 rajveer 4458 
  def markOrdersAsReversalInitiated(self, vendorId, itemId, quantity, estimate, isReminder):
4303 rajveer 4459 
    """
4460 
    Parameters:
4461 
     - vendorId
4462 
     - itemId
4463 
     - quantity
4464 
     - estimate
4369 rajveer 4465 
     - isReminder
4303 rajveer 4466 
    """
4369 rajveer 4467 
    self.send_markOrdersAsReversalInitiated(vendorId, itemId, quantity, estimate, isReminder)
4303 rajveer 4468 
    self.recv_markOrdersAsReversalInitiated()
4469 
 
4369 rajveer 4470 
  def send_markOrdersAsReversalInitiated(self, vendorId, itemId, quantity, estimate, isReminder):
4303 rajveer 4471 
    self._oprot.writeMessageBegin('markOrdersAsReversalInitiated', TMessageType.CALL, self._seqid)
4472 
    args = markOrdersAsReversalInitiated_args()
4473 
    args.vendorId = vendorId
4474 
    args.itemId = itemId
4475 
    args.quantity = quantity
4476 
    args.estimate = estimate
4369 rajveer 4477 
    args.isReminder = isReminder
4303 rajveer 4478 
    args.write(self._oprot)
4479 
    self._oprot.writeMessageEnd()
4480 
    self._oprot.trans.flush()
4481 
 
4482 
  def recv_markOrdersAsReversalInitiated(self, ):
4483 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4484 
    if mtype == TMessageType.EXCEPTION:
4485 
      x = TApplicationException()
4486 
      x.read(self._iprot)
4487 
      self._iprot.readMessageEnd()
4488 
      raise x
4489 
    result = markOrdersAsReversalInitiated_result()
4490 
    result.read(self._iprot)
4491 
    self._iprot.readMessageEnd()
4492 
    if result.ex is not None:
4493 
      raise result.ex
4494 
    return
4495 
 
4369 rajveer 4496 
  def markOrdersAsNotAvailabke(self, vendorId, itemId, quantity, estimate, isReminder):
4303 rajveer 4497 
    """
4498 
    Parameters:
4499 
     - vendorId
4500 
     - itemId
4501 
     - quantity
4502 
     - estimate
4369 rajveer 4503 
     - isReminder
4303 rajveer 4504 
    """
4369 rajveer 4505 
    self.send_markOrdersAsNotAvailabke(vendorId, itemId, quantity, estimate, isReminder)
4303 rajveer 4506 
    self.recv_markOrdersAsNotAvailabke()
4507 
 
4369 rajveer 4508 
  def send_markOrdersAsNotAvailabke(self, vendorId, itemId, quantity, estimate, isReminder):
4303 rajveer 4509 
    self._oprot.writeMessageBegin('markOrdersAsNotAvailabke', TMessageType.CALL, self._seqid)
4510 
    args = markOrdersAsNotAvailabke_args()
4511 
    args.vendorId = vendorId
4512 
    args.itemId = itemId
4513 
    args.quantity = quantity
4514 
    args.estimate = estimate
4369 rajveer 4515 
    args.isReminder = isReminder
4303 rajveer 4516 
    args.write(self._oprot)
4517 
    self._oprot.writeMessageEnd()
4518 
    self._oprot.trans.flush()
4519 
 
4520 
  def recv_markOrdersAsNotAvailabke(self, ):
4521 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4522 
    if mtype == TMessageType.EXCEPTION:
4523 
      x = TApplicationException()
4524 
      x.read(self._iprot)
4525 
      self._iprot.readMessageEnd()
4526 
      raise x
4527 
    result = markOrdersAsNotAvailabke_result()
4528 
    result.read(self._iprot)
4529 
    self._iprot.readMessageEnd()
4530 
    if result.ex is not None:
4531 
      raise result.ex
4532 
    return
4533 
 
4369 rajveer 4534 
  def markOrdersAsTimeout(self, vendorId):
4535 
    """
4536 
    Parameters:
4537 
     - vendorId
4538 
    """
4539 
    self.send_markOrdersAsTimeout(vendorId)
4540 
    return self.recv_markOrdersAsTimeout()
4303 rajveer 4541 
 
4369 rajveer 4542 
  def send_markOrdersAsTimeout(self, vendorId):
4543 
    self._oprot.writeMessageBegin('markOrdersAsTimeout', TMessageType.CALL, self._seqid)
4544 
    args = markOrdersAsTimeout_args()
4545 
    args.vendorId = vendorId
4546 
    args.write(self._oprot)
4547 
    self._oprot.writeMessageEnd()
4548 
    self._oprot.trans.flush()
4549 
 
4550 
  def recv_markOrdersAsTimeout(self, ):
4551 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4552 
    if mtype == TMessageType.EXCEPTION:
4553 
      x = TApplicationException()
4554 
      x.read(self._iprot)
4555 
      self._iprot.readMessageEnd()
4556 
      raise x
4557 
    result = markOrdersAsTimeout_result()
4558 
    result.read(self._iprot)
4559 
    self._iprot.readMessageEnd()
4560 
    if result.success is not None:
4561 
      return result.success
4562 
    if result.ex is not None:
4563 
      raise result.ex
4564 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "markOrdersAsTimeout failed: unknown result");
4565 
 
4662 rajveer 4566 
  def markOrderAsLostInTransit(self, orderId):
4567 
    """
4568 
    Mark order as LOST_IN_TRANSIT
4569 
 
4570 
    Parameters:
4571 
     - orderId
4572 
    """
4573 
    self.send_markOrderAsLostInTransit(orderId)
4574 
    return self.recv_markOrderAsLostInTransit()
4575 
 
4576 
  def send_markOrderAsLostInTransit(self, orderId):
4577 
    self._oprot.writeMessageBegin('markOrderAsLostInTransit', TMessageType.CALL, self._seqid)
4578 
    args = markOrderAsLostInTransit_args()
4579 
    args.orderId = orderId
4580 
    args.write(self._oprot)
4581 
    self._oprot.writeMessageEnd()
4582 
    self._oprot.trans.flush()
4583 
 
4584 
  def recv_markOrderAsLostInTransit(self, ):
4585 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4586 
    if mtype == TMessageType.EXCEPTION:
4587 
      x = TApplicationException()
4588 
      x.read(self._iprot)
4589 
      self._iprot.readMessageEnd()
4590 
      raise x
4591 
    result = markOrderAsLostInTransit_result()
4592 
    result.read(self._iprot)
4593 
    self._iprot.readMessageEnd()
4594 
    if result.success is not None:
4595 
      return result.success
4596 
    if result.ex is not None:
4597 
      raise result.ex
4598 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "markOrderAsLostInTransit failed: unknown result");
4599 
 
4386 anupam.sin 4600 
  def getOrderForAwb(self, awb):
4601 
    """
4602 
    Returns the order corresponding to an AWB number
4369 rajveer 4603 
 
4386 anupam.sin 4604 
    Parameters:
4605 
     - awb
4606 
    """
4607 
    self.send_getOrderForAwb(awb)
4608 
    return self.recv_getOrderForAwb()
4609 
 
4610 
  def send_getOrderForAwb(self, awb):
4611 
    self._oprot.writeMessageBegin('getOrderForAwb', TMessageType.CALL, self._seqid)
4612 
    args = getOrderForAwb_args()
4613 
    args.awb = awb
4614 
    args.write(self._oprot)
4615 
    self._oprot.writeMessageEnd()
4616 
    self._oprot.trans.flush()
4617 
 
4618 
  def recv_getOrderForAwb(self, ):
4619 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4620 
    if mtype == TMessageType.EXCEPTION:
4621 
      x = TApplicationException()
4622 
      x.read(self._iprot)
4623 
      self._iprot.readMessageEnd()
4624 
      raise x
4625 
    result = getOrderForAwb_result()
4626 
    result.read(self._iprot)
4627 
    self._iprot.readMessageEnd()
4628 
    if result.success is not None:
4629 
      return result.success
4630 
    if result.ex is not None:
4631 
      raise result.ex
4632 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getOrderForAwb failed: unknown result");
4633 
 
4910 phani.kuma 4634 
  def getOrdersForProviderForStatus(self, logistics_provider_id, order_status_list):
4506 phani.kuma 4635 
    """
4910 phani.kuma 4636 
    Returns the order corresponding to a logistics provider id for a given list of order status
4386 anupam.sin 4637 
 
4506 phani.kuma 4638 
    Parameters:
4639 
     - logistics_provider_id
4910 phani.kuma 4640 
     - order_status_list
4506 phani.kuma 4641 
    """
4910 phani.kuma 4642 
    self.send_getOrdersForProviderForStatus(logistics_provider_id, order_status_list)
4506 phani.kuma 4643 
    return self.recv_getOrdersForProviderForStatus()
4644 
 
4910 phani.kuma 4645 
  def send_getOrdersForProviderForStatus(self, logistics_provider_id, order_status_list):
4506 phani.kuma 4646 
    self._oprot.writeMessageBegin('getOrdersForProviderForStatus', TMessageType.CALL, self._seqid)
4647 
    args = getOrdersForProviderForStatus_args()
4648 
    args.logistics_provider_id = logistics_provider_id
4910 phani.kuma 4649 
    args.order_status_list = order_status_list
4506 phani.kuma 4650 
    args.write(self._oprot)
4651 
    self._oprot.writeMessageEnd()
4652 
    self._oprot.trans.flush()
4653 
 
4654 
  def recv_getOrdersForProviderForStatus(self, ):
4655 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4656 
    if mtype == TMessageType.EXCEPTION:
4657 
      x = TApplicationException()
4658 
      x.read(self._iprot)
4659 
      self._iprot.readMessageEnd()
4660 
      raise x
4661 
    result = getOrdersForProviderForStatus_result()
4662 
    result.read(self._iprot)
4663 
    self._iprot.readMessageEnd()
4664 
    if result.success is not None:
4665 
      return result.success
4666 
    if result.ex is not None:
4667 
      raise result.ex
4668 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getOrdersForProviderForStatus failed: unknown result");
4669 
 
4600 varun.gupt 4670 
  def getBilledOrdersForVendor(self, vendorId, billingDateFrom, billingDateTo):
4671 
    """
4672 
    Returns list of orders fullfiled from a certain vendor and billed in a given date range
4506 phani.kuma 4673 
 
4600 varun.gupt 4674 
    Parameters:
4675 
     - vendorId
4676 
     - billingDateFrom
4677 
     - billingDateTo
4678 
    """
4679 
    self.send_getBilledOrdersForVendor(vendorId, billingDateFrom, billingDateTo)
4680 
    return self.recv_getBilledOrdersForVendor()
4681 
 
4682 
  def send_getBilledOrdersForVendor(self, vendorId, billingDateFrom, billingDateTo):
4683 
    self._oprot.writeMessageBegin('getBilledOrdersForVendor', TMessageType.CALL, self._seqid)
4684 
    args = getBilledOrdersForVendor_args()
4685 
    args.vendorId = vendorId
4686 
    args.billingDateFrom = billingDateFrom
4687 
    args.billingDateTo = billingDateTo
4688 
    args.write(self._oprot)
4689 
    self._oprot.writeMessageEnd()
4690 
    self._oprot.trans.flush()
4691 
 
4692 
  def recv_getBilledOrdersForVendor(self, ):
4693 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4694 
    if mtype == TMessageType.EXCEPTION:
4695 
      x = TApplicationException()
4696 
      x.read(self._iprot)
4697 
      self._iprot.readMessageEnd()
4698 
      raise x
4699 
    result = getBilledOrdersForVendor_result()
4700 
    result.read(self._iprot)
4701 
    self._iprot.readMessageEnd()
4702 
    if result.success is not None:
4703 
      return result.success
4704 
    if result.ex is not None:
4705 
      raise result.ex
4706 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getBilledOrdersForVendor failed: unknown result");
4707 
 
4607 rajveer 4708 
  def getSlippedSippingDateOrders(self, ):
4709 
    self.send_getSlippedSippingDateOrders()
4710 
    return self.recv_getSlippedSippingDateOrders()
4711 
 
4712 
  def send_getSlippedSippingDateOrders(self, ):
4713 
    self._oprot.writeMessageBegin('getSlippedSippingDateOrders', TMessageType.CALL, self._seqid)
4714 
    args = getSlippedSippingDateOrders_args()
4715 
    args.write(self._oprot)
4716 
    self._oprot.writeMessageEnd()
4717 
    self._oprot.trans.flush()
4718 
 
4719 
  def recv_getSlippedSippingDateOrders(self, ):
4720 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4721 
    if mtype == TMessageType.EXCEPTION:
4722 
      x = TApplicationException()
4723 
      x.read(self._iprot)
4724 
      self._iprot.readMessageEnd()
4725 
      raise x
4726 
    result = getSlippedSippingDateOrders_result()
4727 
    result.read(self._iprot)
4728 
    self._iprot.readMessageEnd()
4729 
    if result.success is not None:
4730 
      return result.success
4731 
    if result.ex is not None:
4732 
      raise result.ex
4733 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getSlippedSippingDateOrders failed: unknown result");
4734 
 
4709 rajveer 4735 
  def getCancelledOrders(self, cancelDateFrom, cancelDateTo):
4736 
    """
4737 
    Parameters:
4738 
     - cancelDateFrom
4739 
     - cancelDateTo
4740 
    """
4741 
    self.send_getCancelledOrders(cancelDateFrom, cancelDateTo)
4742 
    return self.recv_getCancelledOrders()
4743 
 
4744 
  def send_getCancelledOrders(self, cancelDateFrom, cancelDateTo):
4745 
    self._oprot.writeMessageBegin('getCancelledOrders', TMessageType.CALL, self._seqid)
4746 
    args = getCancelledOrders_args()
4747 
    args.cancelDateFrom = cancelDateFrom
4748 
    args.cancelDateTo = cancelDateTo
4749 
    args.write(self._oprot)
4750 
    self._oprot.writeMessageEnd()
4751 
    self._oprot.trans.flush()
4752 
 
4753 
  def recv_getCancelledOrders(self, ):
4754 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4755 
    if mtype == TMessageType.EXCEPTION:
4756 
      x = TApplicationException()
4757 
      x.read(self._iprot)
4758 
      self._iprot.readMessageEnd()
4759 
      raise x
4760 
    result = getCancelledOrders_result()
4761 
    result.read(self._iprot)
4762 
    self._iprot.readMessageEnd()
4763 
    if result.success is not None:
4764 
      return result.success
4765 
    if result.ex is not None:
4766 
      raise result.ex
4767 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getCancelledOrders failed: unknown result");
4768 
 
4600 varun.gupt 4769 
  def saveBluedartSettlements(self, mapAWBAndAmount):
4770 
    """
4771 
    Parameters:
4772 
     - mapAWBAndAmount
4773 
    """
4774 
    self.send_saveBluedartSettlements(mapAWBAndAmount)
4775 
    self.recv_saveBluedartSettlements()
4776 
 
4777 
  def send_saveBluedartSettlements(self, mapAWBAndAmount):
4778 
    self._oprot.writeMessageBegin('saveBluedartSettlements', TMessageType.CALL, self._seqid)
4779 
    args = saveBluedartSettlements_args()
4780 
    args.mapAWBAndAmount = mapAWBAndAmount
4781 
    args.write(self._oprot)
4782 
    self._oprot.writeMessageEnd()
4783 
    self._oprot.trans.flush()
4784 
 
4785 
  def recv_saveBluedartSettlements(self, ):
4786 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4787 
    if mtype == TMessageType.EXCEPTION:
4788 
      x = TApplicationException()
4789 
      x.read(self._iprot)
4790 
      self._iprot.readMessageEnd()
4791 
      raise x
4792 
    result = saveBluedartSettlements_result()
4793 
    result.read(self._iprot)
4794 
    self._iprot.readMessageEnd()
4795 
    if result.ex is not None:
4796 
      raise result.ex
4797 
    return
4798 
 
4905 varun.gupt 4799 
  def savePaymentSettlements(self, settlementDate, paymentGatewayId, referenceId, serviceTax, otherCharges, netCollection):
4600 varun.gupt 4800 
    """
4801 
    Parameters:
4802 
     - settlementDate
4803 
     - paymentGatewayId
4905 varun.gupt 4804 
     - referenceId
4600 varun.gupt 4805 
     - serviceTax
4806 
     - otherCharges
4807 
     - netCollection
4808 
    """
4905 varun.gupt 4809 
    self.send_savePaymentSettlements(settlementDate, paymentGatewayId, referenceId, serviceTax, otherCharges, netCollection)
4600 varun.gupt 4810 
    self.recv_savePaymentSettlements()
4811 
 
4905 varun.gupt 4812 
  def send_savePaymentSettlements(self, settlementDate, paymentGatewayId, referenceId, serviceTax, otherCharges, netCollection):
4600 varun.gupt 4813 
    self._oprot.writeMessageBegin('savePaymentSettlements', TMessageType.CALL, self._seqid)
4814 
    args = savePaymentSettlements_args()
4815 
    args.settlementDate = settlementDate
4816 
    args.paymentGatewayId = paymentGatewayId
4905 varun.gupt 4817 
    args.referenceId = referenceId
4600 varun.gupt 4818 
    args.serviceTax = serviceTax
4819 
    args.otherCharges = otherCharges
4820 
    args.netCollection = netCollection
4821 
    args.write(self._oprot)
4822 
    self._oprot.writeMessageEnd()
4823 
    self._oprot.trans.flush()
4824 
 
4825 
  def recv_savePaymentSettlements(self, ):
4826 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4827 
    if mtype == TMessageType.EXCEPTION:
4828 
      x = TApplicationException()
4829 
      x.read(self._iprot)
4830 
      self._iprot.readMessageEnd()
4831 
      raise x
4832 
    result = savePaymentSettlements_result()
4833 
    result.read(self._iprot)
4834 
    self._iprot.readMessageEnd()
4835 
    if result.ex is not None:
4836 
      raise result.ex
4837 
    return
4838 
 
4839 
  def saveEBSSettlementSummary(self, settlementId, settlementDate, transactionDateFrom, transactionDateTo, amount):
4840 
    """
4841 
    Parameters:
4842 
     - settlementId
4843 
     - settlementDate
4844 
     - transactionDateFrom
4845 
     - transactionDateTo
4846 
     - amount
4847 
    """
4848 
    self.send_saveEBSSettlementSummary(settlementId, settlementDate, transactionDateFrom, transactionDateTo, amount)
4849 
    self.recv_saveEBSSettlementSummary()
4850 
 
4851 
  def send_saveEBSSettlementSummary(self, settlementId, settlementDate, transactionDateFrom, transactionDateTo, amount):
4852 
    self._oprot.writeMessageBegin('saveEBSSettlementSummary', TMessageType.CALL, self._seqid)
4853 
    args = saveEBSSettlementSummary_args()
4854 
    args.settlementId = settlementId
4855 
    args.settlementDate = settlementDate
4856 
    args.transactionDateFrom = transactionDateFrom
4857 
    args.transactionDateTo = transactionDateTo
4858 
    args.amount = amount
4859 
    args.write(self._oprot)
4860 
    self._oprot.writeMessageEnd()
4861 
    self._oprot.trans.flush()
4862 
 
4863 
  def recv_saveEBSSettlementSummary(self, ):
4864 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4865 
    if mtype == TMessageType.EXCEPTION:
4866 
      x = TApplicationException()
4867 
      x.read(self._iprot)
4868 
      self._iprot.readMessageEnd()
4869 
      raise x
4870 
    result = saveEBSSettlementSummary_result()
4871 
    result.read(self._iprot)
4872 
    self._iprot.readMessageEnd()
4873 
    if result.ex is not None:
4874 
      raise result.ex
4875 
    return
4876 
 
5386 phani.kuma 4877 
  def getSettlementForPrepaid(self, referenceId, isRefund):
4600 varun.gupt 4878 
    """
4879 
    Parameters:
5189 varun.gupt 4880 
     - referenceId
4881 
     - isRefund
4600 varun.gupt 4882 
    """
5386 phani.kuma 4883 
    self.send_getSettlementForPrepaid(referenceId, isRefund)
4884 
    return self.recv_getSettlementForPrepaid()
4600 varun.gupt 4885 
 
5386 phani.kuma 4886 
  def send_getSettlementForPrepaid(self, referenceId, isRefund):
4887 
    self._oprot.writeMessageBegin('getSettlementForPrepaid', TMessageType.CALL, self._seqid)
4888 
    args = getSettlementForPrepaid_args()
5189 varun.gupt 4889 
    args.referenceId = referenceId
4890 
    args.isRefund = isRefund
4600 varun.gupt 4891 
    args.write(self._oprot)
4892 
    self._oprot.writeMessageEnd()
4893 
    self._oprot.trans.flush()
4894 
 
5386 phani.kuma 4895 
  def recv_getSettlementForPrepaid(self, ):
4600 varun.gupt 4896 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4897 
    if mtype == TMessageType.EXCEPTION:
4898 
      x = TApplicationException()
4899 
      x.read(self._iprot)
4900 
      self._iprot.readMessageEnd()
4901 
      raise x
5386 phani.kuma 4902 
    result = getSettlementForPrepaid_result()
4600 varun.gupt 4903 
    result.read(self._iprot)
4904 
    self._iprot.readMessageEnd()
4905 
    if result.success is not None:
4906 
      return result.success
4907 
    if result.ex is not None:
4908 
      raise result.ex
5386 phani.kuma 4909 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getSettlementForPrepaid failed: unknown result");
4600 varun.gupt 4910 
 
5386 phani.kuma 4911 
  def getSettlementForCod(self, orderId, isRefund):
4912 
    """
4913 
    Parameters:
4914 
     - orderId
4915 
     - isRefund
4916 
    """
4917 
    self.send_getSettlementForCod(orderId, isRefund)
4918 
    return self.recv_getSettlementForCod()
4919 
 
4920 
  def send_getSettlementForCod(self, orderId, isRefund):
4921 
    self._oprot.writeMessageBegin('getSettlementForCod', TMessageType.CALL, self._seqid)
4922 
    args = getSettlementForCod_args()
4923 
    args.orderId = orderId
4924 
    args.isRefund = isRefund
4925 
    args.write(self._oprot)
4926 
    self._oprot.writeMessageEnd()
4927 
    self._oprot.trans.flush()
4928 
 
4929 
  def recv_getSettlementForCod(self, ):
4930 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4931 
    if mtype == TMessageType.EXCEPTION:
4932 
      x = TApplicationException()
4933 
      x.read(self._iprot)
4934 
      self._iprot.readMessageEnd()
4935 
      raise x
4936 
    result = getSettlementForCod_result()
4937 
    result.read(self._iprot)
4938 
    self._iprot.readMessageEnd()
4939 
    if result.success is not None:
4940 
      return result.success
4941 
    if result.ex is not None:
4942 
      raise result.ex
4943 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getSettlementForCod failed: unknown result");
4944 
 
4600 varun.gupt 4945 
  def getEBSSettlementSummaries(self, ):
4946 
    self.send_getEBSSettlementSummaries()
4947 
    return self.recv_getEBSSettlementSummaries()
4948 
 
4949 
  def send_getEBSSettlementSummaries(self, ):
4950 
    self._oprot.writeMessageBegin('getEBSSettlementSummaries', TMessageType.CALL, self._seqid)
4951 
    args = getEBSSettlementSummaries_args()
4952 
    args.write(self._oprot)
4953 
    self._oprot.writeMessageEnd()
4954 
    self._oprot.trans.flush()
4955 
 
4956 
  def recv_getEBSSettlementSummaries(self, ):
4957 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4958 
    if mtype == TMessageType.EXCEPTION:
4959 
      x = TApplicationException()
4960 
      x.read(self._iprot)
4961 
      self._iprot.readMessageEnd()
4962 
      raise x
4963 
    result = getEBSSettlementSummaries_result()
4964 
    result.read(self._iprot)
4965 
    self._iprot.readMessageEnd()
4966 
    if result.success is not None:
4967 
      return result.success
4968 
    if result.ex is not None:
4969 
      raise result.ex
4970 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getEBSSettlementSummaries failed: unknown result");
4971 
 
4972 
  def markEBSSettlementUploaded(self, settlementId):
4973 
    """
4974 
    Parameters:
4975 
     - settlementId
4976 
    """
4977 
    self.send_markEBSSettlementUploaded(settlementId)
4978 
    self.recv_markEBSSettlementUploaded()
4979 
 
4980 
  def send_markEBSSettlementUploaded(self, settlementId):
4981 
    self._oprot.writeMessageBegin('markEBSSettlementUploaded', TMessageType.CALL, self._seqid)
4982 
    args = markEBSSettlementUploaded_args()
4983 
    args.settlementId = settlementId
4984 
    args.write(self._oprot)
4985 
    self._oprot.writeMessageEnd()
4986 
    self._oprot.trans.flush()
4987 
 
4988 
  def recv_markEBSSettlementUploaded(self, ):
4989 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4990 
    if mtype == TMessageType.EXCEPTION:
4991 
      x = TApplicationException()
4992 
      x.read(self._iprot)
4993 
      self._iprot.readMessageEnd()
4994 
      raise x
4995 
    result = markEBSSettlementUploaded_result()
4996 
    result.read(self._iprot)
4997 
    self._iprot.readMessageEnd()
4998 
    if result.ex is not None:
4999 
      raise result.ex
5000 
    return
5001 
 
5002 
  def getEBSSettlementDate(self, settlementId):
5003 
    """
5004 
    Parameters:
5005 
     - settlementId
5006 
    """
5007 
    self.send_getEBSSettlementDate(settlementId)
5008 
    return self.recv_getEBSSettlementDate()
5009 
 
5010 
  def send_getEBSSettlementDate(self, settlementId):
5011 
    self._oprot.writeMessageBegin('getEBSSettlementDate', TMessageType.CALL, self._seqid)
5012 
    args = getEBSSettlementDate_args()
5013 
    args.settlementId = settlementId
5014 
    args.write(self._oprot)
5015 
    self._oprot.writeMessageEnd()
5016 
    self._oprot.trans.flush()
5017 
 
5018 
  def recv_getEBSSettlementDate(self, ):
5019 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
5020 
    if mtype == TMessageType.EXCEPTION:
5021 
      x = TApplicationException()
5022 
      x.read(self._iprot)
5023 
      self._iprot.readMessageEnd()
5024 
      raise x
5025 
    result = getEBSSettlementDate_result()
5026 
    result.read(self._iprot)
5027 
    self._iprot.readMessageEnd()
5028 
    if result.success is not None:
5029 
      return result.success
5030 
    if result.ex is not None:
5031 
      raise result.ex
5032 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getEBSSettlementDate failed: unknown result");
5033 
 
4715 varun.gupt 5034 
  def getSettlementsByDate(self, settlementDateFrom, settlementDateTo, isRefund):
5035 
    """
5036 
    Parameters:
5037 
     - settlementDateFrom
5038 
     - settlementDateTo
5039 
     - isRefund
5040 
    """
5041 
    self.send_getSettlementsByDate(settlementDateFrom, settlementDateTo, isRefund)
5042 
    return self.recv_getSettlementsByDate()
4600 varun.gupt 5043 
 
4715 varun.gupt 5044 
  def send_getSettlementsByDate(self, settlementDateFrom, settlementDateTo, isRefund):
5045 
    self._oprot.writeMessageBegin('getSettlementsByDate', TMessageType.CALL, self._seqid)
5046 
    args = getSettlementsByDate_args()
5047 
    args.settlementDateFrom = settlementDateFrom
5048 
    args.settlementDateTo = settlementDateTo
5049 
    args.isRefund = isRefund
5050 
    args.write(self._oprot)
5051 
    self._oprot.writeMessageEnd()
5052 
    self._oprot.trans.flush()
5053 
 
5054 
  def recv_getSettlementsByDate(self, ):
5055 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
5056 
    if mtype == TMessageType.EXCEPTION:
5057 
      x = TApplicationException()
5058 
      x.read(self._iprot)
5059 
      self._iprot.readMessageEnd()
5060 
      raise x
5061 
    result = getSettlementsByDate_result()
5062 
    result.read(self._iprot)
5063 
    self._iprot.readMessageEnd()
5064 
    if result.success is not None:
5065 
      return result.success
5066 
    if result.ex is not None:
5067 
      raise result.ex
5068 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getSettlementsByDate failed: unknown result");
5069 
 
5070 
  def getReshippedOrderIds(self, orderIds):
5071 
    """
5072 
    Returns list of Order Ids, which belong to reshiped orders, shortlisted from a given list of Order Ids
5073 
 
5074 
    Parameters:
5075 
     - orderIds
5076 
    """
5077 
    self.send_getReshippedOrderIds(orderIds)
5078 
    return self.recv_getReshippedOrderIds()
5079 
 
5080 
  def send_getReshippedOrderIds(self, orderIds):
5081 
    self._oprot.writeMessageBegin('getReshippedOrderIds', TMessageType.CALL, self._seqid)
5082 
    args = getReshippedOrderIds_args()
5083 
    args.orderIds = orderIds
5084 
    args.write(self._oprot)
5085 
    self._oprot.writeMessageEnd()
5086 
    self._oprot.trans.flush()
5087 
 
5088 
  def recv_getReshippedOrderIds(self, ):
5089 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
5090 
    if mtype == TMessageType.EXCEPTION:
5091 
      x = TApplicationException()
5092 
      x.read(self._iprot)
5093 
      self._iprot.readMessageEnd()
5094 
      raise x
5095 
    result = getReshippedOrderIds_result()
5096 
    result.read(self._iprot)
5097 
    self._iprot.readMessageEnd()
5098 
    if result.success is not None:
5099 
      return result.success
5100 
    if result.ex is not None:
5101 
      raise result.ex
5102 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getReshippedOrderIds failed: unknown result");
5103 
 
5481 phani.kuma 5104 
  def getBilledOrders(self, vendorId, onlyVendorNotPaid, billingDateFrom, billingDateTo):
4875 varun.gupt 5105 
    """
5106 
    Parameters:
5107 
     - vendorId
5481 phani.kuma 5108 
     - onlyVendorNotPaid
5109 
     - billingDateFrom
5110 
     - billingDateTo
4875 varun.gupt 5111 
    """
5481 phani.kuma 5112 
    self.send_getBilledOrders(vendorId, onlyVendorNotPaid, billingDateFrom, billingDateTo)
5113 
    return self.recv_getBilledOrders()
4757 mandeep.dh 5114 
 
5481 phani.kuma 5115 
  def send_getBilledOrders(self, vendorId, onlyVendorNotPaid, billingDateFrom, billingDateTo):
5116 
    self._oprot.writeMessageBegin('getBilledOrders', TMessageType.CALL, self._seqid)
5117 
    args = getBilledOrders_args()
4875 varun.gupt 5118 
    args.vendorId = vendorId
5481 phani.kuma 5119 
    args.onlyVendorNotPaid = onlyVendorNotPaid
5120 
    args.billingDateFrom = billingDateFrom
5121 
    args.billingDateTo = billingDateTo
4875 varun.gupt 5122 
    args.write(self._oprot)
5123 
    self._oprot.writeMessageEnd()
5124 
    self._oprot.trans.flush()
5125 
 
5481 phani.kuma 5126 
  def recv_getBilledOrders(self, ):
4875 varun.gupt 5127 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
5128 
    if mtype == TMessageType.EXCEPTION:
5129 
      x = TApplicationException()
5130 
      x.read(self._iprot)
5131 
      self._iprot.readMessageEnd()
5132 
      raise x
5481 phani.kuma 5133 
    result = getBilledOrders_result()
4875 varun.gupt 5134 
    result.read(self._iprot)
5135 
    self._iprot.readMessageEnd()
5136 
    if result.success is not None:
5137 
      return result.success
5138 
    if result.ex is not None:
5139 
      raise result.ex
5481 phani.kuma 5140 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getBilledOrders failed: unknown result");
4875 varun.gupt 5141 
 
5031 varun.gupt 5142 
  def getStatusDistributionOfOrders(self, startDate, endDate):
5143 
    """
5144 
    Parameters:
5145 
     - startDate
5146 
     - endDate
5147 
    """
5148 
    self.send_getStatusDistributionOfOrders(startDate, endDate)
5149 
    return self.recv_getStatusDistributionOfOrders()
4875 varun.gupt 5150 
 
5031 varun.gupt 5151 
  def send_getStatusDistributionOfOrders(self, startDate, endDate):
5152 
    self._oprot.writeMessageBegin('getStatusDistributionOfOrders', TMessageType.CALL, self._seqid)
5153 
    args = getStatusDistributionOfOrders_args()
5154 
    args.startDate = startDate
5155 
    args.endDate = endDate
5156 
    args.write(self._oprot)
5157 
    self._oprot.writeMessageEnd()
5158 
    self._oprot.trans.flush()
5159 
 
5160 
  def recv_getStatusDistributionOfOrders(self, ):
5161 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
5162 
    if mtype == TMessageType.EXCEPTION:
5163 
      x = TApplicationException()
5164 
      x.read(self._iprot)
5165 
      self._iprot.readMessageEnd()
5166 
      raise x
5167 
    result = getStatusDistributionOfOrders_result()
5168 
    result.read(self._iprot)
5169 
    self._iprot.readMessageEnd()
5170 
    if result.success is not None:
5171 
      return result.success
5172 
    if result.ex is not None:
5173 
      raise result.ex
5174 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getStatusDistributionOfOrders failed: unknown result");
5175 
 
5067 varun.gupt 5176 
  def getOrderIdsForStatus(self, status, startDatetime, endDatetime):
5177 
    """
5178 
    Parameters:
5179 
     - status
5180 
     - startDatetime
5181 
     - endDatetime
5182 
    """
5183 
    self.send_getOrderIdsForStatus(status, startDatetime, endDatetime)
5184 
    return self.recv_getOrderIdsForStatus()
5031 varun.gupt 5185 
 
5067 varun.gupt 5186 
  def send_getOrderIdsForStatus(self, status, startDatetime, endDatetime):
5187 
    self._oprot.writeMessageBegin('getOrderIdsForStatus', TMessageType.CALL, self._seqid)
5188 
    args = getOrderIdsForStatus_args()
5189 
    args.status = status
5190 
    args.startDatetime = startDatetime
5191 
    args.endDatetime = endDatetime
5192 
    args.write(self._oprot)
5193 
    self._oprot.writeMessageEnd()
5194 
    self._oprot.trans.flush()
5195 
 
5196 
  def recv_getOrderIdsForStatus(self, ):
5197 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
5198 
    if mtype == TMessageType.EXCEPTION:
5199 
      x = TApplicationException()
5200 
      x.read(self._iprot)
5201 
      self._iprot.readMessageEnd()
5202 
      raise x
5203 
    result = getOrderIdsForStatus_result()
5204 
    result.read(self._iprot)
5205 
    self._iprot.readMessageEnd()
5206 
    if result.success is not None:
5207 
      return result.success
5208 
    if result.ex is not None:
5209 
      raise result.ex
5210 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getOrderIdsForStatus failed: unknown result");
5211 
 
5348 anupam.sin 5212 
  def updateCODAgent(self, agent, orderId):
5213 
    """
5214 
    Updates the agent who handled the COD verification call
5215 
 
5216 
    Parameters:
5217 
     - agent
5218 
     - orderId
5219 
    """
5220 
    self.send_updateCODAgent(agent, orderId)
5221 
    self.recv_updateCODAgent()
5222 
 
5223 
  def send_updateCODAgent(self, agent, orderId):
5224 
    self._oprot.writeMessageBegin('updateCODAgent', TMessageType.CALL, self._seqid)
5225 
    args = updateCODAgent_args()
5226 
    args.agent = agent
5227 
    args.orderId = orderId
5228 
    args.write(self._oprot)
5229 
    self._oprot.writeMessageEnd()
5230 
    self._oprot.trans.flush()
5231 
 
5232 
  def recv_updateCODAgent(self, ):
5233 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
5234 
    if mtype == TMessageType.EXCEPTION:
5235 
      x = TApplicationException()
5236 
      x.read(self._iprot)
5237 
      self._iprot.readMessageEnd()
5238 
      raise x
5239 
    result = updateCODAgent_result()
5240 
    result.read(self._iprot)
5241 
    self._iprot.readMessageEnd()
5242 
    if result.ex is not None:
5243 
      raise result.ex
5244 
    return
5245 
 
5099 varun.gupt 5246 
  def updateOrderAsPaidToVendor(self, orderId):
5247 
    """
5248 
    Parameters:
5249 
     - orderId
5250 
    """
5251 
    self.send_updateOrderAsPaidToVendor(orderId)
5252 
    self.recv_updateOrderAsPaidToVendor()
5067 varun.gupt 5253 
 
5099 varun.gupt 5254 
  def send_updateOrderAsPaidToVendor(self, orderId):
5255 
    self._oprot.writeMessageBegin('updateOrderAsPaidToVendor', TMessageType.CALL, self._seqid)
5256 
    args = updateOrderAsPaidToVendor_args()
5257 
    args.orderId = orderId
5258 
    args.write(self._oprot)
5259 
    self._oprot.writeMessageEnd()
5260 
    self._oprot.trans.flush()
5261 
 
5262 
  def recv_updateOrderAsPaidToVendor(self, ):
5263 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
5264 
    if mtype == TMessageType.EXCEPTION:
5265 
      x = TApplicationException()
5266 
      x.read(self._iprot)
5267 
      self._iprot.readMessageEnd()
5268 
      raise x
5269 
    result = updateOrderAsPaidToVendor_result()
5270 
    result.read(self._iprot)
5271 
    self._iprot.readMessageEnd()
5272 
    if result.ex is not None:
5273 
      raise result.ex
5274 
    return
5275 
 
5386 phani.kuma 5276 
  def updateOrderOnlyAsPaidToVendor(self, orderId):
5277 
    """
5278 
    Parameters:
5279 
     - orderId
5280 
    """
5281 
    self.send_updateOrderOnlyAsPaidToVendor(orderId)
5282 
    self.recv_updateOrderOnlyAsPaidToVendor()
5283 
 
5284 
  def send_updateOrderOnlyAsPaidToVendor(self, orderId):
5285 
    self._oprot.writeMessageBegin('updateOrderOnlyAsPaidToVendor', TMessageType.CALL, self._seqid)
5286 
    args = updateOrderOnlyAsPaidToVendor_args()
5287 
    args.orderId = orderId
5288 
    args.write(self._oprot)
5289 
    self._oprot.writeMessageEnd()
5290 
    self._oprot.trans.flush()
5291 
 
5292 
  def recv_updateOrderOnlyAsPaidToVendor(self, ):
5293 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
5294 
    if mtype == TMessageType.EXCEPTION:
5295 
      x = TApplicationException()
5296 
      x.read(self._iprot)
5297 
      self._iprot.readMessageEnd()
5298 
      raise x
5299 
    result = updateOrderOnlyAsPaidToVendor_result()
5300 
    result.read(self._iprot)
5301 
    self._iprot.readMessageEnd()
5302 
    if result.ex is not None:
5303 
      raise result.ex
5304 
    return
5305 
 
5208 varun.gupt 5306 
  def getRefundedOrdersMarkedPaid(self, ):
5307 
    self.send_getRefundedOrdersMarkedPaid()
5308 
    return self.recv_getRefundedOrdersMarkedPaid()
5099 varun.gupt 5309 
 
5208 varun.gupt 5310 
  def send_getRefundedOrdersMarkedPaid(self, ):
5311 
    self._oprot.writeMessageBegin('getRefundedOrdersMarkedPaid', TMessageType.CALL, self._seqid)
5312 
    args = getRefundedOrdersMarkedPaid_args()
5313 
    args.write(self._oprot)
5314 
    self._oprot.writeMessageEnd()
5315 
    self._oprot.trans.flush()
5316 
 
5317 
  def recv_getRefundedOrdersMarkedPaid(self, ):
5318 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
5319 
    if mtype == TMessageType.EXCEPTION:
5320 
      x = TApplicationException()
5321 
      x.read(self._iprot)
5322 
      self._iprot.readMessageEnd()
5323 
      raise x
5324 
    result = getRefundedOrdersMarkedPaid_result()
5325 
    result.read(self._iprot)
5326 
    self._iprot.readMessageEnd()
5327 
    if result.success is not None:
5328 
      return result.success
5329 
    if result.ex is not None:
5330 
      raise result.ex
5331 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getRefundedOrdersMarkedPaid failed: unknown result");
5332 
 
5447 anupam.sin 5333 
  def getAllVerificationAgents(self, minOrderId, maxOrderId):
5334 
    """
5335 
    gets all COD Verification Agents for all orderIds from a minId to maxId
5208 varun.gupt 5336 
 
5447 anupam.sin 5337 
 
5338 
    Parameters:
5339 
     - minOrderId
5340 
     - maxOrderId
5341 
    """
5342 
    self.send_getAllVerificationAgents(minOrderId, maxOrderId)
5343 
    return self.recv_getAllVerificationAgents()
5344 
 
5345 
  def send_getAllVerificationAgents(self, minOrderId, maxOrderId):
5346 
    self._oprot.writeMessageBegin('getAllVerificationAgents', TMessageType.CALL, self._seqid)
5347 
    args = getAllVerificationAgents_args()
5348 
    args.minOrderId = minOrderId
5349 
    args.maxOrderId = maxOrderId
5350 
    args.write(self._oprot)
5351 
    self._oprot.writeMessageEnd()
5352 
    self._oprot.trans.flush()
5353 
 
5354 
  def recv_getAllVerificationAgents(self, ):
5355 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
5356 
    if mtype == TMessageType.EXCEPTION:
5357 
      x = TApplicationException()
5358 
      x.read(self._iprot)
5359 
      self._iprot.readMessageEnd()
5360 
      raise x
5361 
    result = getAllVerificationAgents_result()
5362 
    result.read(self._iprot)
5363 
    self._iprot.readMessageEnd()
5364 
    if result.success is not None:
5365 
      return result.success
5366 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAllVerificationAgents failed: unknown result");
5367 
 
5527 anupam.sin 5368 
  def getAllAttributesForOrderId(self, orderId):
5369 
    """
5370 
    gets all attributes for a given orderId
5447 anupam.sin 5371 
 
5527 anupam.sin 5372 
    Parameters:
5373 
     - orderId
5374 
    """
5375 
    self.send_getAllAttributesForOrderId(orderId)
5376 
    return self.recv_getAllAttributesForOrderId()
5377 
 
5378 
  def send_getAllAttributesForOrderId(self, orderId):
5379 
    self._oprot.writeMessageBegin('getAllAttributesForOrderId', TMessageType.CALL, self._seqid)
5380 
    args = getAllAttributesForOrderId_args()
5381 
    args.orderId = orderId
5382 
    args.write(self._oprot)
5383 
    self._oprot.writeMessageEnd()
5384 
    self._oprot.trans.flush()
5385 
 
5386 
  def recv_getAllAttributesForOrderId(self, ):
5387 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
5388 
    if mtype == TMessageType.EXCEPTION:
5389 
      x = TApplicationException()
5390 
      x.read(self._iprot)
5391 
      self._iprot.readMessageEnd()
5392 
      raise x
5393 
    result = getAllAttributesForOrderId_result()
5394 
    result.read(self._iprot)
5395 
    self._iprot.readMessageEnd()
5396 
    if result.success is not None:
5397 
      return result.success
5398 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAllAttributesForOrderId failed: unknown result");
5399 
 
5676 rajveer 5400 
  def setOrderAttributes(self, orderId, attributes):
5401 
    """
5402 
    sets attributes for an order
5403 
 
5404 
    Parameters:
5405 
     - orderId
5406 
     - attributes
5407 
    """
5408 
    self.send_setOrderAttributes(orderId, attributes)
5409 
    self.recv_setOrderAttributes()
5410 
 
5411 
  def send_setOrderAttributes(self, orderId, attributes):
5412 
    self._oprot.writeMessageBegin('setOrderAttributes', TMessageType.CALL, self._seqid)
5413 
    args = setOrderAttributes_args()
5414 
    args.orderId = orderId
5415 
    args.attributes = attributes
5416 
    args.write(self._oprot)
5417 
    self._oprot.writeMessageEnd()
5418 
    self._oprot.trans.flush()
5419 
 
5420 
  def recv_setOrderAttributes(self, ):
5421 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
5422 
    if mtype == TMessageType.EXCEPTION:
5423 
      x = TApplicationException()
5424 
      x.read(self._iprot)
5425 
      self._iprot.readMessageEnd()
5426 
      raise x
5427 
    result = setOrderAttributes_result()
5428 
    result.read(self._iprot)
5429 
    self._iprot.readMessageEnd()
5430 
    return
5431 
 
5527 anupam.sin 5432 
  def setOrderAttributeForTransaction(self, transactionId, attribute):
5433 
    """
5434 
    sets attributes for all orders in a transaction
5435 
 
5436 
    Parameters:
5437 
     - transactionId
5438 
     - attribute
5439 
    """
5440 
    self.send_setOrderAttributeForTransaction(transactionId, attribute)
5441 
    self.recv_setOrderAttributeForTransaction()
5442 
 
5443 
  def send_setOrderAttributeForTransaction(self, transactionId, attribute):
5444 
    self._oprot.writeMessageBegin('setOrderAttributeForTransaction', TMessageType.CALL, self._seqid)
5445 
    args = setOrderAttributeForTransaction_args()
5446 
    args.transactionId = transactionId
5447 
    args.attribute = attribute
5448 
    args.write(self._oprot)
5449 
    self._oprot.writeMessageEnd()
5450 
    self._oprot.trans.flush()
5451 
 
5452 
  def recv_setOrderAttributeForTransaction(self, ):
5453 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
5454 
    if mtype == TMessageType.EXCEPTION:
5455 
      x = TApplicationException()
5456 
      x.read(self._iprot)
5457 
      self._iprot.readMessageEnd()
5458 
      raise x
5459 
    result = setOrderAttributeForTransaction_result()
5460 
    result.read(self._iprot)
5461 
    self._iprot.readMessageEnd()
5462 
    return
5463 
 
5553 rajveer 5464 
  def getReceivePendingOrders(self, storeId):
5465 
    """
5466 
    Parameters:
5467 
     - storeId
5468 
    """
5469 
    self.send_getReceivePendingOrders(storeId)
5470 
    return self.recv_getReceivePendingOrders()
5527 anupam.sin 5471 
 
5553 rajveer 5472 
  def send_getReceivePendingOrders(self, storeId):
5473 
    self._oprot.writeMessageBegin('getReceivePendingOrders', TMessageType.CALL, self._seqid)
5474 
    args = getReceivePendingOrders_args()
5475 
    args.storeId = storeId
5476 
    args.write(self._oprot)
5477 
    self._oprot.writeMessageEnd()
5478 
    self._oprot.trans.flush()
5479 
 
5480 
  def recv_getReceivePendingOrders(self, ):
5481 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
5482 
    if mtype == TMessageType.EXCEPTION:
5483 
      x = TApplicationException()
5484 
      x.read(self._iprot)
5485 
      self._iprot.readMessageEnd()
5486 
      raise x
5487 
    result = getReceivePendingOrders_result()
5488 
    result.read(self._iprot)
5489 
    self._iprot.readMessageEnd()
5490 
    if result.success is not None:
5491 
      return result.success
5492 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getReceivePendingOrders failed: unknown result");
5493 
 
5494 
  def getReceivedAtStoreOrders(self, storeId):
5495 
    """
5496 
    Parameters:
5497 
     - storeId
5498 
    """
5499 
    self.send_getReceivedAtStoreOrders(storeId)
5500 
    return self.recv_getReceivedAtStoreOrders()
5501 
 
5502 
  def send_getReceivedAtStoreOrders(self, storeId):
5503 
    self._oprot.writeMessageBegin('getReceivedAtStoreOrders', TMessageType.CALL, self._seqid)
5504 
    args = getReceivedAtStoreOrders_args()
5505 
    args.storeId = storeId
5506 
    args.write(self._oprot)
5507 
    self._oprot.writeMessageEnd()
5508 
    self._oprot.trans.flush()
5509 
 
5510 
  def recv_getReceivedAtStoreOrders(self, ):
5511 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
5512 
    if mtype == TMessageType.EXCEPTION:
5513 
      x = TApplicationException()
5514 
      x.read(self._iprot)
5515 
      self._iprot.readMessageEnd()
5516 
      raise x
5517 
    result = getReceivedAtStoreOrders_result()
5518 
    result.read(self._iprot)
5519 
    self._iprot.readMessageEnd()
5520 
    if result.success is not None:
5521 
      return result.success
5522 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getReceivedAtStoreOrders failed: unknown result");
5523 
 
5593 mandeep.dh 5524 
  def acceptOrderForItem(self, itemId, quantity, fulfilmentWarehouseId, billingWarehouseId):
5525 
    """
5526 
    Accepts appropriate order for an item in a given billingWarehouse. Usually
5527 
    invoked while scanning IN of items.
5553 rajveer 5528 
 
5593 mandeep.dh 5529 
    Parameters:
5530 
     - itemId
5531 
     - quantity
5532 
     - fulfilmentWarehouseId
5533 
     - billingWarehouseId
5534 
    """
5535 
    self.send_acceptOrderForItem(itemId, quantity, fulfilmentWarehouseId, billingWarehouseId)
5536 
    self.recv_acceptOrderForItem()
5537 
 
5538 
  def send_acceptOrderForItem(self, itemId, quantity, fulfilmentWarehouseId, billingWarehouseId):
5539 
    self._oprot.writeMessageBegin('acceptOrderForItem', TMessageType.CALL, self._seqid)
5540 
    args = acceptOrderForItem_args()
5541 
    args.itemId = itemId
5542 
    args.quantity = quantity
5543 
    args.fulfilmentWarehouseId = fulfilmentWarehouseId
5544 
    args.billingWarehouseId = billingWarehouseId
5545 
    args.write(self._oprot)
5546 
    self._oprot.writeMessageEnd()
5547 
    self._oprot.trans.flush()
5548 
 
5549 
  def recv_acceptOrderForItem(self, ):
5550 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
5551 
    if mtype == TMessageType.EXCEPTION:
5552 
      x = TApplicationException()
5553 
      x.read(self._iprot)
5554 
      self._iprot.readMessageEnd()
5555 
      raise x
5556 
    result = acceptOrderForItem_result()
5557 
    result.read(self._iprot)
5558 
    self._iprot.readMessageEnd()
5559 
    return
5560 
 
5561 
 
3376 rajveer 5562 
class Processor(shop2020.thriftpy.generic.GenericService.Processor, Iface, TProcessor):
94 ashish 5563 
  def __init__(self, handler):
3376 rajveer 5564 
    shop2020.thriftpy.generic.GenericService.Processor.__init__(self, handler)
94 ashish 5565 
    self._processMap["createTransaction"] = Processor.process_createTransaction
5566 
    self._processMap["getTransaction"] = Processor.process_getTransaction
5567 
    self._processMap["getTransactionsForCustomer"] = Processor.process_getTransactionsForCustomer
132 ashish 5568 
    self._processMap["getTransactionsForShoppingCartId"] = Processor.process_getTransactionsForShoppingCartId
94 ashish 5569 
    self._processMap["getTransactionStatus"] = Processor.process_getTransactionStatus
5570 
    self._processMap["changeTransactionStatus"] = Processor.process_changeTransactionStatus
1398 varun.gupt 5571 
    self._processMap["enqueueTransactionInfoEmail"] = Processor.process_enqueueTransactionInfoEmail
483 rajveer 5572 
    self._processMap["getAllOrders"] = Processor.process_getAllOrders
4133 chandransh 5573 
    self._processMap["getOrdersInBatch"] = Processor.process_getOrdersInBatch
5574 
    self._processMap["getOrderCount"] = Processor.process_getOrderCount
999 varun.gupt 5575 
    self._processMap["getOrdersByBillingDate"] = Processor.process_getOrdersByBillingDate
3427 chandransh 5576 
    self._processMap["getOrdersByShippingDate"] = Processor.process_getOrdersByShippingDate
1382 varun.gupt 5577 
    self._processMap["getReturnableOrdersForCustomer"] = Processor.process_getReturnableOrdersForCustomer
5578 
    self._processMap["getCancellableOrdersForCustomer"] = Processor.process_getCancellableOrdersForCustomer
483 rajveer 5579 
    self._processMap["changeOrderStatus"] = Processor.process_changeOrderStatus
5580 
    self._processMap["getOrdersForTransaction"] = Processor.process_getOrdersForTransaction
5581 
    self._processMap["getOrdersForCustomer"] = Processor.process_getOrdersForCustomer
5582 
    self._processMap["createOrder"] = Processor.process_createOrder
5583 
    self._processMap["getOrder"] = Processor.process_getOrder
5584 
    self._processMap["getLineItemsForOrder"] = Processor.process_getLineItemsForOrder
4999 phani.kuma 5585 
    self._processMap["getOrderList"] = Processor.process_getOrderList
5386 phani.kuma 5586 
    self._processMap["getOrderListForVendor"] = Processor.process_getOrderListForVendor
1528 ankur.sing 5587 
    self._processMap["getOrderForCustomer"] = Processor.process_getOrderForCustomer
3064 chandransh 5588 
    self._processMap["getAlerts"] = Processor.process_getAlerts
4394 rajveer 5589 
    self._processMap["addAlert"] = Processor.process_addAlert
4444 rajveer 5590 
    self._processMap["markAlertsAsSeen"] = Processor.process_markAlertsAsSeen
3064 chandransh 5591 
    self._processMap["getValidOrderCount"] = Processor.process_getValidOrderCount
5592 
    self._processMap["getNoOfCustomersWithSuccessfulTransaction"] = Processor.process_getNoOfCustomersWithSuccessfulTransaction
5593 
    self._processMap["getValidOrdersAmountRange"] = Processor.process_getValidOrdersAmountRange
5594 
    self._processMap["getValidOrders"] = Processor.process_getValidOrders
1220 chandransh 5595 
    self._processMap["batchOrders"] = Processor.process_batchOrders
1208 chandransh 5596 
    self._processMap["markOrderAsOutOfStock"] = Processor.process_markOrderAsOutOfStock
3064 chandransh 5597 
    self._processMap["verifyOrder"] = Processor.process_verifyOrder
5598 
    self._processMap["acceptOrder"] = Processor.process_acceptOrder
5599 
    self._processMap["addBillingDetails"] = Processor.process_addBillingDetails
4579 rajveer 5600 
    self._processMap["addInvoiceNumber"] = Processor.process_addInvoiceNumber
4410 rajveer 5601 
    self._processMap["markOrdersAsShippedFromWarehouse"] = Processor.process_markOrdersAsShippedFromWarehouse
5676 rajveer 5602 
    self._processMap["markOrdersAsReturnedFromStore"] = Processor.process_markOrdersAsReturnedFromStore
1113 chandransh 5603 
    self._processMap["markOrdersAsPickedUp"] = Processor.process_markOrdersAsPickedUp
4910 phani.kuma 5604 
    self._processMap["getOrdersNotPickedUp"] = Processor.process_getOrdersNotPickedUp
1132 chandransh 5605 
    self._processMap["markOrdersAsDelivered"] = Processor.process_markOrdersAsDelivered
4910 phani.kuma 5606 
    self._processMap["markAsRTOrders"] = Processor.process_markAsRTOrders
5607 
    self._processMap["getRTOrders"] = Processor.process_getRTOrders
1246 chandransh 5608 
    self._processMap["updateNonDeliveryReason"] = Processor.process_updateNonDeliveryReason
4910 phani.kuma 5609 
    self._processMap["getNonDeliveredOrdersbyCourier"] = Processor.process_getNonDeliveredOrdersbyCourier
5610 
    self._processMap["markOrdersAsLocalConnected"] = Processor.process_markOrdersAsLocalConnected
5611 
    self._processMap["getOrdersNotLocalConnected"] = Processor.process_getOrdersNotLocalConnected
5612 
    self._processMap["markOrdersAsDestinationCityReached"] = Processor.process_markOrdersAsDestinationCityReached
5613 
    self._processMap["markOrdersAsFirstDeliveryAttempted"] = Processor.process_markOrdersAsFirstDeliveryAttempted
1408 ankur.sing 5614 
    self._processMap["getUndeliveredOrders"] = Processor.process_getUndeliveredOrders
4783 phani.kuma 5615 
    self._processMap["getUndeliveredOrdersExpectedDeliveryDateNotMet"] = Processor.process_getUndeliveredOrdersExpectedDeliveryDateNotMet
2536 chandransh 5616 
    self._processMap["toggleDOAFlag"] = Processor.process_toggleDOAFlag
4712 rajveer 5617 
    self._processMap["markOrderAsDelivered"] = Processor.process_markOrderAsDelivered
5553 rajveer 5618 
    self._processMap["markOrderAsReceivedAtStore"] = Processor.process_markOrderAsReceivedAtStore
4454 rajveer 5619 
    self._processMap["markOrderDoaRequestReceived"] = Processor.process_markOrderDoaRequestReceived
5620 
    self._processMap["markOrderDoaRequestAuthorized"] = Processor.process_markOrderDoaRequestAuthorized
4488 rajveer 5621 
    self._processMap["markOrderReturnRequestReceived"] = Processor.process_markOrderReturnRequestReceived
5622 
    self._processMap["markOrderReturnRequestAuthorized"] = Processor.process_markOrderReturnRequestAuthorized
2536 chandransh 5623 
    self._processMap["requestPickupNumber"] = Processor.process_requestPickupNumber
5624 
    self._processMap["authorizePickup"] = Processor.process_authorizePickup
2764 chandransh 5625 
    self._processMap["markDoasAsPickedUp"] = Processor.process_markDoasAsPickedUp
4910 phani.kuma 5626 
    self._processMap["getDoasNotPickedUp"] = Processor.process_getDoasNotPickedUp
4741 phani.kuma 5627 
    self._processMap["markReturnOrdersAsPickedUp"] = Processor.process_markReturnOrdersAsPickedUp
4910 phani.kuma 5628 
    self._processMap["getReturnOrdersNotPickedUp"] = Processor.process_getReturnOrdersNotPickedUp
2616 chandransh 5629 
    self._processMap["receiveReturn"] = Processor.process_receiveReturn
2591 chandransh 5630 
    self._processMap["validateDoa"] = Processor.process_validateDoa
4495 rajveer 5631 
    self._processMap["validateReturnProduct"] = Processor.process_validateReturnProduct
2616 chandransh 5632 
    self._processMap["reshipOrder"] = Processor.process_reshipOrder
5633 
    self._processMap["refundOrder"] = Processor.process_refundOrder
2690 chandransh 5634 
    self._processMap["getReturnOrders"] = Processor.process_getReturnOrders
5481 phani.kuma 5635 
    self._processMap["getAllReturnOrders"] = Processor.process_getAllReturnOrders
2700 chandransh 5636 
    self._processMap["getReturnOrder"] = Processor.process_getReturnOrder
2690 chandransh 5637 
    self._processMap["processReturn"] = Processor.process_processReturn
3451 chandransh 5638 
    self._processMap["updateWeight"] = Processor.process_updateWeight
3469 chandransh 5639 
    self._processMap["changeItem"] = Processor.process_changeItem
5640 
    self._processMap["shiftToWarehouse"] = Processor.process_shiftToWarehouse
3553 chandransh 5641 
    self._processMap["addDelayReason"] = Processor.process_addDelayReason
3956 chandransh 5642 
    self._processMap["reconcileCodCollection"] = Processor.process_reconcileCodCollection
4008 mandeep.dh 5643 
    self._processMap["getTransactionsRequiringExtraProcessing"] = Processor.process_getTransactionsRequiringExtraProcessing
5644 
    self._processMap["markTransactionAsProcessed"] = Processor.process_markTransactionAsProcessed
4018 chandransh 5645 
    self._processMap["getItemWiseRiskyOrdersCount"] = Processor.process_getItemWiseRiskyOrdersCount
4295 varun.gupt 5646 
    self._processMap["getOrdersForItemIds"] = Processor.process_getOrdersForItemIds
4247 rajveer 5647 
    self._processMap["markOrderCancellationRequestReceived"] = Processor.process_markOrderCancellationRequestReceived
5648 
    self._processMap["markOrderCancellationRequestConfirmed"] = Processor.process_markOrderCancellationRequestConfirmed
5649 
    self._processMap["markOrderCancellationRequestDenied"] = Processor.process_markOrderCancellationRequestDenied
4258 rajveer 5650 
    self._processMap["markTransactionAsPaymentFlagRemoved"] = Processor.process_markTransactionAsPaymentFlagRemoved
4259 anupam.sin 5651 
    self._processMap["refundTransaction"] = Processor.process_refundTransaction
4324 mandeep.dh 5652 
    self._processMap["updateShipmentAddress"] = Processor.process_updateShipmentAddress
4285 rajveer 5653 
    self._processMap["acceptOrdersForItemId"] = Processor.process_acceptOrdersForItemId
4303 rajveer 5654 
    self._processMap["markOrdersAsPORaised"] = Processor.process_markOrdersAsPORaised
5655 
    self._processMap["markOrdersAsReversalInitiated"] = Processor.process_markOrdersAsReversalInitiated
5656 
    self._processMap["markOrdersAsNotAvailabke"] = Processor.process_markOrdersAsNotAvailabke
4369 rajveer 5657 
    self._processMap["markOrdersAsTimeout"] = Processor.process_markOrdersAsTimeout
4662 rajveer 5658 
    self._processMap["markOrderAsLostInTransit"] = Processor.process_markOrderAsLostInTransit
4386 anupam.sin 5659 
    self._processMap["getOrderForAwb"] = Processor.process_getOrderForAwb
4506 phani.kuma 5660 
    self._processMap["getOrdersForProviderForStatus"] = Processor.process_getOrdersForProviderForStatus
4600 varun.gupt 5661 
    self._processMap["getBilledOrdersForVendor"] = Processor.process_getBilledOrdersForVendor
4607 rajveer 5662 
    self._processMap["getSlippedSippingDateOrders"] = Processor.process_getSlippedSippingDateOrders
4709 rajveer 5663 
    self._processMap["getCancelledOrders"] = Processor.process_getCancelledOrders
4600 varun.gupt 5664 
    self._processMap["saveBluedartSettlements"] = Processor.process_saveBluedartSettlements
5665 
    self._processMap["savePaymentSettlements"] = Processor.process_savePaymentSettlements
5666 
    self._processMap["saveEBSSettlementSummary"] = Processor.process_saveEBSSettlementSummary
5386 phani.kuma 5667 
    self._processMap["getSettlementForPrepaid"] = Processor.process_getSettlementForPrepaid
5668 
    self._processMap["getSettlementForCod"] = Processor.process_getSettlementForCod
4600 varun.gupt 5669 
    self._processMap["getEBSSettlementSummaries"] = Processor.process_getEBSSettlementSummaries
5670 
    self._processMap["markEBSSettlementUploaded"] = Processor.process_markEBSSettlementUploaded
5671 
    self._processMap["getEBSSettlementDate"] = Processor.process_getEBSSettlementDate
4715 varun.gupt 5672 
    self._processMap["getSettlementsByDate"] = Processor.process_getSettlementsByDate
5673 
    self._processMap["getReshippedOrderIds"] = Processor.process_getReshippedOrderIds
5481 phani.kuma 5674 
    self._processMap["getBilledOrders"] = Processor.process_getBilledOrders
5031 varun.gupt 5675 
    self._processMap["getStatusDistributionOfOrders"] = Processor.process_getStatusDistributionOfOrders
5067 varun.gupt 5676 
    self._processMap["getOrderIdsForStatus"] = Processor.process_getOrderIdsForStatus
5348 anupam.sin 5677 
    self._processMap["updateCODAgent"] = Processor.process_updateCODAgent
5099 varun.gupt 5678 
    self._processMap["updateOrderAsPaidToVendor"] = Processor.process_updateOrderAsPaidToVendor
5386 phani.kuma 5679 
    self._processMap["updateOrderOnlyAsPaidToVendor"] = Processor.process_updateOrderOnlyAsPaidToVendor
5208 varun.gupt 5680 
    self._processMap["getRefundedOrdersMarkedPaid"] = Processor.process_getRefundedOrdersMarkedPaid
5447 anupam.sin 5681 
    self._processMap["getAllVerificationAgents"] = Processor.process_getAllVerificationAgents
5527 anupam.sin 5682 
    self._processMap["getAllAttributesForOrderId"] = Processor.process_getAllAttributesForOrderId
5676 rajveer 5683 
    self._processMap["setOrderAttributes"] = Processor.process_setOrderAttributes
5527 anupam.sin 5684 
    self._processMap["setOrderAttributeForTransaction"] = Processor.process_setOrderAttributeForTransaction
5553 rajveer 5685 
    self._processMap["getReceivePendingOrders"] = Processor.process_getReceivePendingOrders
5686 
    self._processMap["getReceivedAtStoreOrders"] = Processor.process_getReceivedAtStoreOrders
5593 mandeep.dh 5687 
    self._processMap["acceptOrderForItem"] = Processor.process_acceptOrderForItem
94 ashish 5688 
 
5689 
  def process(self, iprot, oprot):
5690 
    (name, type, seqid) = iprot.readMessageBegin()
5691 
    if name not in self._processMap:
5692 
      iprot.skip(TType.STRUCT)
5693 
      iprot.readMessageEnd()
5694 
      x = TApplicationException(TApplicationException.UNKNOWN_METHOD, 'Unknown function %s' % (name))
5695 
      oprot.writeMessageBegin(name, TMessageType.EXCEPTION, seqid)
5696 
      x.write(oprot)
5697 
      oprot.writeMessageEnd()
5698 
      oprot.trans.flush()
5699 
      return
5700 
    else:
5701 
      self._processMap[name](self, seqid, iprot, oprot)
5702 
    return True
5703 
 
5704 
  def process_createTransaction(self, seqid, iprot, oprot):
5705 
    args = createTransaction_args()
5706 
    args.read(iprot)
5707 
    iprot.readMessageEnd()
5708 
    result = createTransaction_result()
5709 
    try:
132 ashish 5710 
      result.success = self._handler.createTransaction(args.transaction)
94 ashish 5711 
    except TransactionServiceException, ex:
5712 
      result.ex = ex
5713 
    oprot.writeMessageBegin("createTransaction", TMessageType.REPLY, seqid)
5714 
    result.write(oprot)
5715 
    oprot.writeMessageEnd()
5716 
    oprot.trans.flush()
5717 
 
5718 
  def process_getTransaction(self, seqid, iprot, oprot):
5719 
    args = getTransaction_args()
5720 
    args.read(iprot)
5721 
    iprot.readMessageEnd()
5722 
    result = getTransaction_result()
5723 
    try:
5724 
      result.success = self._handler.getTransaction(args.id)
5725 
    except TransactionServiceException, ex:
5726 
      result.ex = ex
5727 
    oprot.writeMessageBegin("getTransaction", TMessageType.REPLY, seqid)
5728 
    result.write(oprot)
5729 
    oprot.writeMessageEnd()
5730 
    oprot.trans.flush()
5731 
 
5732 
  def process_getTransactionsForCustomer(self, seqid, iprot, oprot):
5733 
    args = getTransactionsForCustomer_args()
5734 
    args.read(iprot)
5735 
    iprot.readMessageEnd()
5736 
    result = getTransactionsForCustomer_result()
5737 
    try:
5738 
      result.success = self._handler.getTransactionsForCustomer(args.customerId, args.from_date, args.to_date, args.status)
5739 
    except TransactionServiceException, ex:
5740 
      result.ex = ex
5741 
    oprot.writeMessageBegin("getTransactionsForCustomer", TMessageType.REPLY, seqid)
5742 
    result.write(oprot)
5743 
    oprot.writeMessageEnd()
5744 
    oprot.trans.flush()
5745 
 
132 ashish 5746 
  def process_getTransactionsForShoppingCartId(self, seqid, iprot, oprot):
5747 
    args = getTransactionsForShoppingCartId_args()
5748 
    args.read(iprot)
5749 
    iprot.readMessageEnd()
5750 
    result = getTransactionsForShoppingCartId_result()
5751 
    try:
5752 
      result.success = self._handler.getTransactionsForShoppingCartId(args.shoppingCartId)
5753 
    except TransactionServiceException, ex:
5754 
      result.ex = ex
5755 
    oprot.writeMessageBegin("getTransactionsForShoppingCartId", TMessageType.REPLY, seqid)
5756 
    result.write(oprot)
5757 
    oprot.writeMessageEnd()
5758 
    oprot.trans.flush()
5759 
 
94 ashish 5760 
  def process_getTransactionStatus(self, seqid, iprot, oprot):
5761 
    args = getTransactionStatus_args()
5762 
    args.read(iprot)
5763 
    iprot.readMessageEnd()
5764 
    result = getTransactionStatus_result()
5765 
    try:
5766 
      result.success = self._handler.getTransactionStatus(args.transactionId)
5767 
    except TransactionServiceException, ex:
5768 
      result.ex = ex
5769 
    oprot.writeMessageBegin("getTransactionStatus", TMessageType.REPLY, seqid)
5770 
    result.write(oprot)
5771 
    oprot.writeMessageEnd()
5772 
    oprot.trans.flush()
5773 
 
5774 
  def process_changeTransactionStatus(self, seqid, iprot, oprot):
5775 
    args = changeTransactionStatus_args()
5776 
    args.read(iprot)
5777 
    iprot.readMessageEnd()
5778 
    result = changeTransactionStatus_result()
5779 
    try:
5527 anupam.sin 5780 
      result.success = self._handler.changeTransactionStatus(args.transactionId, args.status, args.description, args.pickUp, args.orderType)
94 ashish 5781 
    except TransactionServiceException, ex:
5782 
      result.ex = ex
5783 
    oprot.writeMessageBegin("changeTransactionStatus", TMessageType.REPLY, seqid)
5784 
    result.write(oprot)
5785 
    oprot.writeMessageEnd()
5786 
    oprot.trans.flush()
5787 
 
1398 varun.gupt 5788 
  def process_enqueueTransactionInfoEmail(self, seqid, iprot, oprot):
5789 
    args = enqueueTransactionInfoEmail_args()
1382 varun.gupt 5790 
    args.read(iprot)
5791 
    iprot.readMessageEnd()
1398 varun.gupt 5792 
    result = enqueueTransactionInfoEmail_result()
1382 varun.gupt 5793 
    try:
1398 varun.gupt 5794 
      result.success = self._handler.enqueueTransactionInfoEmail(args.transactionId)
1382 varun.gupt 5795 
    except TransactionServiceException, ex:
5796 
      result.ex = ex
1398 varun.gupt 5797 
    oprot.writeMessageBegin("enqueueTransactionInfoEmail", TMessageType.REPLY, seqid)
1382 varun.gupt 5798 
    result.write(oprot)
5799 
    oprot.writeMessageEnd()
5800 
    oprot.trans.flush()
5801 
 
483 rajveer 5802 
  def process_getAllOrders(self, seqid, iprot, oprot):
5803 
    args = getAllOrders_args()
94 ashish 5804 
    args.read(iprot)
5805 
    iprot.readMessageEnd()
483 rajveer 5806 
    result = getAllOrders_result()
94 ashish 5807 
    try:
4801 anupam.sin 5808 
      result.success = self._handler.getAllOrders(args.statuses, args.from_date, args.to_date, args.warehouse_id)
94 ashish 5809 
    except TransactionServiceException, ex:
5810 
      result.ex = ex
483 rajveer 5811 
    oprot.writeMessageBegin("getAllOrders", TMessageType.REPLY, seqid)
94 ashish 5812 
    result.write(oprot)
5813 
    oprot.writeMessageEnd()
5814 
    oprot.trans.flush()
5815 
 
4133 chandransh 5816 
  def process_getOrdersInBatch(self, seqid, iprot, oprot):
5817 
    args = getOrdersInBatch_args()
5818 
    args.read(iprot)
5819 
    iprot.readMessageEnd()
5820 
    result = getOrdersInBatch_result()
5821 
    try:
5822 
      result.success = self._handler.getOrdersInBatch(args.statuses, args.offset, args.limit, args.warehouse_id)
5823 
    except TransactionServiceException, ex:
5824 
      result.ex = ex
5825 
    oprot.writeMessageBegin("getOrdersInBatch", TMessageType.REPLY, seqid)
5826 
    result.write(oprot)
5827 
    oprot.writeMessageEnd()
5828 
    oprot.trans.flush()
5829 
 
5830 
  def process_getOrderCount(self, seqid, iprot, oprot):
5831 
    args = getOrderCount_args()
5832 
    args.read(iprot)
5833 
    iprot.readMessageEnd()
5834 
    result = getOrderCount_result()
5835 
    try:
5836 
      result.success = self._handler.getOrderCount(args.statuses, args.warehouseId)
5837 
    except TransactionServiceException, ex:
5838 
      result.ex = ex
5839 
    oprot.writeMessageBegin("getOrderCount", TMessageType.REPLY, seqid)
5840 
    result.write(oprot)
5841 
    oprot.writeMessageEnd()
5842 
    oprot.trans.flush()
5843 
 
999 varun.gupt 5844 
  def process_getOrdersByBillingDate(self, seqid, iprot, oprot):
5845 
    args = getOrdersByBillingDate_args()
5846 
    args.read(iprot)
5847 
    iprot.readMessageEnd()
5848 
    result = getOrdersByBillingDate_result()
5849 
    try:
5850 
      result.success = self._handler.getOrdersByBillingDate(args.status, args.start_billing_date, args.end_billing_date, args.warehouse_id)
5851 
    except TransactionServiceException, ex:
5852 
      result.ex = ex
5853 
    oprot.writeMessageBegin("getOrdersByBillingDate", TMessageType.REPLY, seqid)
5854 
    result.write(oprot)
5855 
    oprot.writeMessageEnd()
5856 
    oprot.trans.flush()
5857 
 
3427 chandransh 5858 
  def process_getOrdersByShippingDate(self, seqid, iprot, oprot):
5859 
    args = getOrdersByShippingDate_args()
5860 
    args.read(iprot)
5861 
    iprot.readMessageEnd()
5862 
    result = getOrdersByShippingDate_result()
5863 
    try:
3451 chandransh 5864 
      result.success = self._handler.getOrdersByShippingDate(args.fromShippingDate, args.toShippingDate, args.providerId, args.warehouseId, args.cod)
3427 chandransh 5865 
    except TransactionServiceException, ex:
5866 
      result.ex = ex
5867 
    oprot.writeMessageBegin("getOrdersByShippingDate", TMessageType.REPLY, seqid)
5868 
    result.write(oprot)
5869 
    oprot.writeMessageEnd()
5870 
    oprot.trans.flush()
5871 
 
1382 varun.gupt 5872 
  def process_getReturnableOrdersForCustomer(self, seqid, iprot, oprot):
5873 
    args = getReturnableOrdersForCustomer_args()
5874 
    args.read(iprot)
5875 
    iprot.readMessageEnd()
5876 
    result = getReturnableOrdersForCustomer_result()
5877 
    try:
5878 
      result.success = self._handler.getReturnableOrdersForCustomer(args.customer_id, args.limit)
5879 
    except TransactionServiceException, ex:
5880 
      result.ex = ex
5881 
    oprot.writeMessageBegin("getReturnableOrdersForCustomer", TMessageType.REPLY, seqid)
5882 
    result.write(oprot)
5883 
    oprot.writeMessageEnd()
5884 
    oprot.trans.flush()
5885 
 
5886 
  def process_getCancellableOrdersForCustomer(self, seqid, iprot, oprot):
5887 
    args = getCancellableOrdersForCustomer_args()
5888 
    args.read(iprot)
5889 
    iprot.readMessageEnd()
5890 
    result = getCancellableOrdersForCustomer_result()
5891 
    try:
5892 
      result.success = self._handler.getCancellableOrdersForCustomer(args.customer_id, args.limit)
5893 
    except TransactionServiceException, ex:
5894 
      result.ex = ex
5895 
    oprot.writeMessageBegin("getCancellableOrdersForCustomer", TMessageType.REPLY, seqid)
5896 
    result.write(oprot)
5897 
    oprot.writeMessageEnd()
5898 
    oprot.trans.flush()
5899 
 
483 rajveer 5900 
  def process_changeOrderStatus(self, seqid, iprot, oprot):
5901 
    args = changeOrderStatus_args()
94 ashish 5902 
    args.read(iprot)
5903 
    iprot.readMessageEnd()
483 rajveer 5904 
    result = changeOrderStatus_result()
94 ashish 5905 
    try:
483 rajveer 5906 
      result.success = self._handler.changeOrderStatus(args.orderId, args.status, args.description)
94 ashish 5907 
    except TransactionServiceException, ex:
5908 
      result.ex = ex
483 rajveer 5909 
    oprot.writeMessageBegin("changeOrderStatus", TMessageType.REPLY, seqid)
94 ashish 5910 
    result.write(oprot)
5911 
    oprot.writeMessageEnd()
5912 
    oprot.trans.flush()
5913 
 
483 rajveer 5914 
  def process_getOrdersForTransaction(self, seqid, iprot, oprot):
5915 
    args = getOrdersForTransaction_args()
94 ashish 5916 
    args.read(iprot)
5917 
    iprot.readMessageEnd()
483 rajveer 5918 
    result = getOrdersForTransaction_result()
94 ashish 5919 
    try:
1528 ankur.sing 5920 
      result.success = self._handler.getOrdersForTransaction(args.transactionId, args.customerId)
94 ashish 5921 
    except TransactionServiceException, ex:
5922 
      result.ex = ex
483 rajveer 5923 
    oprot.writeMessageBegin("getOrdersForTransaction", TMessageType.REPLY, seqid)
94 ashish 5924 
    result.write(oprot)
5925 
    oprot.writeMessageEnd()
5926 
    oprot.trans.flush()
5927 
 
483 rajveer 5928 
  def process_getOrdersForCustomer(self, seqid, iprot, oprot):
5929 
    args = getOrdersForCustomer_args()
94 ashish 5930 
    args.read(iprot)
5931 
    iprot.readMessageEnd()
483 rajveer 5932 
    result = getOrdersForCustomer_result()
94 ashish 5933 
    try:
3014 chandransh 5934 
      result.success = self._handler.getOrdersForCustomer(args.customerId, args.from_date, args.to_date, args.statuses)
94 ashish 5935 
    except TransactionServiceException, ex:
5936 
      result.ex = ex
483 rajveer 5937 
    oprot.writeMessageBegin("getOrdersForCustomer", TMessageType.REPLY, seqid)
94 ashish 5938 
    result.write(oprot)
5939 
    oprot.writeMessageEnd()
5940 
    oprot.trans.flush()
5941 
 
483 rajveer 5942 
  def process_createOrder(self, seqid, iprot, oprot):
5943 
    args = createOrder_args()
94 ashish 5944 
    args.read(iprot)
5945 
    iprot.readMessageEnd()
483 rajveer 5946 
    result = createOrder_result()
94 ashish 5947 
    try:
483 rajveer 5948 
      result.success = self._handler.createOrder(args.order)
94 ashish 5949 
    except TransactionServiceException, ex:
5950 
      result.ex = ex
483 rajveer 5951 
    oprot.writeMessageBegin("createOrder", TMessageType.REPLY, seqid)
94 ashish 5952 
    result.write(oprot)
5953 
    oprot.writeMessageEnd()
5954 
    oprot.trans.flush()
5955 
 
483 rajveer 5956 
  def process_getOrder(self, seqid, iprot, oprot):
5957 
    args = getOrder_args()
94 ashish 5958 
    args.read(iprot)
5959 
    iprot.readMessageEnd()
483 rajveer 5960 
    result = getOrder_result()
94 ashish 5961 
    try:
483 rajveer 5962 
      result.success = self._handler.getOrder(args.id)
94 ashish 5963 
    except TransactionServiceException, ex:
5964 
      result.ex = ex
483 rajveer 5965 
    oprot.writeMessageBegin("getOrder", TMessageType.REPLY, seqid)
94 ashish 5966 
    result.write(oprot)
5967 
    oprot.writeMessageEnd()
5968 
    oprot.trans.flush()
5969 
 
483 rajveer 5970 
  def process_getLineItemsForOrder(self, seqid, iprot, oprot):
5971 
    args = getLineItemsForOrder_args()
94 ashish 5972 
    args.read(iprot)
5973 
    iprot.readMessageEnd()
483 rajveer 5974 
    result = getLineItemsForOrder_result()
94 ashish 5975 
    try:
483 rajveer 5976 
      result.success = self._handler.getLineItemsForOrder(args.orderId)
94 ashish 5977 
    except TransactionServiceException, ex:
5978 
      result.ex = ex
483 rajveer 5979 
    oprot.writeMessageBegin("getLineItemsForOrder", TMessageType.REPLY, seqid)
94 ashish 5980 
    result.write(oprot)
5981 
    oprot.writeMessageEnd()
5982 
    oprot.trans.flush()
5983 
 
4999 phani.kuma 5984 
  def process_getOrderList(self, seqid, iprot, oprot):
5985 
    args = getOrderList_args()
5986 
    args.read(iprot)
5987 
    iprot.readMessageEnd()
5988 
    result = getOrderList_result()
5989 
    result.success = self._handler.getOrderList(args.order_ids)
5990 
    oprot.writeMessageBegin("getOrderList", TMessageType.REPLY, seqid)
5991 
    result.write(oprot)
5992 
    oprot.writeMessageEnd()
5993 
    oprot.trans.flush()
5994 
 
5386 phani.kuma 5995 
  def process_getOrderListForVendor(self, seqid, iprot, oprot):
5996 
    args = getOrderListForVendor_args()
5997 
    args.read(iprot)
5998 
    iprot.readMessageEnd()
5999 
    result = getOrderListForVendor_result()
6000 
    result.success = self._handler.getOrderListForVendor(args.order_ids, args.vendorId)
6001 
    oprot.writeMessageBegin("getOrderListForVendor", TMessageType.REPLY, seqid)
6002 
    result.write(oprot)
6003 
    oprot.writeMessageEnd()
6004 
    oprot.trans.flush()
6005 
 
1528 ankur.sing 6006 
  def process_getOrderForCustomer(self, seqid, iprot, oprot):
6007 
    args = getOrderForCustomer_args()
6008 
    args.read(iprot)
6009 
    iprot.readMessageEnd()
6010 
    result = getOrderForCustomer_result()
6011 
    try:
6012 
      result.success = self._handler.getOrderForCustomer(args.orderId, args.customerId)
6013 
    except TransactionServiceException, ex:
6014 
      result.ex = ex
6015 
    oprot.writeMessageBegin("getOrderForCustomer", TMessageType.REPLY, seqid)
6016 
    result.write(oprot)
6017 
    oprot.writeMessageEnd()
6018 
    oprot.trans.flush()
6019 
 
3064 chandransh 6020 
  def process_getAlerts(self, seqid, iprot, oprot):
6021 
    args = getAlerts_args()
6022 
    args.read(iprot)
6023 
    iprot.readMessageEnd()
6024 
    result = getAlerts_result()
4444 rajveer 6025 
    result.success = self._handler.getAlerts(args.type, args.warehouseId, args.status, args.timestamp)
3064 chandransh 6026 
    oprot.writeMessageBegin("getAlerts", TMessageType.REPLY, seqid)
6027 
    result.write(oprot)
6028 
    oprot.writeMessageEnd()
6029 
    oprot.trans.flush()
6030 
 
4394 rajveer 6031 
  def process_addAlert(self, seqid, iprot, oprot):
6032 
    args = addAlert_args()
3064 chandransh 6033 
    args.read(iprot)
6034 
    iprot.readMessageEnd()
4394 rajveer 6035 
    result = addAlert_result()
4444 rajveer 6036 
    self._handler.addAlert(args.type, args.warehouseId, args.description)
4394 rajveer 6037 
    oprot.writeMessageBegin("addAlert", TMessageType.REPLY, seqid)
3064 chandransh 6038 
    result.write(oprot)
6039 
    oprot.writeMessageEnd()
6040 
    oprot.trans.flush()
6041 
 
4444 rajveer 6042 
  def process_markAlertsAsSeen(self, seqid, iprot, oprot):
6043 
    args = markAlertsAsSeen_args()
6044 
    args.read(iprot)
6045 
    iprot.readMessageEnd()
6046 
    result = markAlertsAsSeen_result()
6047 
    self._handler.markAlertsAsSeen(args.warehouseId)
6048 
    oprot.writeMessageBegin("markAlertsAsSeen", TMessageType.REPLY, seqid)
6049 
    result.write(oprot)
6050 
    oprot.writeMessageEnd()
6051 
    oprot.trans.flush()
6052 
 
3064 chandransh 6053 
  def process_getValidOrderCount(self, seqid, iprot, oprot):
6054 
    args = getValidOrderCount_args()
6055 
    args.read(iprot)
6056 
    iprot.readMessageEnd()
6057 
    result = getValidOrderCount_result()
6058 
    result.success = self._handler.getValidOrderCount()
6059 
    oprot.writeMessageBegin("getValidOrderCount", TMessageType.REPLY, seqid)
6060 
    result.write(oprot)
6061 
    oprot.writeMessageEnd()
6062 
    oprot.trans.flush()
6063 
 
6064 
  def process_getNoOfCustomersWithSuccessfulTransaction(self, seqid, iprot, oprot):
6065 
    args = getNoOfCustomersWithSuccessfulTransaction_args()
6066 
    args.read(iprot)
6067 
    iprot.readMessageEnd()
6068 
    result = getNoOfCustomersWithSuccessfulTransaction_result()
6069 
    result.success = self._handler.getNoOfCustomersWithSuccessfulTransaction()
6070 
    oprot.writeMessageBegin("getNoOfCustomersWithSuccessfulTransaction", TMessageType.REPLY, seqid)
6071 
    result.write(oprot)
6072 
    oprot.writeMessageEnd()
6073 
    oprot.trans.flush()
6074 
 
6075 
  def process_getValidOrdersAmountRange(self, seqid, iprot, oprot):
6076 
    args = getValidOrdersAmountRange_args()
6077 
    args.read(iprot)
6078 
    iprot.readMessageEnd()
6079 
    result = getValidOrdersAmountRange_result()
6080 
    result.success = self._handler.getValidOrdersAmountRange()
6081 
    oprot.writeMessageBegin("getValidOrdersAmountRange", TMessageType.REPLY, seqid)
6082 
    result.write(oprot)
6083 
    oprot.writeMessageEnd()
6084 
    oprot.trans.flush()
6085 
 
6086 
  def process_getValidOrders(self, seqid, iprot, oprot):
6087 
    args = getValidOrders_args()
6088 
    args.read(iprot)
6089 
    iprot.readMessageEnd()
6090 
    result = getValidOrders_result()
6091 
    result.success = self._handler.getValidOrders(args.limit)
6092 
    oprot.writeMessageBegin("getValidOrders", TMessageType.REPLY, seqid)
6093 
    result.write(oprot)
6094 
    oprot.writeMessageEnd()
6095 
    oprot.trans.flush()
6096 
 
1220 chandransh 6097 
  def process_batchOrders(self, seqid, iprot, oprot):
6098 
    args = batchOrders_args()
6099 
    args.read(iprot)
6100 
    iprot.readMessageEnd()
6101 
    result = batchOrders_result()
6102 
    try:
6103 
      result.success = self._handler.batchOrders(args.warehouseId)
6104 
    except TransactionServiceException, ex:
6105 
      result.ex = ex
6106 
    oprot.writeMessageBegin("batchOrders", TMessageType.REPLY, seqid)
6107 
    result.write(oprot)
6108 
    oprot.writeMessageEnd()
6109 
    oprot.trans.flush()
6110 
 
1208 chandransh 6111 
  def process_markOrderAsOutOfStock(self, seqid, iprot, oprot):
6112 
    args = markOrderAsOutOfStock_args()
6113 
    args.read(iprot)
6114 
    iprot.readMessageEnd()
6115 
    result = markOrderAsOutOfStock_result()
6116 
    try:
6117 
      result.success = self._handler.markOrderAsOutOfStock(args.orderId)
6118 
    except TransactionServiceException, ex:
6119 
      result.ex = ex
6120 
    oprot.writeMessageBegin("markOrderAsOutOfStock", TMessageType.REPLY, seqid)
6121 
    result.write(oprot)
6122 
    oprot.writeMessageEnd()
6123 
    oprot.trans.flush()
6124 
 
3064 chandransh 6125 
  def process_verifyOrder(self, seqid, iprot, oprot):
6126 
    args = verifyOrder_args()
759 chandransh 6127 
    args.read(iprot)
6128 
    iprot.readMessageEnd()
3064 chandransh 6129 
    result = verifyOrder_result()
759 chandransh 6130 
    try:
3064 chandransh 6131 
      result.success = self._handler.verifyOrder(args.orderId)
759 chandransh 6132 
    except TransactionServiceException, ex:
6133 
      result.ex = ex
3064 chandransh 6134 
    oprot.writeMessageBegin("verifyOrder", TMessageType.REPLY, seqid)
759 chandransh 6135 
    result.write(oprot)
6136 
    oprot.writeMessageEnd()
6137 
    oprot.trans.flush()
6138 
 
3064 chandransh 6139 
  def process_acceptOrder(self, seqid, iprot, oprot):
6140 
    args = acceptOrder_args()
1113 chandransh 6141 
    args.read(iprot)
6142 
    iprot.readMessageEnd()
3064 chandransh 6143 
    result = acceptOrder_result()
1113 chandransh 6144 
    try:
3064 chandransh 6145 
      result.success = self._handler.acceptOrder(args.orderId)
1113 chandransh 6146 
    except TransactionServiceException, ex:
6147 
      result.ex = ex
3064 chandransh 6148 
    oprot.writeMessageBegin("acceptOrder", TMessageType.REPLY, seqid)
1113 chandransh 6149 
    result.write(oprot)
6150 
    oprot.writeMessageEnd()
6151 
    oprot.trans.flush()
6152 
 
3064 chandransh 6153 
  def process_addBillingDetails(self, seqid, iprot, oprot):
6154 
    args = addBillingDetails_args()
1135 chandransh 6155 
    args.read(iprot)
6156 
    iprot.readMessageEnd()
3064 chandransh 6157 
    result = addBillingDetails_result()
1135 chandransh 6158 
    try:
5110 mandeep.dh 6159 
      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 6160 
    except TransactionServiceException, ex:
6161 
      result.ex = ex
3064 chandransh 6162 
    oprot.writeMessageBegin("addBillingDetails", TMessageType.REPLY, seqid)
1135 chandransh 6163 
    result.write(oprot)
6164 
    oprot.writeMessageEnd()
6165 
    oprot.trans.flush()
6166 
 
4579 rajveer 6167 
  def process_addInvoiceNumber(self, seqid, iprot, oprot):
6168 
    args = addInvoiceNumber_args()
6169 
    args.read(iprot)
6170 
    iprot.readMessageEnd()
6171 
    result = addInvoiceNumber_result()
6172 
    try:
4763 rajveer 6173 
      self._handler.addInvoiceNumber(args.orderId, args.invoiceNumber, args.color)
4579 rajveer 6174 
    except TransactionServiceException, ex:
6175 
      result.ex = ex
6176 
    oprot.writeMessageBegin("addInvoiceNumber", TMessageType.REPLY, seqid)
6177 
    result.write(oprot)
6178 
    oprot.writeMessageEnd()
6179 
    oprot.trans.flush()
6180 
 
4410 rajveer 6181 
  def process_markOrdersAsShippedFromWarehouse(self, seqid, iprot, oprot):
6182 
    args = markOrdersAsShippedFromWarehouse_args()
6183 
    args.read(iprot)
6184 
    iprot.readMessageEnd()
6185 
    result = markOrdersAsShippedFromWarehouse_result()
6186 
    try:
4789 rajveer 6187 
      result.success = self._handler.markOrdersAsShippedFromWarehouse(args.warehouseId, args.providerId, args.cod, args.orderIds)
4410 rajveer 6188 
    except TransactionServiceException, ex:
6189 
      result.ex = ex
6190 
    oprot.writeMessageBegin("markOrdersAsShippedFromWarehouse", TMessageType.REPLY, seqid)
6191 
    result.write(oprot)
6192 
    oprot.writeMessageEnd()
6193 
    oprot.trans.flush()
6194 
 
5676 rajveer 6195 
  def process_markOrdersAsReturnedFromStore(self, seqid, iprot, oprot):
6196 
    args = markOrdersAsReturnedFromStore_args()
6197 
    args.read(iprot)
6198 
    iprot.readMessageEnd()
6199 
    result = markOrdersAsReturnedFromStore_result()
6200 
    try:
6201 
      result.success = self._handler.markOrdersAsReturnedFromStore(args.providerId, args.orderIds)
6202 
    except TransactionServiceException, ex:
6203 
      result.ex = ex
6204 
    oprot.writeMessageBegin("markOrdersAsReturnedFromStore", TMessageType.REPLY, seqid)
6205 
    result.write(oprot)
6206 
    oprot.writeMessageEnd()
6207 
    oprot.trans.flush()
6208 
 
3064 chandransh 6209 
  def process_markOrdersAsPickedUp(self, seqid, iprot, oprot):
6210 
    args = markOrdersAsPickedUp_args()
304 ashish 6211 
    args.read(iprot)
6212 
    iprot.readMessageEnd()
3064 chandransh 6213 
    result = markOrdersAsPickedUp_result()
6214 
    try:
4910 phani.kuma 6215 
      self._handler.markOrdersAsPickedUp(args.providerId, args.pickupDetails)
3064 chandransh 6216 
    except TransactionServiceException, ex:
6217 
      result.ex = ex
6218 
    oprot.writeMessageBegin("markOrdersAsPickedUp", TMessageType.REPLY, seqid)
304 ashish 6219 
    result.write(oprot)
6220 
    oprot.writeMessageEnd()
6221 
    oprot.trans.flush()
94 ashish 6222 
 
4910 phani.kuma 6223 
  def process_getOrdersNotPickedUp(self, seqid, iprot, oprot):
6224 
    args = getOrdersNotPickedUp_args()
6225 
    args.read(iprot)
6226 
    iprot.readMessageEnd()
6227 
    result = getOrdersNotPickedUp_result()
6228 
    result.success = self._handler.getOrdersNotPickedUp(args.providerId)
6229 
    oprot.writeMessageBegin("getOrdersNotPickedUp", TMessageType.REPLY, seqid)
6230 
    result.write(oprot)
6231 
    oprot.writeMessageEnd()
6232 
    oprot.trans.flush()
6233 
 
3064 chandransh 6234 
  def process_markOrdersAsDelivered(self, seqid, iprot, oprot):
6235 
    args = markOrdersAsDelivered_args()
304 ashish 6236 
    args.read(iprot)
6237 
    iprot.readMessageEnd()
3064 chandransh 6238 
    result = markOrdersAsDelivered_result()
6239 
    try:
6240 
      self._handler.markOrdersAsDelivered(args.providerId, args.deliveredOrders)
6241 
    except TransactionServiceException, ex:
6242 
      result.ex = ex
6243 
    oprot.writeMessageBegin("markOrdersAsDelivered", TMessageType.REPLY, seqid)
304 ashish 6244 
    result.write(oprot)
6245 
    oprot.writeMessageEnd()
6246 
    oprot.trans.flush()
6247 
 
4910 phani.kuma 6248 
  def process_markAsRTOrders(self, seqid, iprot, oprot):
6249 
    args = markAsRTOrders_args()
1596 ankur.sing 6250 
    args.read(iprot)
6251 
    iprot.readMessageEnd()
4910 phani.kuma 6252 
    result = markAsRTOrders_result()
3064 chandransh 6253 
    try:
4910 phani.kuma 6254 
      self._handler.markAsRTOrders(args.providerId, args.returnedOrders)
3064 chandransh 6255 
    except TransactionServiceException, ex:
6256 
      result.ex = ex
4910 phani.kuma 6257 
    oprot.writeMessageBegin("markAsRTOrders", TMessageType.REPLY, seqid)
1596 ankur.sing 6258 
    result.write(oprot)
6259 
    oprot.writeMessageEnd()
6260 
    oprot.trans.flush()
304 ashish 6261 
 
4910 phani.kuma 6262 
  def process_getRTOrders(self, seqid, iprot, oprot):
6263 
    args = getRTOrders_args()
6264 
    args.read(iprot)
6265 
    iprot.readMessageEnd()
6266 
    result = getRTOrders_result()
6267 
    result.success = self._handler.getRTOrders(args.providerId)
6268 
    oprot.writeMessageBegin("getRTOrders", TMessageType.REPLY, seqid)
6269 
    result.write(oprot)
6270 
    oprot.writeMessageEnd()
6271 
    oprot.trans.flush()
6272 
 
3064 chandransh 6273 
  def process_updateNonDeliveryReason(self, seqid, iprot, oprot):
6274 
    args = updateNonDeliveryReason_args()
1627 ankur.sing 6275 
    args.read(iprot)
6276 
    iprot.readMessageEnd()
3064 chandransh 6277 
    result = updateNonDeliveryReason_result()
6278 
    try:
4910 phani.kuma 6279 
      self._handler.updateNonDeliveryReason(args.providerId, args.undeliveredOrders)
3064 chandransh 6280 
    except TransactionServiceException, ex:
6281 
      result.ex = ex
6282 
    oprot.writeMessageBegin("updateNonDeliveryReason", TMessageType.REPLY, seqid)
1627 ankur.sing 6283 
    result.write(oprot)
6284 
    oprot.writeMessageEnd()
6285 
    oprot.trans.flush()
1596 ankur.sing 6286 
 
4910 phani.kuma 6287 
  def process_getNonDeliveredOrdersbyCourier(self, seqid, iprot, oprot):
6288 
    args = getNonDeliveredOrdersbyCourier_args()
6289 
    args.read(iprot)
6290 
    iprot.readMessageEnd()
6291 
    result = getNonDeliveredOrdersbyCourier_result()
6292 
    result.success = self._handler.getNonDeliveredOrdersbyCourier(args.providerId)
6293 
    oprot.writeMessageBegin("getNonDeliveredOrdersbyCourier", TMessageType.REPLY, seqid)
6294 
    result.write(oprot)
6295 
    oprot.writeMessageEnd()
6296 
    oprot.trans.flush()
6297 
 
6298 
  def process_markOrdersAsLocalConnected(self, seqid, iprot, oprot):
6299 
    args = markOrdersAsLocalConnected_args()
6300 
    args.read(iprot)
6301 
    iprot.readMessageEnd()
6302 
    result = markOrdersAsLocalConnected_result()
6303 
    try:
6304 
      self._handler.markOrdersAsLocalConnected(args.providerId, args.local_connected_orders)
6305 
    except TransactionServiceException, ex:
6306 
      result.ex = ex
6307 
    oprot.writeMessageBegin("markOrdersAsLocalConnected", TMessageType.REPLY, seqid)
6308 
    result.write(oprot)
6309 
    oprot.writeMessageEnd()
6310 
    oprot.trans.flush()
6311 
 
6312 
  def process_getOrdersNotLocalConnected(self, seqid, iprot, oprot):
6313 
    args = getOrdersNotLocalConnected_args()
6314 
    args.read(iprot)
6315 
    iprot.readMessageEnd()
6316 
    result = getOrdersNotLocalConnected_result()
6317 
    result.success = self._handler.getOrdersNotLocalConnected(args.providerId)
6318 
    oprot.writeMessageBegin("getOrdersNotLocalConnected", TMessageType.REPLY, seqid)
6319 
    result.write(oprot)
6320 
    oprot.writeMessageEnd()
6321 
    oprot.trans.flush()
6322 
 
6323 
  def process_markOrdersAsDestinationCityReached(self, seqid, iprot, oprot):
6324 
    args = markOrdersAsDestinationCityReached_args()
6325 
    args.read(iprot)
6326 
    iprot.readMessageEnd()
6327 
    result = markOrdersAsDestinationCityReached_result()
6328 
    try:
6329 
      self._handler.markOrdersAsDestinationCityReached(args.providerId, args.destination_city_reached_orders)
6330 
    except TransactionServiceException, ex:
6331 
      result.ex = ex
6332 
    oprot.writeMessageBegin("markOrdersAsDestinationCityReached", TMessageType.REPLY, seqid)
6333 
    result.write(oprot)
6334 
    oprot.writeMessageEnd()
6335 
    oprot.trans.flush()
6336 
 
6337 
  def process_markOrdersAsFirstDeliveryAttempted(self, seqid, iprot, oprot):
6338 
    args = markOrdersAsFirstDeliveryAttempted_args()
6339 
    args.read(iprot)
6340 
    iprot.readMessageEnd()
6341 
    result = markOrdersAsFirstDeliveryAttempted_result()
6342 
    try:
6343 
      self._handler.markOrdersAsFirstDeliveryAttempted(args.providerId, args.first_atdl_orders)
6344 
    except TransactionServiceException, ex:
6345 
      result.ex = ex
6346 
    oprot.writeMessageBegin("markOrdersAsFirstDeliveryAttempted", TMessageType.REPLY, seqid)
6347 
    result.write(oprot)
6348 
    oprot.writeMessageEnd()
6349 
    oprot.trans.flush()
6350 
 
3064 chandransh 6351 
  def process_getUndeliveredOrders(self, seqid, iprot, oprot):
6352 
    args = getUndeliveredOrders_args()
1627 ankur.sing 6353 
    args.read(iprot)
6354 
    iprot.readMessageEnd()
3064 chandransh 6355 
    result = getUndeliveredOrders_result()
6356 
    result.success = self._handler.getUndeliveredOrders(args.providerId, args.warehouseId)
6357 
    oprot.writeMessageBegin("getUndeliveredOrders", TMessageType.REPLY, seqid)
1627 ankur.sing 6358 
    result.write(oprot)
6359 
    oprot.writeMessageEnd()
6360 
    oprot.trans.flush()
6361 
 
4783 phani.kuma 6362 
  def process_getUndeliveredOrdersExpectedDeliveryDateNotMet(self, seqid, iprot, oprot):
6363 
    args = getUndeliveredOrdersExpectedDeliveryDateNotMet_args()
6364 
    args.read(iprot)
6365 
    iprot.readMessageEnd()
6366 
    result = getUndeliveredOrdersExpectedDeliveryDateNotMet_result()
6367 
    result.success = self._handler.getUndeliveredOrdersExpectedDeliveryDateNotMet()
6368 
    oprot.writeMessageBegin("getUndeliveredOrdersExpectedDeliveryDateNotMet", TMessageType.REPLY, seqid)
6369 
    result.write(oprot)
6370 
    oprot.writeMessageEnd()
6371 
    oprot.trans.flush()
6372 
 
2536 chandransh 6373 
  def process_toggleDOAFlag(self, seqid, iprot, oprot):
6374 
    args = toggleDOAFlag_args()
6375 
    args.read(iprot)
6376 
    iprot.readMessageEnd()
6377 
    result = toggleDOAFlag_result()
6378 
    try:
6379 
      result.success = self._handler.toggleDOAFlag(args.orderId)
6380 
    except TransactionServiceException, ex:
6381 
      result.ex = ex
6382 
    oprot.writeMessageBegin("toggleDOAFlag", TMessageType.REPLY, seqid)
6383 
    result.write(oprot)
6384 
    oprot.writeMessageEnd()
6385 
    oprot.trans.flush()
1886 ankur.sing 6386 
 
4712 rajveer 6387 
  def process_markOrderAsDelivered(self, seqid, iprot, oprot):
6388 
    args = markOrderAsDelivered_args()
6389 
    args.read(iprot)
6390 
    iprot.readMessageEnd()
6391 
    result = markOrderAsDelivered_result()
6392 
    try:
6393 
      self._handler.markOrderAsDelivered(args.orderId, args.deliveryTimestamp, args.receiver)
6394 
    except TransactionServiceException, ex:
6395 
      result.ex = ex
6396 
    oprot.writeMessageBegin("markOrderAsDelivered", TMessageType.REPLY, seqid)
6397 
    result.write(oprot)
6398 
    oprot.writeMessageEnd()
6399 
    oprot.trans.flush()
6400 
 
5553 rajveer 6401 
  def process_markOrderAsReceivedAtStore(self, seqid, iprot, oprot):
6402 
    args = markOrderAsReceivedAtStore_args()
6403 
    args.read(iprot)
6404 
    iprot.readMessageEnd()
6405 
    result = markOrderAsReceivedAtStore_result()
6406 
    try:
6407 
      self._handler.markOrderAsReceivedAtStore(args.orderId, args.deliveryTimestamp)
6408 
    except TransactionServiceException, ex:
6409 
      result.ex = ex
6410 
    oprot.writeMessageBegin("markOrderAsReceivedAtStore", TMessageType.REPLY, seqid)
6411 
    result.write(oprot)
6412 
    oprot.writeMessageEnd()
6413 
    oprot.trans.flush()
6414 
 
4454 rajveer 6415 
  def process_markOrderDoaRequestReceived(self, seqid, iprot, oprot):
6416 
    args = markOrderDoaRequestReceived_args()
6417 
    args.read(iprot)
6418 
    iprot.readMessageEnd()
6419 
    result = markOrderDoaRequestReceived_result()
6420 
    try:
6421 
      result.success = self._handler.markOrderDoaRequestReceived(args.orderId)
6422 
    except TransactionServiceException, ex:
6423 
      result.ex = ex
6424 
    oprot.writeMessageBegin("markOrderDoaRequestReceived", TMessageType.REPLY, seqid)
6425 
    result.write(oprot)
6426 
    oprot.writeMessageEnd()
6427 
    oprot.trans.flush()
6428 
 
6429 
  def process_markOrderDoaRequestAuthorized(self, seqid, iprot, oprot):
6430 
    args = markOrderDoaRequestAuthorized_args()
6431 
    args.read(iprot)
6432 
    iprot.readMessageEnd()
6433 
    result = markOrderDoaRequestAuthorized_result()
6434 
    try:
6435 
      result.success = self._handler.markOrderDoaRequestAuthorized(args.orderId, args.isAuthorized)
6436 
    except TransactionServiceException, ex:
6437 
      result.ex = ex
6438 
    oprot.writeMessageBegin("markOrderDoaRequestAuthorized", TMessageType.REPLY, seqid)
6439 
    result.write(oprot)
6440 
    oprot.writeMessageEnd()
6441 
    oprot.trans.flush()
6442 
 
4488 rajveer 6443 
  def process_markOrderReturnRequestReceived(self, seqid, iprot, oprot):
6444 
    args = markOrderReturnRequestReceived_args()
6445 
    args.read(iprot)
6446 
    iprot.readMessageEnd()
6447 
    result = markOrderReturnRequestReceived_result()
6448 
    try:
6449 
      result.success = self._handler.markOrderReturnRequestReceived(args.orderId)
6450 
    except TransactionServiceException, ex:
6451 
      result.ex = ex
6452 
    oprot.writeMessageBegin("markOrderReturnRequestReceived", TMessageType.REPLY, seqid)
6453 
    result.write(oprot)
6454 
    oprot.writeMessageEnd()
6455 
    oprot.trans.flush()
6456 
 
6457 
  def process_markOrderReturnRequestAuthorized(self, seqid, iprot, oprot):
6458 
    args = markOrderReturnRequestAuthorized_args()
6459 
    args.read(iprot)
6460 
    iprot.readMessageEnd()
6461 
    result = markOrderReturnRequestAuthorized_result()
6462 
    try:
6463 
      result.success = self._handler.markOrderReturnRequestAuthorized(args.orderId, args.isAuthorized)
6464 
    except TransactionServiceException, ex:
6465 
      result.ex = ex
6466 
    oprot.writeMessageBegin("markOrderReturnRequestAuthorized", TMessageType.REPLY, seqid)
6467 
    result.write(oprot)
6468 
    oprot.writeMessageEnd()
6469 
    oprot.trans.flush()
6470 
 
2536 chandransh 6471 
  def process_requestPickupNumber(self, seqid, iprot, oprot):
6472 
    args = requestPickupNumber_args()
6473 
    args.read(iprot)
6474 
    iprot.readMessageEnd()
6475 
    result = requestPickupNumber_result()
6476 
    try:
4579 rajveer 6477 
      result.success = self._handler.requestPickupNumber(args.orderId, args.providerId)
2536 chandransh 6478 
    except TransactionServiceException, ex:
6479 
      result.ex = ex
6480 
    oprot.writeMessageBegin("requestPickupNumber", TMessageType.REPLY, seqid)
6481 
    result.write(oprot)
6482 
    oprot.writeMessageEnd()
6483 
    oprot.trans.flush()
6484 
 
6485 
  def process_authorizePickup(self, seqid, iprot, oprot):
6486 
    args = authorizePickup_args()
6487 
    args.read(iprot)
6488 
    iprot.readMessageEnd()
6489 
    result = authorizePickup_result()
6490 
    try:
4602 rajveer 6491 
      result.success = self._handler.authorizePickup(args.orderId, args.pickupNumber, args.providerId)
2536 chandransh 6492 
    except TransactionServiceException, ex:
6493 
      result.ex = ex
6494 
    oprot.writeMessageBegin("authorizePickup", TMessageType.REPLY, seqid)
6495 
    result.write(oprot)
6496 
    oprot.writeMessageEnd()
6497 
    oprot.trans.flush()
6498 
 
2764 chandransh 6499 
  def process_markDoasAsPickedUp(self, seqid, iprot, oprot):
6500 
    args = markDoasAsPickedUp_args()
6501 
    args.read(iprot)
6502 
    iprot.readMessageEnd()
6503 
    result = markDoasAsPickedUp_result()
4910 phani.kuma 6504 
    self._handler.markDoasAsPickedUp(args.providerId, args.pickupDetails)
2764 chandransh 6505 
    oprot.writeMessageBegin("markDoasAsPickedUp", TMessageType.REPLY, seqid)
6506 
    result.write(oprot)
6507 
    oprot.writeMessageEnd()
6508 
    oprot.trans.flush()
6509 
 
4910 phani.kuma 6510 
  def process_getDoasNotPickedUp(self, seqid, iprot, oprot):
6511 
    args = getDoasNotPickedUp_args()
6512 
    args.read(iprot)
6513 
    iprot.readMessageEnd()
6514 
    result = getDoasNotPickedUp_result()
6515 
    result.success = self._handler.getDoasNotPickedUp(args.providerId)
6516 
    oprot.writeMessageBegin("getDoasNotPickedUp", TMessageType.REPLY, seqid)
6517 
    result.write(oprot)
6518 
    oprot.writeMessageEnd()
6519 
    oprot.trans.flush()
6520 
 
4741 phani.kuma 6521 
  def process_markReturnOrdersAsPickedUp(self, seqid, iprot, oprot):
6522 
    args = markReturnOrdersAsPickedUp_args()
6523 
    args.read(iprot)
6524 
    iprot.readMessageEnd()
6525 
    result = markReturnOrdersAsPickedUp_result()
4910 phani.kuma 6526 
    self._handler.markReturnOrdersAsPickedUp(args.providerId, args.pickupDetails)
4741 phani.kuma 6527 
    oprot.writeMessageBegin("markReturnOrdersAsPickedUp", TMessageType.REPLY, seqid)
6528 
    result.write(oprot)
6529 
    oprot.writeMessageEnd()
6530 
    oprot.trans.flush()
6531 
 
4910 phani.kuma 6532 
  def process_getReturnOrdersNotPickedUp(self, seqid, iprot, oprot):
6533 
    args = getReturnOrdersNotPickedUp_args()
6534 
    args.read(iprot)
6535 
    iprot.readMessageEnd()
6536 
    result = getReturnOrdersNotPickedUp_result()
6537 
    result.success = self._handler.getReturnOrdersNotPickedUp(args.providerId)
6538 
    oprot.writeMessageBegin("getReturnOrdersNotPickedUp", TMessageType.REPLY, seqid)
6539 
    result.write(oprot)
6540 
    oprot.writeMessageEnd()
6541 
    oprot.trans.flush()
6542 
 
2616 chandransh 6543 
  def process_receiveReturn(self, seqid, iprot, oprot):
6544 
    args = receiveReturn_args()
2591 chandransh 6545 
    args.read(iprot)
6546 
    iprot.readMessageEnd()
2616 chandransh 6547 
    result = receiveReturn_result()
2591 chandransh 6548 
    try:
4479 rajveer 6549 
      result.success = self._handler.receiveReturn(args.orderId, args.receiveCondition)
2591 chandransh 6550 
    except TransactionServiceException, ex:
6551 
      result.ex = ex
2616 chandransh 6552 
    oprot.writeMessageBegin("receiveReturn", TMessageType.REPLY, seqid)
2591 chandransh 6553 
    result.write(oprot)
6554 
    oprot.writeMessageEnd()
6555 
    oprot.trans.flush()
2536 chandransh 6556 
 
2591 chandransh 6557 
  def process_validateDoa(self, seqid, iprot, oprot):
6558 
    args = validateDoa_args()
6559 
    args.read(iprot)
6560 
    iprot.readMessageEnd()
6561 
    result = validateDoa_result()
6562 
    try:
6563 
      result.success = self._handler.validateDoa(args.orderId, args.isValid)
6564 
    except TransactionServiceException, ex:
6565 
      result.ex = ex
6566 
    oprot.writeMessageBegin("validateDoa", TMessageType.REPLY, seqid)
6567 
    result.write(oprot)
6568 
    oprot.writeMessageEnd()
6569 
    oprot.trans.flush()
6570 
 
4495 rajveer 6571 
  def process_validateReturnProduct(self, seqid, iprot, oprot):
6572 
    args = validateReturnProduct_args()
6573 
    args.read(iprot)
6574 
    iprot.readMessageEnd()
6575 
    result = validateReturnProduct_result()
6576 
    try:
6577 
      result.success = self._handler.validateReturnProduct(args.orderId, args.isUsable)
6578 
    except TransactionServiceException, ex:
6579 
      result.ex = ex
6580 
    oprot.writeMessageBegin("validateReturnProduct", TMessageType.REPLY, seqid)
6581 
    result.write(oprot)
6582 
    oprot.writeMessageEnd()
6583 
    oprot.trans.flush()
6584 
 
2616 chandransh 6585 
  def process_reshipOrder(self, seqid, iprot, oprot):
6586 
    args = reshipOrder_args()
6587 
    args.read(iprot)
6588 
    iprot.readMessageEnd()
6589 
    result = reshipOrder_result()
6590 
    try:
6591 
      result.success = self._handler.reshipOrder(args.orderId)
6592 
    except TransactionServiceException, ex:
6593 
      result.ex = ex
6594 
    oprot.writeMessageBegin("reshipOrder", TMessageType.REPLY, seqid)
6595 
    result.write(oprot)
6596 
    oprot.writeMessageEnd()
6597 
    oprot.trans.flush()
2591 chandransh 6598 
 
2616 chandransh 6599 
  def process_refundOrder(self, seqid, iprot, oprot):
6600 
    args = refundOrder_args()
6601 
    args.read(iprot)
6602 
    iprot.readMessageEnd()
6603 
    result = refundOrder_result()
6604 
    try:
3226 chandransh 6605 
      result.success = self._handler.refundOrder(args.orderId, args.refundedBy, args.reason)
2616 chandransh 6606 
    except TransactionServiceException, ex:
6607 
      result.ex = ex
6608 
    oprot.writeMessageBegin("refundOrder", TMessageType.REPLY, seqid)
6609 
    result.write(oprot)
6610 
    oprot.writeMessageEnd()
6611 
    oprot.trans.flush()
6612 
 
2690 chandransh 6613 
  def process_getReturnOrders(self, seqid, iprot, oprot):
6614 
    args = getReturnOrders_args()
6615 
    args.read(iprot)
6616 
    iprot.readMessageEnd()
6617 
    result = getReturnOrders_result()
6618 
    result.success = self._handler.getReturnOrders(args.warehouseId, args.fromDate, args.toDate)
6619 
    oprot.writeMessageBegin("getReturnOrders", TMessageType.REPLY, seqid)
6620 
    result.write(oprot)
6621 
    oprot.writeMessageEnd()
6622 
    oprot.trans.flush()
2616 chandransh 6623 
 
5481 phani.kuma 6624 
  def process_getAllReturnOrders(self, seqid, iprot, oprot):
6625 
    args = getAllReturnOrders_args()
6626 
    args.read(iprot)
6627 
    iprot.readMessageEnd()
6628 
    result = getAllReturnOrders_result()
6629 
    result.success = self._handler.getAllReturnOrders(args.onlyNotProcessed, args.fromDate, args.toDate)
6630 
    oprot.writeMessageBegin("getAllReturnOrders", TMessageType.REPLY, seqid)
6631 
    result.write(oprot)
6632 
    oprot.writeMessageEnd()
6633 
    oprot.trans.flush()
6634 
 
2700 chandransh 6635 
  def process_getReturnOrder(self, seqid, iprot, oprot):
6636 
    args = getReturnOrder_args()
6637 
    args.read(iprot)
6638 
    iprot.readMessageEnd()
6639 
    result = getReturnOrder_result()
6640 
    try:
6641 
      result.success = self._handler.getReturnOrder(args.id)
6642 
    except TransactionServiceException, ex:
6643 
      result.ex = ex
6644 
    oprot.writeMessageBegin("getReturnOrder", TMessageType.REPLY, seqid)
6645 
    result.write(oprot)
6646 
    oprot.writeMessageEnd()
6647 
    oprot.trans.flush()
6648 
 
2690 chandransh 6649 
  def process_processReturn(self, seqid, iprot, oprot):
6650 
    args = processReturn_args()
6651 
    args.read(iprot)
6652 
    iprot.readMessageEnd()
6653 
    result = processReturn_result()
6654 
    try:
6655 
      self._handler.processReturn(args.returnOrderId)
6656 
    except TransactionServiceException, ex:
6657 
      result.ex = ex
6658 
    oprot.writeMessageBegin("processReturn", TMessageType.REPLY, seqid)
6659 
    result.write(oprot)
6660 
    oprot.writeMessageEnd()
6661 
    oprot.trans.flush()
6662 
 
3451 chandransh 6663 
  def process_updateWeight(self, seqid, iprot, oprot):
6664 
    args = updateWeight_args()
6665 
    args.read(iprot)
6666 
    iprot.readMessageEnd()
6667 
    result = updateWeight_result()
6668 
    try:
6669 
      result.success = self._handler.updateWeight(args.orderId, args.weight)
6670 
    except TransactionServiceException, ex:
6671 
      result.ex = ex
6672 
    oprot.writeMessageBegin("updateWeight", TMessageType.REPLY, seqid)
6673 
    result.write(oprot)
6674 
    oprot.writeMessageEnd()
6675 
    oprot.trans.flush()
2819 chandransh 6676 
 
3469 chandransh 6677 
  def process_changeItem(self, seqid, iprot, oprot):
6678 
    args = changeItem_args()
6679 
    args.read(iprot)
6680 
    iprot.readMessageEnd()
6681 
    result = changeItem_result()
6682 
    try:
6683 
      result.success = self._handler.changeItem(args.orderId, args.itemId)
6684 
    except TransactionServiceException, ex:
6685 
      result.ex = ex
6686 
    oprot.writeMessageBegin("changeItem", TMessageType.REPLY, seqid)
6687 
    result.write(oprot)
6688 
    oprot.writeMessageEnd()
6689 
    oprot.trans.flush()
3451 chandransh 6690 
 
3469 chandransh 6691 
  def process_shiftToWarehouse(self, seqid, iprot, oprot):
6692 
    args = shiftToWarehouse_args()
6693 
    args.read(iprot)
6694 
    iprot.readMessageEnd()
6695 
    result = shiftToWarehouse_result()
6696 
    try:
6697 
      result.success = self._handler.shiftToWarehouse(args.orderId, args.warehouseId)
6698 
    except TransactionServiceException, ex:
6699 
      result.ex = ex
6700 
    oprot.writeMessageBegin("shiftToWarehouse", TMessageType.REPLY, seqid)
6701 
    result.write(oprot)
6702 
    oprot.writeMessageEnd()
6703 
    oprot.trans.flush()
6704 
 
3553 chandransh 6705 
  def process_addDelayReason(self, seqid, iprot, oprot):
6706 
    args = addDelayReason_args()
6707 
    args.read(iprot)
6708 
    iprot.readMessageEnd()
6709 
    result = addDelayReason_result()
6710 
    try:
4647 rajveer 6711 
      result.success = self._handler.addDelayReason(args.orderId, args.delayReason, args.furtherDelay, args.delayReasonText)
3553 chandransh 6712 
    except TransactionServiceException, ex:
6713 
      result.ex = ex
6714 
    oprot.writeMessageBegin("addDelayReason", TMessageType.REPLY, seqid)
6715 
    result.write(oprot)
6716 
    oprot.writeMessageEnd()
6717 
    oprot.trans.flush()
3469 chandransh 6718 
 
3956 chandransh 6719 
  def process_reconcileCodCollection(self, seqid, iprot, oprot):
6720 
    args = reconcileCodCollection_args()
6721 
    args.read(iprot)
6722 
    iprot.readMessageEnd()
6723 
    result = reconcileCodCollection_result()
6724 
    try:
6725 
      result.success = self._handler.reconcileCodCollection(args.collectedAmountMap, args.xferBy, args.xferTxnId, args.xferDate)
6726 
    except TransactionServiceException, ex:
6727 
      result.ex = ex
6728 
    oprot.writeMessageBegin("reconcileCodCollection", TMessageType.REPLY, seqid)
6729 
    result.write(oprot)
6730 
    oprot.writeMessageEnd()
6731 
    oprot.trans.flush()
3553 chandransh 6732 
 
4008 mandeep.dh 6733 
  def process_getTransactionsRequiringExtraProcessing(self, seqid, iprot, oprot):
6734 
    args = getTransactionsRequiringExtraProcessing_args()
6735 
    args.read(iprot)
6736 
    iprot.readMessageEnd()
6737 
    result = getTransactionsRequiringExtraProcessing_result()
6738 
    result.success = self._handler.getTransactionsRequiringExtraProcessing(args.category)
6739 
    oprot.writeMessageBegin("getTransactionsRequiringExtraProcessing", TMessageType.REPLY, seqid)
6740 
    result.write(oprot)
6741 
    oprot.writeMessageEnd()
6742 
    oprot.trans.flush()
3956 chandransh 6743 
 
4008 mandeep.dh 6744 
  def process_markTransactionAsProcessed(self, seqid, iprot, oprot):
6745 
    args = markTransactionAsProcessed_args()
6746 
    args.read(iprot)
6747 
    iprot.readMessageEnd()
6748 
    result = markTransactionAsProcessed_result()
6749 
    self._handler.markTransactionAsProcessed(args.transactionId, args.category)
6750 
    oprot.writeMessageBegin("markTransactionAsProcessed", TMessageType.REPLY, seqid)
6751 
    result.write(oprot)
6752 
    oprot.writeMessageEnd()
6753 
    oprot.trans.flush()
6754 
 
4018 chandransh 6755 
  def process_getItemWiseRiskyOrdersCount(self, seqid, iprot, oprot):
6756 
    args = getItemWiseRiskyOrdersCount_args()
6757 
    args.read(iprot)
6758 
    iprot.readMessageEnd()
6759 
    result = getItemWiseRiskyOrdersCount_result()
6760 
    result.success = self._handler.getItemWiseRiskyOrdersCount()
6761 
    oprot.writeMessageBegin("getItemWiseRiskyOrdersCount", TMessageType.REPLY, seqid)
6762 
    result.write(oprot)
6763 
    oprot.writeMessageEnd()
6764 
    oprot.trans.flush()
4008 mandeep.dh 6765 
 
4295 varun.gupt 6766 
  def process_getOrdersForItemIds(self, seqid, iprot, oprot):
6767 
    args = getOrdersForItemIds_args()
6768 
    args.read(iprot)
6769 
    iprot.readMessageEnd()
6770 
    result = getOrdersForItemIds_result()
6771 
    result.success = self._handler.getOrdersForItemIds(args.itemIds)
6772 
    oprot.writeMessageBegin("getOrdersForItemIds", TMessageType.REPLY, seqid)
6773 
    result.write(oprot)
6774 
    oprot.writeMessageEnd()
6775 
    oprot.trans.flush()
6776 
 
4247 rajveer 6777 
  def process_markOrderCancellationRequestReceived(self, seqid, iprot, oprot):
6778 
    args = markOrderCancellationRequestReceived_args()
6779 
    args.read(iprot)
6780 
    iprot.readMessageEnd()
6781 
    result = markOrderCancellationRequestReceived_result()
6782 
    try:
6783 
      self._handler.markOrderCancellationRequestReceived(args.orderId)
6784 
    except TransactionServiceException, ex:
6785 
      result.ex = ex
6786 
    oprot.writeMessageBegin("markOrderCancellationRequestReceived", TMessageType.REPLY, seqid)
6787 
    result.write(oprot)
6788 
    oprot.writeMessageEnd()
6789 
    oprot.trans.flush()
4018 chandransh 6790 
 
4247 rajveer 6791 
  def process_markOrderCancellationRequestConfirmed(self, seqid, iprot, oprot):
6792 
    args = markOrderCancellationRequestConfirmed_args()
6793 
    args.read(iprot)
6794 
    iprot.readMessageEnd()
6795 
    result = markOrderCancellationRequestConfirmed_result()
6796 
    try:
6797 
      self._handler.markOrderCancellationRequestConfirmed(args.orderId)
6798 
    except TransactionServiceException, ex:
6799 
      result.ex = ex
6800 
    oprot.writeMessageBegin("markOrderCancellationRequestConfirmed", TMessageType.REPLY, seqid)
6801 
    result.write(oprot)
6802 
    oprot.writeMessageEnd()
6803 
    oprot.trans.flush()
6804 
 
6805 
  def process_markOrderCancellationRequestDenied(self, seqid, iprot, oprot):
6806 
    args = markOrderCancellationRequestDenied_args()
6807 
    args.read(iprot)
6808 
    iprot.readMessageEnd()
6809 
    result = markOrderCancellationRequestDenied_result()
6810 
    try:
6811 
      self._handler.markOrderCancellationRequestDenied(args.orderId)
6812 
    except TransactionServiceException, ex:
6813 
      result.ex = ex
6814 
    oprot.writeMessageBegin("markOrderCancellationRequestDenied", TMessageType.REPLY, seqid)
6815 
    result.write(oprot)
6816 
    oprot.writeMessageEnd()
6817 
    oprot.trans.flush()
6818 
 
4258 rajveer 6819 
  def process_markTransactionAsPaymentFlagRemoved(self, seqid, iprot, oprot):
6820 
    args = markTransactionAsPaymentFlagRemoved_args()
4247 rajveer 6821 
    args.read(iprot)
6822 
    iprot.readMessageEnd()
4258 rajveer 6823 
    result = markTransactionAsPaymentFlagRemoved_result()
4247 rajveer 6824 
    try:
4258 rajveer 6825 
      self._handler.markTransactionAsPaymentFlagRemoved(args.transactionId)
4247 rajveer 6826 
    except TransactionServiceException, ex:
6827 
      result.ex = ex
4258 rajveer 6828 
    oprot.writeMessageBegin("markTransactionAsPaymentFlagRemoved", TMessageType.REPLY, seqid)
4247 rajveer 6829 
    result.write(oprot)
6830 
    oprot.writeMessageEnd()
6831 
    oprot.trans.flush()
6832 
 
4259 anupam.sin 6833 
  def process_refundTransaction(self, seqid, iprot, oprot):
6834 
    args = refundTransaction_args()
6835 
    args.read(iprot)
6836 
    iprot.readMessageEnd()
6837 
    result = refundTransaction_result()
6838 
    try:
6839 
      self._handler.refundTransaction(args.transactionId, args.refundedBy, args.reason)
6840 
    except TransactionServiceException, ex:
6841 
      result.ex = ex
6842 
    oprot.writeMessageBegin("refundTransaction", TMessageType.REPLY, seqid)
6843 
    result.write(oprot)
6844 
    oprot.writeMessageEnd()
6845 
    oprot.trans.flush()
4247 rajveer 6846 
 
4324 mandeep.dh 6847 
  def process_updateShipmentAddress(self, seqid, iprot, oprot):
6848 
    args = updateShipmentAddress_args()
6849 
    args.read(iprot)
6850 
    iprot.readMessageEnd()
6851 
    result = updateShipmentAddress_result()
6852 
    try:
6853 
      self._handler.updateShipmentAddress(args.orderId, args.addressId)
6854 
    except TransactionServiceException, ex:
6855 
      result.ex = ex
6856 
    oprot.writeMessageBegin("updateShipmentAddress", TMessageType.REPLY, seqid)
6857 
    result.write(oprot)
6858 
    oprot.writeMessageEnd()
6859 
    oprot.trans.flush()
6860 
 
4285 rajveer 6861 
  def process_acceptOrdersForItemId(self, seqid, iprot, oprot):
6862 
    args = acceptOrdersForItemId_args()
6863 
    args.read(iprot)
6864 
    iprot.readMessageEnd()
6865 
    result = acceptOrdersForItemId_result()
6866 
    try:
6867 
      result.success = self._handler.acceptOrdersForItemId(args.itemId, args.inventory)
6868 
    except TransactionServiceException, ex:
6869 
      result.ex = ex
6870 
    oprot.writeMessageBegin("acceptOrdersForItemId", TMessageType.REPLY, seqid)
6871 
    result.write(oprot)
6872 
    oprot.writeMessageEnd()
6873 
    oprot.trans.flush()
4259 anupam.sin 6874 
 
4303 rajveer 6875 
  def process_markOrdersAsPORaised(self, seqid, iprot, oprot):
6876 
    args = markOrdersAsPORaised_args()
6877 
    args.read(iprot)
6878 
    iprot.readMessageEnd()
6879 
    result = markOrdersAsPORaised_result()
6880 
    try:
4369 rajveer 6881 
      self._handler.markOrdersAsPORaised(args.vendorId, args.itemId, args.quantity, args.estimate, args.isReminder)
4303 rajveer 6882 
    except TransactionServiceException, ex:
6883 
      result.ex = ex
6884 
    oprot.writeMessageBegin("markOrdersAsPORaised", TMessageType.REPLY, seqid)
6885 
    result.write(oprot)
6886 
    oprot.writeMessageEnd()
6887 
    oprot.trans.flush()
4285 rajveer 6888 
 
4303 rajveer 6889 
  def process_markOrdersAsReversalInitiated(self, seqid, iprot, oprot):
6890 
    args = markOrdersAsReversalInitiated_args()
6891 
    args.read(iprot)
6892 
    iprot.readMessageEnd()
6893 
    result = markOrdersAsReversalInitiated_result()
6894 
    try:
4369 rajveer 6895 
      self._handler.markOrdersAsReversalInitiated(args.vendorId, args.itemId, args.quantity, args.estimate, args.isReminder)
4303 rajveer 6896 
    except TransactionServiceException, ex:
6897 
      result.ex = ex
6898 
    oprot.writeMessageBegin("markOrdersAsReversalInitiated", TMessageType.REPLY, seqid)
6899 
    result.write(oprot)
6900 
    oprot.writeMessageEnd()
6901 
    oprot.trans.flush()
6902 
 
6903 
  def process_markOrdersAsNotAvailabke(self, seqid, iprot, oprot):
6904 
    args = markOrdersAsNotAvailabke_args()
6905 
    args.read(iprot)
6906 
    iprot.readMessageEnd()
6907 
    result = markOrdersAsNotAvailabke_result()
6908 
    try:
4369 rajveer 6909 
      self._handler.markOrdersAsNotAvailabke(args.vendorId, args.itemId, args.quantity, args.estimate, args.isReminder)
4303 rajveer 6910 
    except TransactionServiceException, ex:
6911 
      result.ex = ex
6912 
    oprot.writeMessageBegin("markOrdersAsNotAvailabke", TMessageType.REPLY, seqid)
6913 
    result.write(oprot)
6914 
    oprot.writeMessageEnd()
6915 
    oprot.trans.flush()
6916 
 
4369 rajveer 6917 
  def process_markOrdersAsTimeout(self, seqid, iprot, oprot):
6918 
    args = markOrdersAsTimeout_args()
6919 
    args.read(iprot)
6920 
    iprot.readMessageEnd()
6921 
    result = markOrdersAsTimeout_result()
6922 
    try:
6923 
      result.success = self._handler.markOrdersAsTimeout(args.vendorId)
6924 
    except TransactionServiceException, ex:
6925 
      result.ex = ex
6926 
    oprot.writeMessageBegin("markOrdersAsTimeout", TMessageType.REPLY, seqid)
6927 
    result.write(oprot)
6928 
    oprot.writeMessageEnd()
6929 
    oprot.trans.flush()
4303 rajveer 6930 
 
4662 rajveer 6931 
  def process_markOrderAsLostInTransit(self, seqid, iprot, oprot):
6932 
    args = markOrderAsLostInTransit_args()
6933 
    args.read(iprot)
6934 
    iprot.readMessageEnd()
6935 
    result = markOrderAsLostInTransit_result()
6936 
    try:
6937 
      result.success = self._handler.markOrderAsLostInTransit(args.orderId)
6938 
    except TransactionServiceException, ex:
6939 
      result.ex = ex
6940 
    oprot.writeMessageBegin("markOrderAsLostInTransit", TMessageType.REPLY, seqid)
6941 
    result.write(oprot)
6942 
    oprot.writeMessageEnd()
6943 
    oprot.trans.flush()
6944 
 
4386 anupam.sin 6945 
  def process_getOrderForAwb(self, seqid, iprot, oprot):
6946 
    args = getOrderForAwb_args()
6947 
    args.read(iprot)
6948 
    iprot.readMessageEnd()
6949 
    result = getOrderForAwb_result()
6950 
    try:
6951 
      result.success = self._handler.getOrderForAwb(args.awb)
6952 
    except TransactionServiceException, ex:
6953 
      result.ex = ex
6954 
    oprot.writeMessageBegin("getOrderForAwb", TMessageType.REPLY, seqid)
6955 
    result.write(oprot)
6956 
    oprot.writeMessageEnd()
6957 
    oprot.trans.flush()
4369 rajveer 6958 
 
4506 phani.kuma 6959 
  def process_getOrdersForProviderForStatus(self, seqid, iprot, oprot):
6960 
    args = getOrdersForProviderForStatus_args()
6961 
    args.read(iprot)
6962 
    iprot.readMessageEnd()
6963 
    result = getOrdersForProviderForStatus_result()
6964 
    try:
4910 phani.kuma 6965 
      result.success = self._handler.getOrdersForProviderForStatus(args.logistics_provider_id, args.order_status_list)
4506 phani.kuma 6966 
    except TransactionServiceException, ex:
6967 
      result.ex = ex
6968 
    oprot.writeMessageBegin("getOrdersForProviderForStatus", TMessageType.REPLY, seqid)
6969 
    result.write(oprot)
6970 
    oprot.writeMessageEnd()
6971 
    oprot.trans.flush()
4386 anupam.sin 6972 
 
4600 varun.gupt 6973 
  def process_getBilledOrdersForVendor(self, seqid, iprot, oprot):
6974 
    args = getBilledOrdersForVendor_args()
6975 
    args.read(iprot)
6976 
    iprot.readMessageEnd()
6977 
    result = getBilledOrdersForVendor_result()
6978 
    try:
6979 
      result.success = self._handler.getBilledOrdersForVendor(args.vendorId, args.billingDateFrom, args.billingDateTo)
6980 
    except TransactionServiceException, ex:
6981 
      result.ex = ex
6982 
    oprot.writeMessageBegin("getBilledOrdersForVendor", TMessageType.REPLY, seqid)
6983 
    result.write(oprot)
6984 
    oprot.writeMessageEnd()
6985 
    oprot.trans.flush()
4506 phani.kuma 6986 
 
4607 rajveer 6987 
  def process_getSlippedSippingDateOrders(self, seqid, iprot, oprot):
6988 
    args = getSlippedSippingDateOrders_args()
6989 
    args.read(iprot)
6990 
    iprot.readMessageEnd()
6991 
    result = getSlippedSippingDateOrders_result()
6992 
    try:
6993 
      result.success = self._handler.getSlippedSippingDateOrders()
6994 
    except TransactionServiceException, ex:
6995 
      result.ex = ex
6996 
    oprot.writeMessageBegin("getSlippedSippingDateOrders", TMessageType.REPLY, seqid)
6997 
    result.write(oprot)
6998 
    oprot.writeMessageEnd()
6999 
    oprot.trans.flush()
7000 
 
4709 rajveer 7001 
  def process_getCancelledOrders(self, seqid, iprot, oprot):
7002 
    args = getCancelledOrders_args()
7003 
    args.read(iprot)
7004 
    iprot.readMessageEnd()
7005 
    result = getCancelledOrders_result()
7006 
    try:
7007 
      result.success = self._handler.getCancelledOrders(args.cancelDateFrom, args.cancelDateTo)
7008 
    except TransactionServiceException, ex:
7009 
      result.ex = ex
7010 
    oprot.writeMessageBegin("getCancelledOrders", TMessageType.REPLY, seqid)
7011 
    result.write(oprot)
7012 
    oprot.writeMessageEnd()
7013 
    oprot.trans.flush()
7014 
 
4600 varun.gupt 7015 
  def process_saveBluedartSettlements(self, seqid, iprot, oprot):
7016 
    args = saveBluedartSettlements_args()
7017 
    args.read(iprot)
7018 
    iprot.readMessageEnd()
7019 
    result = saveBluedartSettlements_result()
7020 
    try:
7021 
      self._handler.saveBluedartSettlements(args.mapAWBAndAmount)
7022 
    except TransactionServiceException, ex:
7023 
      result.ex = ex
7024 
    oprot.writeMessageBegin("saveBluedartSettlements", TMessageType.REPLY, seqid)
7025 
    result.write(oprot)
7026 
    oprot.writeMessageEnd()
7027 
    oprot.trans.flush()
7028 
 
7029 
  def process_savePaymentSettlements(self, seqid, iprot, oprot):
7030 
    args = savePaymentSettlements_args()
7031 
    args.read(iprot)
7032 
    iprot.readMessageEnd()
7033 
    result = savePaymentSettlements_result()
7034 
    try:
4905 varun.gupt 7035 
      self._handler.savePaymentSettlements(args.settlementDate, args.paymentGatewayId, args.referenceId, args.serviceTax, args.otherCharges, args.netCollection)
4600 varun.gupt 7036 
    except TransactionServiceException, ex:
7037 
      result.ex = ex
7038 
    oprot.writeMessageBegin("savePaymentSettlements", TMessageType.REPLY, seqid)
7039 
    result.write(oprot)
7040 
    oprot.writeMessageEnd()
7041 
    oprot.trans.flush()
7042 
 
7043 
  def process_saveEBSSettlementSummary(self, seqid, iprot, oprot):
7044 
    args = saveEBSSettlementSummary_args()
7045 
    args.read(iprot)
7046 
    iprot.readMessageEnd()
7047 
    result = saveEBSSettlementSummary_result()
7048 
    try:
7049 
      self._handler.saveEBSSettlementSummary(args.settlementId, args.settlementDate, args.transactionDateFrom, args.transactionDateTo, args.amount)
7050 
    except TransactionServiceException, ex:
7051 
      result.ex = ex
7052 
    oprot.writeMessageBegin("saveEBSSettlementSummary", TMessageType.REPLY, seqid)
7053 
    result.write(oprot)
7054 
    oprot.writeMessageEnd()
7055 
    oprot.trans.flush()
7056 
 
5386 phani.kuma 7057 
  def process_getSettlementForPrepaid(self, seqid, iprot, oprot):
7058 
    args = getSettlementForPrepaid_args()
4600 varun.gupt 7059 
    args.read(iprot)
7060 
    iprot.readMessageEnd()
5386 phani.kuma 7061 
    result = getSettlementForPrepaid_result()
4600 varun.gupt 7062 
    try:
5386 phani.kuma 7063 
      result.success = self._handler.getSettlementForPrepaid(args.referenceId, args.isRefund)
4600 varun.gupt 7064 
    except TransactionServiceException, ex:
7065 
      result.ex = ex
5386 phani.kuma 7066 
    oprot.writeMessageBegin("getSettlementForPrepaid", TMessageType.REPLY, seqid)
4600 varun.gupt 7067 
    result.write(oprot)
7068 
    oprot.writeMessageEnd()
7069 
    oprot.trans.flush()
7070 
 
5386 phani.kuma 7071 
  def process_getSettlementForCod(self, seqid, iprot, oprot):
7072 
    args = getSettlementForCod_args()
7073 
    args.read(iprot)
7074 
    iprot.readMessageEnd()
7075 
    result = getSettlementForCod_result()
7076 
    try:
7077 
      result.success = self._handler.getSettlementForCod(args.orderId, args.isRefund)
7078 
    except TransactionServiceException, ex:
7079 
      result.ex = ex
7080 
    oprot.writeMessageBegin("getSettlementForCod", TMessageType.REPLY, seqid)
7081 
    result.write(oprot)
7082 
    oprot.writeMessageEnd()
7083 
    oprot.trans.flush()
7084 
 
4600 varun.gupt 7085 
  def process_getEBSSettlementSummaries(self, seqid, iprot, oprot):
7086 
    args = getEBSSettlementSummaries_args()
7087 
    args.read(iprot)
7088 
    iprot.readMessageEnd()
7089 
    result = getEBSSettlementSummaries_result()
7090 
    try:
7091 
      result.success = self._handler.getEBSSettlementSummaries()
7092 
    except TransactionServiceException, ex:
7093 
      result.ex = ex
7094 
    oprot.writeMessageBegin("getEBSSettlementSummaries", TMessageType.REPLY, seqid)
7095 
    result.write(oprot)
7096 
    oprot.writeMessageEnd()
7097 
    oprot.trans.flush()
7098 
 
7099 
  def process_markEBSSettlementUploaded(self, seqid, iprot, oprot):
7100 
    args = markEBSSettlementUploaded_args()
7101 
    args.read(iprot)
7102 
    iprot.readMessageEnd()
7103 
    result = markEBSSettlementUploaded_result()
7104 
    try:
7105 
      self._handler.markEBSSettlementUploaded(args.settlementId)
7106 
    except TransactionServiceException, ex:
7107 
      result.ex = ex
7108 
    oprot.writeMessageBegin("markEBSSettlementUploaded", TMessageType.REPLY, seqid)
7109 
    result.write(oprot)
7110 
    oprot.writeMessageEnd()
7111 
    oprot.trans.flush()
7112 
 
7113 
  def process_getEBSSettlementDate(self, seqid, iprot, oprot):
7114 
    args = getEBSSettlementDate_args()
7115 
    args.read(iprot)
7116 
    iprot.readMessageEnd()
7117 
    result = getEBSSettlementDate_result()
7118 
    try:
7119 
      result.success = self._handler.getEBSSettlementDate(args.settlementId)
7120 
    except TransactionServiceException, ex:
7121 
      result.ex = ex
7122 
    oprot.writeMessageBegin("getEBSSettlementDate", TMessageType.REPLY, seqid)
7123 
    result.write(oprot)
7124 
    oprot.writeMessageEnd()
7125 
    oprot.trans.flush()
7126 
 
4715 varun.gupt 7127 
  def process_getSettlementsByDate(self, seqid, iprot, oprot):
7128 
    args = getSettlementsByDate_args()
7129 
    args.read(iprot)
7130 
    iprot.readMessageEnd()
7131 
    result = getSettlementsByDate_result()
7132 
    try:
7133 
      result.success = self._handler.getSettlementsByDate(args.settlementDateFrom, args.settlementDateTo, args.isRefund)
7134 
    except TransactionServiceException, ex:
7135 
      result.ex = ex
7136 
    oprot.writeMessageBegin("getSettlementsByDate", TMessageType.REPLY, seqid)
7137 
    result.write(oprot)
7138 
    oprot.writeMessageEnd()
7139 
    oprot.trans.flush()
4600 varun.gupt 7140 
 
4715 varun.gupt 7141 
  def process_getReshippedOrderIds(self, seqid, iprot, oprot):
7142 
    args = getReshippedOrderIds_args()
7143 
    args.read(iprot)
7144 
    iprot.readMessageEnd()
7145 
    result = getReshippedOrderIds_result()
7146 
    try:
7147 
      result.success = self._handler.getReshippedOrderIds(args.orderIds)
7148 
    except TransactionServiceException, ex:
7149 
      result.ex = ex
7150 
    oprot.writeMessageBegin("getReshippedOrderIds", TMessageType.REPLY, seqid)
7151 
    result.write(oprot)
7152 
    oprot.writeMessageEnd()
7153 
    oprot.trans.flush()
7154 
 
5481 phani.kuma 7155 
  def process_getBilledOrders(self, seqid, iprot, oprot):
7156 
    args = getBilledOrders_args()
4875 varun.gupt 7157 
    args.read(iprot)
7158 
    iprot.readMessageEnd()
5481 phani.kuma 7159 
    result = getBilledOrders_result()
4875 varun.gupt 7160 
    try:
5481 phani.kuma 7161 
      result.success = self._handler.getBilledOrders(args.vendorId, args.onlyVendorNotPaid, args.billingDateFrom, args.billingDateTo)
4875 varun.gupt 7162 
    except TransactionServiceException, ex:
7163 
      result.ex = ex
5481 phani.kuma 7164 
    oprot.writeMessageBegin("getBilledOrders", TMessageType.REPLY, seqid)
4875 varun.gupt 7165 
    result.write(oprot)
7166 
    oprot.writeMessageEnd()
7167 
    oprot.trans.flush()
4757 mandeep.dh 7168 
 
5031 varun.gupt 7169 
  def process_getStatusDistributionOfOrders(self, seqid, iprot, oprot):
7170 
    args = getStatusDistributionOfOrders_args()
7171 
    args.read(iprot)
7172 
    iprot.readMessageEnd()
7173 
    result = getStatusDistributionOfOrders_result()
7174 
    try:
7175 
      result.success = self._handler.getStatusDistributionOfOrders(args.startDate, args.endDate)
7176 
    except TransactionServiceException, ex:
7177 
      result.ex = ex
7178 
    oprot.writeMessageBegin("getStatusDistributionOfOrders", TMessageType.REPLY, seqid)
7179 
    result.write(oprot)
7180 
    oprot.writeMessageEnd()
7181 
    oprot.trans.flush()
4875 varun.gupt 7182 
 
5067 varun.gupt 7183 
  def process_getOrderIdsForStatus(self, seqid, iprot, oprot):
7184 
    args = getOrderIdsForStatus_args()
7185 
    args.read(iprot)
7186 
    iprot.readMessageEnd()
7187 
    result = getOrderIdsForStatus_result()
7188 
    try:
7189 
      result.success = self._handler.getOrderIdsForStatus(args.status, args.startDatetime, args.endDatetime)
7190 
    except TransactionServiceException, ex:
7191 
      result.ex = ex
7192 
    oprot.writeMessageBegin("getOrderIdsForStatus", TMessageType.REPLY, seqid)
7193 
    result.write(oprot)
7194 
    oprot.writeMessageEnd()
7195 
    oprot.trans.flush()
5031 varun.gupt 7196 
 
5348 anupam.sin 7197 
  def process_updateCODAgent(self, seqid, iprot, oprot):
7198 
    args = updateCODAgent_args()
7199 
    args.read(iprot)
7200 
    iprot.readMessageEnd()
7201 
    result = updateCODAgent_result()
7202 
    try:
7203 
      self._handler.updateCODAgent(args.agent, args.orderId)
7204 
    except TransactionServiceException, ex:
7205 
      result.ex = ex
7206 
    oprot.writeMessageBegin("updateCODAgent", TMessageType.REPLY, seqid)
7207 
    result.write(oprot)
7208 
    oprot.writeMessageEnd()
7209 
    oprot.trans.flush()
7210 
 
5099 varun.gupt 7211 
  def process_updateOrderAsPaidToVendor(self, seqid, iprot, oprot):
7212 
    args = updateOrderAsPaidToVendor_args()
7213 
    args.read(iprot)
7214 
    iprot.readMessageEnd()
7215 
    result = updateOrderAsPaidToVendor_result()
7216 
    try:
7217 
      self._handler.updateOrderAsPaidToVendor(args.orderId)
7218 
    except TransactionServiceException, ex:
7219 
      result.ex = ex
7220 
    oprot.writeMessageBegin("updateOrderAsPaidToVendor", TMessageType.REPLY, seqid)
7221 
    result.write(oprot)
7222 
    oprot.writeMessageEnd()
7223 
    oprot.trans.flush()
5067 varun.gupt 7224 
 
5386 phani.kuma 7225 
  def process_updateOrderOnlyAsPaidToVendor(self, seqid, iprot, oprot):
7226 
    args = updateOrderOnlyAsPaidToVendor_args()
7227 
    args.read(iprot)
7228 
    iprot.readMessageEnd()
7229 
    result = updateOrderOnlyAsPaidToVendor_result()
7230 
    try:
7231 
      self._handler.updateOrderOnlyAsPaidToVendor(args.orderId)
7232 
    except TransactionServiceException, ex:
7233 
      result.ex = ex
7234 
    oprot.writeMessageBegin("updateOrderOnlyAsPaidToVendor", TMessageType.REPLY, seqid)
7235 
    result.write(oprot)
7236 
    oprot.writeMessageEnd()
7237 
    oprot.trans.flush()
7238 
 
5208 varun.gupt 7239 
  def process_getRefundedOrdersMarkedPaid(self, seqid, iprot, oprot):
7240 
    args = getRefundedOrdersMarkedPaid_args()
7241 
    args.read(iprot)
7242 
    iprot.readMessageEnd()
7243 
    result = getRefundedOrdersMarkedPaid_result()
7244 
    try:
7245 
      result.success = self._handler.getRefundedOrdersMarkedPaid()
7246 
    except TransactionServiceException, ex:
7247 
      result.ex = ex
7248 
    oprot.writeMessageBegin("getRefundedOrdersMarkedPaid", TMessageType.REPLY, seqid)
7249 
    result.write(oprot)
7250 
    oprot.writeMessageEnd()
7251 
    oprot.trans.flush()
5099 varun.gupt 7252 
 
5447 anupam.sin 7253 
  def process_getAllVerificationAgents(self, seqid, iprot, oprot):
7254 
    args = getAllVerificationAgents_args()
7255 
    args.read(iprot)
7256 
    iprot.readMessageEnd()
7257 
    result = getAllVerificationAgents_result()
7258 
    result.success = self._handler.getAllVerificationAgents(args.minOrderId, args.maxOrderId)
7259 
    oprot.writeMessageBegin("getAllVerificationAgents", TMessageType.REPLY, seqid)
7260 
    result.write(oprot)
7261 
    oprot.writeMessageEnd()
7262 
    oprot.trans.flush()
5208 varun.gupt 7263 
 
5527 anupam.sin 7264 
  def process_getAllAttributesForOrderId(self, seqid, iprot, oprot):
7265 
    args = getAllAttributesForOrderId_args()
7266 
    args.read(iprot)
7267 
    iprot.readMessageEnd()
7268 
    result = getAllAttributesForOrderId_result()
7269 
    result.success = self._handler.getAllAttributesForOrderId(args.orderId)
7270 
    oprot.writeMessageBegin("getAllAttributesForOrderId", TMessageType.REPLY, seqid)
7271 
    result.write(oprot)
7272 
    oprot.writeMessageEnd()
7273 
    oprot.trans.flush()
5447 anupam.sin 7274 
 
5676 rajveer 7275 
  def process_setOrderAttributes(self, seqid, iprot, oprot):
7276 
    args = setOrderAttributes_args()
7277 
    args.read(iprot)
7278 
    iprot.readMessageEnd()
7279 
    result = setOrderAttributes_result()
7280 
    self._handler.setOrderAttributes(args.orderId, args.attributes)
7281 
    oprot.writeMessageBegin("setOrderAttributes", TMessageType.REPLY, seqid)
7282 
    result.write(oprot)
7283 
    oprot.writeMessageEnd()
7284 
    oprot.trans.flush()
7285 
 
5527 anupam.sin 7286 
  def process_setOrderAttributeForTransaction(self, seqid, iprot, oprot):
7287 
    args = setOrderAttributeForTransaction_args()
7288 
    args.read(iprot)
7289 
    iprot.readMessageEnd()
7290 
    result = setOrderAttributeForTransaction_result()
7291 
    self._handler.setOrderAttributeForTransaction(args.transactionId, args.attribute)
7292 
    oprot.writeMessageBegin("setOrderAttributeForTransaction", TMessageType.REPLY, seqid)
7293 
    result.write(oprot)
7294 
    oprot.writeMessageEnd()
7295 
    oprot.trans.flush()
7296 
 
5553 rajveer 7297 
  def process_getReceivePendingOrders(self, seqid, iprot, oprot):
7298 
    args = getReceivePendingOrders_args()
7299 
    args.read(iprot)
7300 
    iprot.readMessageEnd()
7301 
    result = getReceivePendingOrders_result()
7302 
    result.success = self._handler.getReceivePendingOrders(args.storeId)
7303 
    oprot.writeMessageBegin("getReceivePendingOrders", TMessageType.REPLY, seqid)
7304 
    result.write(oprot)
7305 
    oprot.writeMessageEnd()
7306 
    oprot.trans.flush()
5527 anupam.sin 7307 
 
5553 rajveer 7308 
  def process_getReceivedAtStoreOrders(self, seqid, iprot, oprot):
7309 
    args = getReceivedAtStoreOrders_args()
7310 
    args.read(iprot)
7311 
    iprot.readMessageEnd()
7312 
    result = getReceivedAtStoreOrders_result()
7313 
    result.success = self._handler.getReceivedAtStoreOrders(args.storeId)
7314 
    oprot.writeMessageBegin("getReceivedAtStoreOrders", TMessageType.REPLY, seqid)
7315 
    result.write(oprot)
7316 
    oprot.writeMessageEnd()
7317 
    oprot.trans.flush()
7318 
 
5593 mandeep.dh 7319 
  def process_acceptOrderForItem(self, seqid, iprot, oprot):
7320 
    args = acceptOrderForItem_args()
7321 
    args.read(iprot)
7322 
    iprot.readMessageEnd()
7323 
    result = acceptOrderForItem_result()
7324 
    self._handler.acceptOrderForItem(args.itemId, args.quantity, args.fulfilmentWarehouseId, args.billingWarehouseId)
7325 
    oprot.writeMessageBegin("acceptOrderForItem", TMessageType.REPLY, seqid)
7326 
    result.write(oprot)
7327 
    oprot.writeMessageEnd()
7328 
    oprot.trans.flush()
5553 rajveer 7329 
 
5593 mandeep.dh 7330 
 
94 ashish 7331 
# HELPER FUNCTIONS AND STRUCTURES
7332 
 
7333 
class createTransaction_args:
7334 
  """
7335 
  Attributes:
7336 
   - transaction
7337 
  """
7338 
 
7339 
  thrift_spec = (
7340 
    None, # 0
7341 
    (1, TType.STRUCT, 'transaction', (Transaction, Transaction.thrift_spec), None, ), # 1
7342 
  )
7343 
 
7344 
  def __init__(self, transaction=None,):
7345 
    self.transaction = transaction
7346 
 
7347 
  def read(self, iprot):
7348 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
7349 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
7350 
      return
7351 
    iprot.readStructBegin()
7352 
    while True:
7353 
      (fname, ftype, fid) = iprot.readFieldBegin()
7354 
      if ftype == TType.STOP:
7355 
        break
7356 
      if fid == 1:
7357 
        if ftype == TType.STRUCT:
7358 
          self.transaction = Transaction()
7359 
          self.transaction.read(iprot)
7360 
        else:
7361 
          iprot.skip(ftype)
7362 
      else:
7363 
        iprot.skip(ftype)
7364 
      iprot.readFieldEnd()
7365 
    iprot.readStructEnd()
7366 
 
7367 
  def write(self, oprot):
7368 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
7369 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
7370 
      return
7371 
    oprot.writeStructBegin('createTransaction_args')
3431 rajveer 7372 
    if self.transaction is not None:
94 ashish 7373 
      oprot.writeFieldBegin('transaction', TType.STRUCT, 1)
7374 
      self.transaction.write(oprot)
7375 
      oprot.writeFieldEnd()
7376 
    oprot.writeFieldStop()
7377 
    oprot.writeStructEnd()
7378 
 
3431 rajveer 7379 
  def validate(self):
7380 
    return
7381 
 
7382 
 
94 ashish 7383 
  def __repr__(self):
7384 
    L = ['%s=%r' % (key, value)
7385 
      for key, value in self.__dict__.iteritems()]
7386 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
7387 
 
7388 
  def __eq__(self, other):
7389 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
7390 
 
7391 
  def __ne__(self, other):
7392 
    return not (self == other)
7393 
 
7394 
class createTransaction_result:
7395 
  """
7396 
  Attributes:
132 ashish 7397 
   - success
94 ashish 7398 
   - ex
7399 
  """
7400 
 
7401 
  thrift_spec = (
132 ashish 7402 
    (0, TType.I64, 'success', None, None, ), # 0
94 ashish 7403 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
7404 
  )
7405 
 
132 ashish 7406 
  def __init__(self, success=None, ex=None,):
7407 
    self.success = success
94 ashish 7408 
    self.ex = ex
7409 
 
7410 
  def read(self, iprot):
7411 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
7412 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
7413 
      return
7414 
    iprot.readStructBegin()
7415 
    while True:
7416 
      (fname, ftype, fid) = iprot.readFieldBegin()
7417 
      if ftype == TType.STOP:
7418 
        break
132 ashish 7419 
      if fid == 0:
7420 
        if ftype == TType.I64:
7421 
          self.success = iprot.readI64();
7422 
        else:
7423 
          iprot.skip(ftype)
7424 
      elif fid == 1:
94 ashish 7425 
        if ftype == TType.STRUCT:
7426 
          self.ex = TransactionServiceException()
7427 
          self.ex.read(iprot)
7428 
        else:
7429 
          iprot.skip(ftype)
7430 
      else:
7431 
        iprot.skip(ftype)
7432 
      iprot.readFieldEnd()
7433 
    iprot.readStructEnd()
7434 
 
7435 
  def write(self, oprot):
7436 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
7437 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
7438 
      return
7439 
    oprot.writeStructBegin('createTransaction_result')
3431 rajveer 7440 
    if self.success is not None:
132 ashish 7441 
      oprot.writeFieldBegin('success', TType.I64, 0)
7442 
      oprot.writeI64(self.success)
7443 
      oprot.writeFieldEnd()
3431 rajveer 7444 
    if self.ex is not None:
94 ashish 7445 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
7446 
      self.ex.write(oprot)
7447 
      oprot.writeFieldEnd()
7448 
    oprot.writeFieldStop()
7449 
    oprot.writeStructEnd()
7450 
 
3431 rajveer 7451 
  def validate(self):
7452 
    return
7453 
 
7454 
 
94 ashish 7455 
  def __repr__(self):
7456 
    L = ['%s=%r' % (key, value)
7457 
      for key, value in self.__dict__.iteritems()]
7458 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
7459 
 
7460 
  def __eq__(self, other):
7461 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
7462 
 
7463 
  def __ne__(self, other):
7464 
    return not (self == other)
7465 
 
7466 
class getTransaction_args:
7467 
  """
7468 
  Attributes:
7469 
   - id
7470 
  """
7471 
 
7472 
  thrift_spec = (
7473 
    None, # 0
7474 
    (1, TType.I64, 'id', None, None, ), # 1
7475 
  )
7476 
 
7477 
  def __init__(self, id=None,):
7478 
    self.id = id
7479 
 
7480 
  def read(self, iprot):
7481 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
7482 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
7483 
      return
7484 
    iprot.readStructBegin()
7485 
    while True:
7486 
      (fname, ftype, fid) = iprot.readFieldBegin()
7487 
      if ftype == TType.STOP:
7488 
        break
7489 
      if fid == 1:
7490 
        if ftype == TType.I64:
7491 
          self.id = iprot.readI64();
7492 
        else:
7493 
          iprot.skip(ftype)
7494 
      else:
7495 
        iprot.skip(ftype)
7496 
      iprot.readFieldEnd()
7497 
    iprot.readStructEnd()
7498 
 
7499 
  def write(self, oprot):
7500 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
7501 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
7502 
      return
7503 
    oprot.writeStructBegin('getTransaction_args')
3431 rajveer 7504 
    if self.id is not None:
94 ashish 7505 
      oprot.writeFieldBegin('id', TType.I64, 1)
7506 
      oprot.writeI64(self.id)
7507 
      oprot.writeFieldEnd()
7508 
    oprot.writeFieldStop()
7509 
    oprot.writeStructEnd()
7510 
 
3431 rajveer 7511 
  def validate(self):
7512 
    return
7513 
 
7514 
 
94 ashish 7515 
  def __repr__(self):
7516 
    L = ['%s=%r' % (key, value)
7517 
      for key, value in self.__dict__.iteritems()]
7518 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
7519 
 
7520 
  def __eq__(self, other):
7521 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
7522 
 
7523 
  def __ne__(self, other):
7524 
    return not (self == other)
7525 
 
7526 
class getTransaction_result:
7527 
  """
7528 
  Attributes:
7529 
   - success
7530 
   - ex
7531 
  """
7532 
 
7533 
  thrift_spec = (
7534 
    (0, TType.STRUCT, 'success', (Transaction, Transaction.thrift_spec), None, ), # 0
7535 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
7536 
  )
7537 
 
7538 
  def __init__(self, success=None, ex=None,):
7539 
    self.success = success
7540 
    self.ex = ex
7541 
 
7542 
  def read(self, iprot):
7543 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
7544 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
7545 
      return
7546 
    iprot.readStructBegin()
7547 
    while True:
7548 
      (fname, ftype, fid) = iprot.readFieldBegin()
7549 
      if ftype == TType.STOP:
7550 
        break
7551 
      if fid == 0:
7552 
        if ftype == TType.STRUCT:
7553 
          self.success = Transaction()
7554 
          self.success.read(iprot)
7555 
        else:
7556 
          iprot.skip(ftype)
7557 
      elif fid == 1:
7558 
        if ftype == TType.STRUCT:
7559 
          self.ex = TransactionServiceException()
7560 
          self.ex.read(iprot)
7561 
        else:
7562 
          iprot.skip(ftype)
7563 
      else:
7564 
        iprot.skip(ftype)
7565 
      iprot.readFieldEnd()
7566 
    iprot.readStructEnd()
7567 
 
7568 
  def write(self, oprot):
7569 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
7570 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
7571 
      return
7572 
    oprot.writeStructBegin('getTransaction_result')
3431 rajveer 7573 
    if self.success is not None:
94 ashish 7574 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
7575 
      self.success.write(oprot)
7576 
      oprot.writeFieldEnd()
3431 rajveer 7577 
    if self.ex is not None:
94 ashish 7578 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
7579 
      self.ex.write(oprot)
7580 
      oprot.writeFieldEnd()
7581 
    oprot.writeFieldStop()
7582 
    oprot.writeStructEnd()
7583 
 
3431 rajveer 7584 
  def validate(self):
7585 
    return
7586 
 
7587 
 
94 ashish 7588 
  def __repr__(self):
7589 
    L = ['%s=%r' % (key, value)
7590 
      for key, value in self.__dict__.iteritems()]
7591 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
7592 
 
7593 
  def __eq__(self, other):
7594 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
7595 
 
7596 
  def __ne__(self, other):
7597 
    return not (self == other)
7598 
 
7599 
class getTransactionsForCustomer_args:
7600 
  """
7601 
  Attributes:
7602 
   - customerId
7603 
   - from_date
7604 
   - to_date
7605 
   - status
7606 
  """
7607 
 
7608 
  thrift_spec = (
7609 
    None, # 0
7610 
    (1, TType.I64, 'customerId', None, None, ), # 1
7611 
    (2, TType.I64, 'from_date', None, None, ), # 2
7612 
    (3, TType.I64, 'to_date', None, None, ), # 3
7613 
    (4, TType.I32, 'status', None, None, ), # 4
7614 
  )
7615 
 
7616 
  def __init__(self, customerId=None, from_date=None, to_date=None, status=None,):
7617 
    self.customerId = customerId
7618 
    self.from_date = from_date
7619 
    self.to_date = to_date
7620 
    self.status = status
7621 
 
7622 
  def read(self, iprot):
7623 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
7624 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
7625 
      return
7626 
    iprot.readStructBegin()
7627 
    while True:
7628 
      (fname, ftype, fid) = iprot.readFieldBegin()
7629 
      if ftype == TType.STOP:
7630 
        break
7631 
      if fid == 1:
7632 
        if ftype == TType.I64:
7633 
          self.customerId = iprot.readI64();
7634 
        else:
7635 
          iprot.skip(ftype)
7636 
      elif fid == 2:
7637 
        if ftype == TType.I64:
7638 
          self.from_date = iprot.readI64();
7639 
        else:
7640 
          iprot.skip(ftype)
7641 
      elif fid == 3:
7642 
        if ftype == TType.I64:
7643 
          self.to_date = iprot.readI64();
7644 
        else:
7645 
          iprot.skip(ftype)
7646 
      elif fid == 4:
7647 
        if ftype == TType.I32:
7648 
          self.status = iprot.readI32();
7649 
        else:
7650 
          iprot.skip(ftype)
7651 
      else:
7652 
        iprot.skip(ftype)
7653 
      iprot.readFieldEnd()
7654 
    iprot.readStructEnd()
7655 
 
7656 
  def write(self, oprot):
7657 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
7658 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
7659 
      return
7660 
    oprot.writeStructBegin('getTransactionsForCustomer_args')
3431 rajveer 7661 
    if self.customerId is not None:
94 ashish 7662 
      oprot.writeFieldBegin('customerId', TType.I64, 1)
7663 
      oprot.writeI64(self.customerId)
7664 
      oprot.writeFieldEnd()
3431 rajveer 7665 
    if self.from_date is not None:
94 ashish 7666 
      oprot.writeFieldBegin('from_date', TType.I64, 2)
7667 
      oprot.writeI64(self.from_date)
7668 
      oprot.writeFieldEnd()
3431 rajveer 7669 
    if self.to_date is not None:
94 ashish 7670 
      oprot.writeFieldBegin('to_date', TType.I64, 3)
7671 
      oprot.writeI64(self.to_date)
7672 
      oprot.writeFieldEnd()
3431 rajveer 7673 
    if self.status is not None:
94 ashish 7674 
      oprot.writeFieldBegin('status', TType.I32, 4)
7675 
      oprot.writeI32(self.status)
7676 
      oprot.writeFieldEnd()
7677 
    oprot.writeFieldStop()
7678 
    oprot.writeStructEnd()
7679 
 
3431 rajveer 7680 
  def validate(self):
7681 
    return
7682 
 
7683 
 
94 ashish 7684 
  def __repr__(self):
7685 
    L = ['%s=%r' % (key, value)
7686 
      for key, value in self.__dict__.iteritems()]
7687 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
7688 
 
7689 
  def __eq__(self, other):
7690 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
7691 
 
7692 
  def __ne__(self, other):
7693 
    return not (self == other)
7694 
 
7695 
class getTransactionsForCustomer_result:
7696 
  """
7697 
  Attributes:
7698 
   - success
7699 
   - ex
7700 
  """
7701 
 
7702 
  thrift_spec = (
7703 
    (0, TType.LIST, 'success', (TType.STRUCT,(Transaction, Transaction.thrift_spec)), None, ), # 0
7704 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
7705 
  )
7706 
 
7707 
  def __init__(self, success=None, ex=None,):
7708 
    self.success = success
7709 
    self.ex = ex
7710 
 
7711 
  def read(self, iprot):
7712 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
7713 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
7714 
      return
7715 
    iprot.readStructBegin()
7716 
    while True:
7717 
      (fname, ftype, fid) = iprot.readFieldBegin()
7718 
      if ftype == TType.STOP:
7719 
        break
7720 
      if fid == 0:
7721 
        if ftype == TType.LIST:
7722 
          self.success = []
5031 varun.gupt 7723 
          (_etype66, _size63) = iprot.readListBegin()
7724 
          for _i67 in xrange(_size63):
7725 
            _elem68 = Transaction()
7726 
            _elem68.read(iprot)
7727 
            self.success.append(_elem68)
94 ashish 7728 
          iprot.readListEnd()
7729 
        else:
7730 
          iprot.skip(ftype)
7731 
      elif fid == 1:
7732 
        if ftype == TType.STRUCT:
7733 
          self.ex = TransactionServiceException()
7734 
          self.ex.read(iprot)
7735 
        else:
7736 
          iprot.skip(ftype)
7737 
      else:
7738 
        iprot.skip(ftype)
7739 
      iprot.readFieldEnd()
7740 
    iprot.readStructEnd()
7741 
 
7742 
  def write(self, oprot):
7743 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
7744 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
7745 
      return
7746 
    oprot.writeStructBegin('getTransactionsForCustomer_result')
3431 rajveer 7747 
    if self.success is not None:
94 ashish 7748 
      oprot.writeFieldBegin('success', TType.LIST, 0)
7749 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
5031 varun.gupt 7750 
      for iter69 in self.success:
7751 
        iter69.write(oprot)
94 ashish 7752 
      oprot.writeListEnd()
7753 
      oprot.writeFieldEnd()
3431 rajveer 7754 
    if self.ex is not None:
94 ashish 7755 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
7756 
      self.ex.write(oprot)
7757 
      oprot.writeFieldEnd()
7758 
    oprot.writeFieldStop()
7759 
    oprot.writeStructEnd()
7760 
 
3431 rajveer 7761 
  def validate(self):
7762 
    return
7763 
 
7764 
 
94 ashish 7765 
  def __repr__(self):
7766 
    L = ['%s=%r' % (key, value)
7767 
      for key, value in self.__dict__.iteritems()]
7768 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
7769 
 
7770 
  def __eq__(self, other):
7771 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
7772 
 
7773 
  def __ne__(self, other):
7774 
    return not (self == other)
7775 
 
132 ashish 7776 
class getTransactionsForShoppingCartId_args:
7777 
  """
7778 
  Attributes:
7779 
   - shoppingCartId
7780 
  """
7781 
 
7782 
  thrift_spec = (
7783 
    None, # 0
7784 
    (1, TType.I64, 'shoppingCartId', None, None, ), # 1
7785 
  )
7786 
 
7787 
  def __init__(self, shoppingCartId=None,):
7788 
    self.shoppingCartId = shoppingCartId
7789 
 
7790 
  def read(self, iprot):
7791 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
7792 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
7793 
      return
7794 
    iprot.readStructBegin()
7795 
    while True:
7796 
      (fname, ftype, fid) = iprot.readFieldBegin()
7797 
      if ftype == TType.STOP:
7798 
        break
7799 
      if fid == 1:
7800 
        if ftype == TType.I64:
7801 
          self.shoppingCartId = iprot.readI64();
7802 
        else:
7803 
          iprot.skip(ftype)
7804 
      else:
7805 
        iprot.skip(ftype)
7806 
      iprot.readFieldEnd()
7807 
    iprot.readStructEnd()
7808 
 
7809 
  def write(self, oprot):
7810 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
7811 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
7812 
      return
7813 
    oprot.writeStructBegin('getTransactionsForShoppingCartId_args')
3431 rajveer 7814 
    if self.shoppingCartId is not None:
132 ashish 7815 
      oprot.writeFieldBegin('shoppingCartId', TType.I64, 1)
7816 
      oprot.writeI64(self.shoppingCartId)
7817 
      oprot.writeFieldEnd()
7818 
    oprot.writeFieldStop()
7819 
    oprot.writeStructEnd()
7820 
 
3431 rajveer 7821 
  def validate(self):
7822 
    return
7823 
 
7824 
 
132 ashish 7825 
  def __repr__(self):
7826 
    L = ['%s=%r' % (key, value)
7827 
      for key, value in self.__dict__.iteritems()]
7828 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
7829 
 
7830 
  def __eq__(self, other):
7831 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
7832 
 
7833 
  def __ne__(self, other):
7834 
    return not (self == other)
7835 
 
7836 
class getTransactionsForShoppingCartId_result:
7837 
  """
7838 
  Attributes:
7839 
   - success
7840 
   - ex
7841 
  """
7842 
 
7843 
  thrift_spec = (
7844 
    (0, TType.LIST, 'success', (TType.STRUCT,(Transaction, Transaction.thrift_spec)), None, ), # 0
7845 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
7846 
  )
7847 
 
7848 
  def __init__(self, success=None, ex=None,):
7849 
    self.success = success
7850 
    self.ex = ex
7851 
 
7852 
  def read(self, iprot):
7853 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
7854 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
7855 
      return
7856 
    iprot.readStructBegin()
7857 
    while True:
7858 
      (fname, ftype, fid) = iprot.readFieldBegin()
7859 
      if ftype == TType.STOP:
7860 
        break
7861 
      if fid == 0:
7862 
        if ftype == TType.LIST:
7863 
          self.success = []
5031 varun.gupt 7864 
          (_etype73, _size70) = iprot.readListBegin()
7865 
          for _i74 in xrange(_size70):
7866 
            _elem75 = Transaction()
7867 
            _elem75.read(iprot)
7868 
            self.success.append(_elem75)
132 ashish 7869 
          iprot.readListEnd()
7870 
        else:
7871 
          iprot.skip(ftype)
7872 
      elif fid == 1:
7873 
        if ftype == TType.STRUCT:
7874 
          self.ex = TransactionServiceException()
7875 
          self.ex.read(iprot)
7876 
        else:
7877 
          iprot.skip(ftype)
7878 
      else:
7879 
        iprot.skip(ftype)
7880 
      iprot.readFieldEnd()
7881 
    iprot.readStructEnd()
7882 
 
7883 
  def write(self, oprot):
7884 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
7885 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
7886 
      return
7887 
    oprot.writeStructBegin('getTransactionsForShoppingCartId_result')
3431 rajveer 7888 
    if self.success is not None:
132 ashish 7889 
      oprot.writeFieldBegin('success', TType.LIST, 0)
7890 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
5031 varun.gupt 7891 
      for iter76 in self.success:
7892 
        iter76.write(oprot)
132 ashish 7893 
      oprot.writeListEnd()
7894 
      oprot.writeFieldEnd()
3431 rajveer 7895 
    if self.ex is not None:
132 ashish 7896 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
7897 
      self.ex.write(oprot)
7898 
      oprot.writeFieldEnd()
7899 
    oprot.writeFieldStop()
7900 
    oprot.writeStructEnd()
7901 
 
3431 rajveer 7902 
  def validate(self):
7903 
    return
7904 
 
7905 
 
132 ashish 7906 
  def __repr__(self):
7907 
    L = ['%s=%r' % (key, value)
7908 
      for key, value in self.__dict__.iteritems()]
7909 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
7910 
 
7911 
  def __eq__(self, other):
7912 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
7913 
 
7914 
  def __ne__(self, other):
7915 
    return not (self == other)
7916 
 
94 ashish 7917 
class getTransactionStatus_args:
7918 
  """
7919 
  Attributes:
7920 
   - transactionId
7921 
  """
7922 
 
7923 
  thrift_spec = (
7924 
    None, # 0
7925 
    (1, TType.I64, 'transactionId', None, None, ), # 1
7926 
  )
7927 
 
7928 
  def __init__(self, transactionId=None,):
7929 
    self.transactionId = transactionId
7930 
 
7931 
  def read(self, iprot):
7932 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
7933 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
7934 
      return
7935 
    iprot.readStructBegin()
7936 
    while True:
7937 
      (fname, ftype, fid) = iprot.readFieldBegin()
7938 
      if ftype == TType.STOP:
7939 
        break
7940 
      if fid == 1:
7941 
        if ftype == TType.I64:
7942 
          self.transactionId = iprot.readI64();
7943 
        else:
7944 
          iprot.skip(ftype)
7945 
      else:
7946 
        iprot.skip(ftype)
7947 
      iprot.readFieldEnd()
7948 
    iprot.readStructEnd()
7949 
 
7950 
  def write(self, oprot):
7951 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
7952 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
7953 
      return
7954 
    oprot.writeStructBegin('getTransactionStatus_args')
3431 rajveer 7955 
    if self.transactionId is not None:
94 ashish 7956 
      oprot.writeFieldBegin('transactionId', TType.I64, 1)
7957 
      oprot.writeI64(self.transactionId)
7958 
      oprot.writeFieldEnd()
7959 
    oprot.writeFieldStop()
7960 
    oprot.writeStructEnd()
7961 
 
3431 rajveer 7962 
  def validate(self):
7963 
    return
7964 
 
7965 
 
94 ashish 7966 
  def __repr__(self):
7967 
    L = ['%s=%r' % (key, value)
7968 
      for key, value in self.__dict__.iteritems()]
7969 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
7970 
 
7971 
  def __eq__(self, other):
7972 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
7973 
 
7974 
  def __ne__(self, other):
7975 
    return not (self == other)
7976 
 
7977 
class getTransactionStatus_result:
7978 
  """
7979 
  Attributes:
7980 
   - success
7981 
   - ex
7982 
  """
7983 
 
7984 
  thrift_spec = (
7985 
    (0, TType.I32, 'success', None, None, ), # 0
7986 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
7987 
  )
7988 
 
7989 
  def __init__(self, success=None, ex=None,):
7990 
    self.success = success
7991 
    self.ex = ex
7992 
 
7993 
  def read(self, iprot):
7994 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
7995 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
7996 
      return
7997 
    iprot.readStructBegin()
7998 
    while True:
7999 
      (fname, ftype, fid) = iprot.readFieldBegin()
8000 
      if ftype == TType.STOP:
8001 
        break
8002 
      if fid == 0:
8003 
        if ftype == TType.I32:
8004 
          self.success = iprot.readI32();
8005 
        else:
8006 
          iprot.skip(ftype)
8007 
      elif fid == 1:
8008 
        if ftype == TType.STRUCT:
8009 
          self.ex = TransactionServiceException()
8010 
          self.ex.read(iprot)
8011 
        else:
8012 
          iprot.skip(ftype)
8013 
      else:
8014 
        iprot.skip(ftype)
8015 
      iprot.readFieldEnd()
8016 
    iprot.readStructEnd()
8017 
 
8018 
  def write(self, oprot):
8019 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8020 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8021 
      return
8022 
    oprot.writeStructBegin('getTransactionStatus_result')
3431 rajveer 8023 
    if self.success is not None:
94 ashish 8024 
      oprot.writeFieldBegin('success', TType.I32, 0)
8025 
      oprot.writeI32(self.success)
8026 
      oprot.writeFieldEnd()
3431 rajveer 8027 
    if self.ex is not None:
94 ashish 8028 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
8029 
      self.ex.write(oprot)
8030 
      oprot.writeFieldEnd()
8031 
    oprot.writeFieldStop()
8032 
    oprot.writeStructEnd()
8033 
 
3431 rajveer 8034 
  def validate(self):
8035 
    return
8036 
 
8037 
 
94 ashish 8038 
  def __repr__(self):
8039 
    L = ['%s=%r' % (key, value)
8040 
      for key, value in self.__dict__.iteritems()]
8041 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8042 
 
8043 
  def __eq__(self, other):
8044 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8045 
 
8046 
  def __ne__(self, other):
8047 
    return not (self == other)
8048 
 
8049 
class changeTransactionStatus_args:
8050 
  """
8051 
  Attributes:
8052 
   - transactionId
8053 
   - status
8054 
   - description
5527 anupam.sin 8055 
   - pickUp
8056 
   - orderType
94 ashish 8057 
  """
8058 
 
8059 
  thrift_spec = (
8060 
    None, # 0
8061 
    (1, TType.I64, 'transactionId', None, None, ), # 1
8062 
    (2, TType.I32, 'status', None, None, ), # 2
8063 
    (3, TType.STRING, 'description', None, None, ), # 3
5527 anupam.sin 8064 
    (4, TType.I64, 'pickUp', None, None, ), # 4
8065 
    (5, TType.I32, 'orderType', None, None, ), # 5
94 ashish 8066 
  )
8067 
 
5527 anupam.sin 8068 
  def __init__(self, transactionId=None, status=None, description=None, pickUp=None, orderType=None,):
94 ashish 8069 
    self.transactionId = transactionId
8070 
    self.status = status
8071 
    self.description = description
5527 anupam.sin 8072 
    self.pickUp = pickUp
8073 
    self.orderType = orderType
94 ashish 8074 
 
8075 
  def read(self, iprot):
8076 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8077 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8078 
      return
8079 
    iprot.readStructBegin()
8080 
    while True:
8081 
      (fname, ftype, fid) = iprot.readFieldBegin()
8082 
      if ftype == TType.STOP:
8083 
        break
8084 
      if fid == 1:
8085 
        if ftype == TType.I64:
8086 
          self.transactionId = iprot.readI64();
8087 
        else:
8088 
          iprot.skip(ftype)
8089 
      elif fid == 2:
8090 
        if ftype == TType.I32:
8091 
          self.status = iprot.readI32();
8092 
        else:
8093 
          iprot.skip(ftype)
8094 
      elif fid == 3:
8095 
        if ftype == TType.STRING:
8096 
          self.description = iprot.readString();
8097 
        else:
8098 
          iprot.skip(ftype)
5387 rajveer 8099 
      elif fid == 4:
5527 anupam.sin 8100 
        if ftype == TType.I64:
8101 
          self.pickUp = iprot.readI64();
5387 rajveer 8102 
        else:
8103 
          iprot.skip(ftype)
5527 anupam.sin 8104 
      elif fid == 5:
8105 
        if ftype == TType.I32:
8106 
          self.orderType = iprot.readI32();
8107 
        else:
8108 
          iprot.skip(ftype)
94 ashish 8109 
      else:
8110 
        iprot.skip(ftype)
8111 
      iprot.readFieldEnd()
8112 
    iprot.readStructEnd()
8113 
 
8114 
  def write(self, oprot):
8115 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8116 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8117 
      return
8118 
    oprot.writeStructBegin('changeTransactionStatus_args')
3431 rajveer 8119 
    if self.transactionId is not None:
94 ashish 8120 
      oprot.writeFieldBegin('transactionId', TType.I64, 1)
8121 
      oprot.writeI64(self.transactionId)
8122 
      oprot.writeFieldEnd()
3431 rajveer 8123 
    if self.status is not None:
94 ashish 8124 
      oprot.writeFieldBegin('status', TType.I32, 2)
8125 
      oprot.writeI32(self.status)
8126 
      oprot.writeFieldEnd()
3431 rajveer 8127 
    if self.description is not None:
94 ashish 8128 
      oprot.writeFieldBegin('description', TType.STRING, 3)
8129 
      oprot.writeString(self.description)
8130 
      oprot.writeFieldEnd()
5527 anupam.sin 8131 
    if self.pickUp is not None:
8132 
      oprot.writeFieldBegin('pickUp', TType.I64, 4)
8133 
      oprot.writeI64(self.pickUp)
5387 rajveer 8134 
      oprot.writeFieldEnd()
5527 anupam.sin 8135 
    if self.orderType is not None:
8136 
      oprot.writeFieldBegin('orderType', TType.I32, 5)
8137 
      oprot.writeI32(self.orderType)
8138 
      oprot.writeFieldEnd()
94 ashish 8139 
    oprot.writeFieldStop()
8140 
    oprot.writeStructEnd()
8141 
 
3431 rajveer 8142 
  def validate(self):
8143 
    return
8144 
 
8145 
 
94 ashish 8146 
  def __repr__(self):
8147 
    L = ['%s=%r' % (key, value)
8148 
      for key, value in self.__dict__.iteritems()]
8149 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8150 
 
8151 
  def __eq__(self, other):
8152 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8153 
 
8154 
  def __ne__(self, other):
8155 
    return not (self == other)
8156 
 
8157 
class changeTransactionStatus_result:
8158 
  """
8159 
  Attributes:
8160 
   - success
8161 
   - ex
8162 
  """
8163 
 
8164 
  thrift_spec = (
8165 
    (0, TType.BOOL, 'success', None, None, ), # 0
8166 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
8167 
  )
8168 
 
8169 
  def __init__(self, success=None, ex=None,):
8170 
    self.success = success
8171 
    self.ex = ex
8172 
 
8173 
  def read(self, iprot):
8174 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8175 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8176 
      return
8177 
    iprot.readStructBegin()
8178 
    while True:
8179 
      (fname, ftype, fid) = iprot.readFieldBegin()
8180 
      if ftype == TType.STOP:
8181 
        break
8182 
      if fid == 0:
8183 
        if ftype == TType.BOOL:
8184 
          self.success = iprot.readBool();
8185 
        else:
8186 
          iprot.skip(ftype)
8187 
      elif fid == 1:
8188 
        if ftype == TType.STRUCT:
8189 
          self.ex = TransactionServiceException()
8190 
          self.ex.read(iprot)
8191 
        else:
8192 
          iprot.skip(ftype)
8193 
      else:
8194 
        iprot.skip(ftype)
8195 
      iprot.readFieldEnd()
8196 
    iprot.readStructEnd()
8197 
 
8198 
  def write(self, oprot):
8199 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8200 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8201 
      return
8202 
    oprot.writeStructBegin('changeTransactionStatus_result')
3431 rajveer 8203 
    if self.success is not None:
94 ashish 8204 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
8205 
      oprot.writeBool(self.success)
8206 
      oprot.writeFieldEnd()
3431 rajveer 8207 
    if self.ex is not None:
94 ashish 8208 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
8209 
      self.ex.write(oprot)
8210 
      oprot.writeFieldEnd()
8211 
    oprot.writeFieldStop()
8212 
    oprot.writeStructEnd()
8213 
 
3431 rajveer 8214 
  def validate(self):
8215 
    return
8216 
 
8217 
 
94 ashish 8218 
  def __repr__(self):
8219 
    L = ['%s=%r' % (key, value)
8220 
      for key, value in self.__dict__.iteritems()]
8221 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8222 
 
8223 
  def __eq__(self, other):
8224 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8225 
 
8226 
  def __ne__(self, other):
8227 
    return not (self == other)
8228 
 
1398 varun.gupt 8229 
class enqueueTransactionInfoEmail_args:
1382 varun.gupt 8230 
  """
8231 
  Attributes:
8232 
   - transactionId
8233 
  """
8234 
 
8235 
  thrift_spec = (
8236 
    None, # 0
8237 
    (1, TType.I64, 'transactionId', None, None, ), # 1
8238 
  )
8239 
 
8240 
  def __init__(self, transactionId=None,):
8241 
    self.transactionId = transactionId
8242 
 
8243 
  def read(self, iprot):
8244 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8245 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8246 
      return
8247 
    iprot.readStructBegin()
8248 
    while True:
8249 
      (fname, ftype, fid) = iprot.readFieldBegin()
8250 
      if ftype == TType.STOP:
8251 
        break
8252 
      if fid == 1:
8253 
        if ftype == TType.I64:
8254 
          self.transactionId = iprot.readI64();
8255 
        else:
8256 
          iprot.skip(ftype)
8257 
      else:
8258 
        iprot.skip(ftype)
8259 
      iprot.readFieldEnd()
8260 
    iprot.readStructEnd()
8261 
 
8262 
  def write(self, oprot):
8263 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8264 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8265 
      return
1398 varun.gupt 8266 
    oprot.writeStructBegin('enqueueTransactionInfoEmail_args')
3431 rajveer 8267 
    if self.transactionId is not None:
1382 varun.gupt 8268 
      oprot.writeFieldBegin('transactionId', TType.I64, 1)
8269 
      oprot.writeI64(self.transactionId)
8270 
      oprot.writeFieldEnd()
8271 
    oprot.writeFieldStop()
8272 
    oprot.writeStructEnd()
8273 
 
3431 rajveer 8274 
  def validate(self):
8275 
    return
8276 
 
8277 
 
1382 varun.gupt 8278 
  def __repr__(self):
8279 
    L = ['%s=%r' % (key, value)
8280 
      for key, value in self.__dict__.iteritems()]
8281 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8282 
 
8283 
  def __eq__(self, other):
8284 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8285 
 
8286 
  def __ne__(self, other):
8287 
    return not (self == other)
8288 
 
1398 varun.gupt 8289 
class enqueueTransactionInfoEmail_result:
1382 varun.gupt 8290 
  """
8291 
  Attributes:
8292 
   - success
8293 
   - ex
8294 
  """
8295 
 
8296 
  thrift_spec = (
8297 
    (0, TType.BOOL, 'success', None, None, ), # 0
8298 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
8299 
  )
8300 
 
8301 
  def __init__(self, success=None, ex=None,):
8302 
    self.success = success
8303 
    self.ex = ex
8304 
 
8305 
  def read(self, iprot):
8306 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8307 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8308 
      return
8309 
    iprot.readStructBegin()
8310 
    while True:
8311 
      (fname, ftype, fid) = iprot.readFieldBegin()
8312 
      if ftype == TType.STOP:
8313 
        break
8314 
      if fid == 0:
8315 
        if ftype == TType.BOOL:
8316 
          self.success = iprot.readBool();
8317 
        else:
8318 
          iprot.skip(ftype)
8319 
      elif fid == 1:
8320 
        if ftype == TType.STRUCT:
8321 
          self.ex = TransactionServiceException()
8322 
          self.ex.read(iprot)
8323 
        else:
8324 
          iprot.skip(ftype)
8325 
      else:
8326 
        iprot.skip(ftype)
8327 
      iprot.readFieldEnd()
8328 
    iprot.readStructEnd()
8329 
 
8330 
  def write(self, oprot):
8331 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8332 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8333 
      return
1398 varun.gupt 8334 
    oprot.writeStructBegin('enqueueTransactionInfoEmail_result')
3431 rajveer 8335 
    if self.success is not None:
1382 varun.gupt 8336 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
8337 
      oprot.writeBool(self.success)
8338 
      oprot.writeFieldEnd()
3431 rajveer 8339 
    if self.ex is not None:
1382 varun.gupt 8340 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
8341 
      self.ex.write(oprot)
8342 
      oprot.writeFieldEnd()
8343 
    oprot.writeFieldStop()
8344 
    oprot.writeStructEnd()
8345 
 
3431 rajveer 8346 
  def validate(self):
8347 
    return
8348 
 
8349 
 
1382 varun.gupt 8350 
  def __repr__(self):
8351 
    L = ['%s=%r' % (key, value)
8352 
      for key, value in self.__dict__.iteritems()]
8353 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8354 
 
8355 
  def __eq__(self, other):
8356 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8357 
 
8358 
  def __ne__(self, other):
8359 
    return not (self == other)
8360 
 
483 rajveer 8361 
class getAllOrders_args:
94 ashish 8362 
  """
8363 
  Attributes:
4801 anupam.sin 8364 
   - statuses
483 rajveer 8365 
   - from_date
8366 
   - to_date
8367 
   - warehouse_id
94 ashish 8368 
  """
8369 
 
8370 
  thrift_spec = (
8371 
    None, # 0
4801 anupam.sin 8372 
    (1, TType.LIST, 'statuses', (TType.I32,None), None, ), # 1
483 rajveer 8373 
    (2, TType.I64, 'from_date', None, None, ), # 2
8374 
    (3, TType.I64, 'to_date', None, None, ), # 3
8375 
    (4, TType.I64, 'warehouse_id', None, None, ), # 4
94 ashish 8376 
  )
8377 
 
4801 anupam.sin 8378 
  def __init__(self, statuses=None, from_date=None, to_date=None, warehouse_id=None,):
8379 
    self.statuses = statuses
483 rajveer 8380 
    self.from_date = from_date
8381 
    self.to_date = to_date
8382 
    self.warehouse_id = warehouse_id
94 ashish 8383 
 
8384 
  def read(self, iprot):
8385 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8386 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8387 
      return
8388 
    iprot.readStructBegin()
8389 
    while True:
8390 
      (fname, ftype, fid) = iprot.readFieldBegin()
8391 
      if ftype == TType.STOP:
8392 
        break
8393 
      if fid == 1:
4801 anupam.sin 8394 
        if ftype == TType.LIST:
8395 
          self.statuses = []
5031 varun.gupt 8396 
          (_etype80, _size77) = iprot.readListBegin()
8397 
          for _i81 in xrange(_size77):
8398 
            _elem82 = iprot.readI32();
8399 
            self.statuses.append(_elem82)
4801 anupam.sin 8400 
          iprot.readListEnd()
94 ashish 8401 
        else:
8402 
          iprot.skip(ftype)
483 rajveer 8403 
      elif fid == 2:
8404 
        if ftype == TType.I64:
8405 
          self.from_date = iprot.readI64();
94 ashish 8406 
        else:
8407 
          iprot.skip(ftype)
483 rajveer 8408 
      elif fid == 3:
8409 
        if ftype == TType.I64:
8410 
          self.to_date = iprot.readI64();
94 ashish 8411 
        else:
8412 
          iprot.skip(ftype)
483 rajveer 8413 
      elif fid == 4:
94 ashish 8414 
        if ftype == TType.I64:
483 rajveer 8415 
          self.warehouse_id = iprot.readI64();
94 ashish 8416 
        else:
8417 
          iprot.skip(ftype)
8418 
      else:
8419 
        iprot.skip(ftype)
8420 
      iprot.readFieldEnd()
8421 
    iprot.readStructEnd()
8422 
 
8423 
  def write(self, oprot):
8424 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8425 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8426 
      return
483 rajveer 8427 
    oprot.writeStructBegin('getAllOrders_args')
4801 anupam.sin 8428 
    if self.statuses is not None:
8429 
      oprot.writeFieldBegin('statuses', TType.LIST, 1)
8430 
      oprot.writeListBegin(TType.I32, len(self.statuses))
5031 varun.gupt 8431 
      for iter83 in self.statuses:
8432 
        oprot.writeI32(iter83)
4801 anupam.sin 8433 
      oprot.writeListEnd()
94 ashish 8434 
      oprot.writeFieldEnd()
3431 rajveer 8435 
    if self.from_date is not None:
483 rajveer 8436 
      oprot.writeFieldBegin('from_date', TType.I64, 2)
8437 
      oprot.writeI64(self.from_date)
94 ashish 8438 
      oprot.writeFieldEnd()
3431 rajveer 8439 
    if self.to_date is not None:
483 rajveer 8440 
      oprot.writeFieldBegin('to_date', TType.I64, 3)
8441 
      oprot.writeI64(self.to_date)
94 ashish 8442 
      oprot.writeFieldEnd()
3431 rajveer 8443 
    if self.warehouse_id is not None:
483 rajveer 8444 
      oprot.writeFieldBegin('warehouse_id', TType.I64, 4)
8445 
      oprot.writeI64(self.warehouse_id)
94 ashish 8446 
      oprot.writeFieldEnd()
8447 
    oprot.writeFieldStop()
8448 
    oprot.writeStructEnd()
8449 
 
3431 rajveer 8450 
  def validate(self):
8451 
    return
8452 
 
8453 
 
94 ashish 8454 
  def __repr__(self):
8455 
    L = ['%s=%r' % (key, value)
8456 
      for key, value in self.__dict__.iteritems()]
8457 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8458 
 
8459 
  def __eq__(self, other):
8460 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8461 
 
8462 
  def __ne__(self, other):
8463 
    return not (self == other)
8464 
 
483 rajveer 8465 
class getAllOrders_result:
94 ashish 8466 
  """
8467 
  Attributes:
8468 
   - success
8469 
   - ex
8470 
  """
8471 
 
8472 
  thrift_spec = (
483 rajveer 8473 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
94 ashish 8474 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
8475 
  )
8476 
 
8477 
  def __init__(self, success=None, ex=None,):
8478 
    self.success = success
8479 
    self.ex = ex
8480 
 
8481 
  def read(self, iprot):
8482 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8483 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8484 
      return
8485 
    iprot.readStructBegin()
8486 
    while True:
8487 
      (fname, ftype, fid) = iprot.readFieldBegin()
8488 
      if ftype == TType.STOP:
8489 
        break
8490 
      if fid == 0:
483 rajveer 8491 
        if ftype == TType.LIST:
8492 
          self.success = []
5031 varun.gupt 8493 
          (_etype87, _size84) = iprot.readListBegin()
8494 
          for _i88 in xrange(_size84):
8495 
            _elem89 = Order()
8496 
            _elem89.read(iprot)
8497 
            self.success.append(_elem89)
483 rajveer 8498 
          iprot.readListEnd()
94 ashish 8499 
        else:
8500 
          iprot.skip(ftype)
8501 
      elif fid == 1:
8502 
        if ftype == TType.STRUCT:
8503 
          self.ex = TransactionServiceException()
8504 
          self.ex.read(iprot)
8505 
        else:
8506 
          iprot.skip(ftype)
8507 
      else:
8508 
        iprot.skip(ftype)
8509 
      iprot.readFieldEnd()
8510 
    iprot.readStructEnd()
8511 
 
8512 
  def write(self, oprot):
8513 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8514 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8515 
      return
483 rajveer 8516 
    oprot.writeStructBegin('getAllOrders_result')
3431 rajveer 8517 
    if self.success is not None:
483 rajveer 8518 
      oprot.writeFieldBegin('success', TType.LIST, 0)
8519 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
5031 varun.gupt 8520 
      for iter90 in self.success:
8521 
        iter90.write(oprot)
483 rajveer 8522 
      oprot.writeListEnd()
94 ashish 8523 
      oprot.writeFieldEnd()
3431 rajveer 8524 
    if self.ex is not None:
94 ashish 8525 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
8526 
      self.ex.write(oprot)
8527 
      oprot.writeFieldEnd()
8528 
    oprot.writeFieldStop()
8529 
    oprot.writeStructEnd()
8530 
 
3431 rajveer 8531 
  def validate(self):
8532 
    return
8533 
 
8534 
 
94 ashish 8535 
  def __repr__(self):
8536 
    L = ['%s=%r' % (key, value)
8537 
      for key, value in self.__dict__.iteritems()]
8538 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8539 
 
8540 
  def __eq__(self, other):
8541 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8542 
 
8543 
  def __ne__(self, other):
8544 
    return not (self == other)
8545 
 
4133 chandransh 8546 
class getOrdersInBatch_args:
8547 
  """
8548 
  Attributes:
8549 
   - statuses
8550 
   - offset
8551 
   - limit
8552 
   - warehouse_id
8553 
  """
8554 
 
8555 
  thrift_spec = (
8556 
    None, # 0
8557 
    (1, TType.LIST, 'statuses', (TType.I32,None), None, ), # 1
8558 
    (2, TType.I64, 'offset', None, None, ), # 2
8559 
    (3, TType.I64, 'limit', None, None, ), # 3
8560 
    (4, TType.I64, 'warehouse_id', None, None, ), # 4
8561 
  )
8562 
 
8563 
  def __init__(self, statuses=None, offset=None, limit=None, warehouse_id=None,):
8564 
    self.statuses = statuses
8565 
    self.offset = offset
8566 
    self.limit = limit
8567 
    self.warehouse_id = warehouse_id
8568 
 
8569 
  def read(self, iprot):
8570 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8571 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8572 
      return
8573 
    iprot.readStructBegin()
8574 
    while True:
8575 
      (fname, ftype, fid) = iprot.readFieldBegin()
8576 
      if ftype == TType.STOP:
8577 
        break
8578 
      if fid == 1:
8579 
        if ftype == TType.LIST:
8580 
          self.statuses = []
5031 varun.gupt 8581 
          (_etype94, _size91) = iprot.readListBegin()
8582 
          for _i95 in xrange(_size91):
8583 
            _elem96 = iprot.readI32();
8584 
            self.statuses.append(_elem96)
4133 chandransh 8585 
          iprot.readListEnd()
8586 
        else:
8587 
          iprot.skip(ftype)
8588 
      elif fid == 2:
8589 
        if ftype == TType.I64:
8590 
          self.offset = iprot.readI64();
8591 
        else:
8592 
          iprot.skip(ftype)
8593 
      elif fid == 3:
8594 
        if ftype == TType.I64:
8595 
          self.limit = iprot.readI64();
8596 
        else:
8597 
          iprot.skip(ftype)
8598 
      elif fid == 4:
8599 
        if ftype == TType.I64:
8600 
          self.warehouse_id = iprot.readI64();
8601 
        else:
8602 
          iprot.skip(ftype)
8603 
      else:
8604 
        iprot.skip(ftype)
8605 
      iprot.readFieldEnd()
8606 
    iprot.readStructEnd()
8607 
 
8608 
  def write(self, oprot):
8609 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8610 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8611 
      return
8612 
    oprot.writeStructBegin('getOrdersInBatch_args')
8613 
    if self.statuses is not None:
8614 
      oprot.writeFieldBegin('statuses', TType.LIST, 1)
8615 
      oprot.writeListBegin(TType.I32, len(self.statuses))
5031 varun.gupt 8616 
      for iter97 in self.statuses:
8617 
        oprot.writeI32(iter97)
4133 chandransh 8618 
      oprot.writeListEnd()
8619 
      oprot.writeFieldEnd()
8620 
    if self.offset is not None:
8621 
      oprot.writeFieldBegin('offset', TType.I64, 2)
8622 
      oprot.writeI64(self.offset)
8623 
      oprot.writeFieldEnd()
8624 
    if self.limit is not None:
8625 
      oprot.writeFieldBegin('limit', TType.I64, 3)
8626 
      oprot.writeI64(self.limit)
8627 
      oprot.writeFieldEnd()
8628 
    if self.warehouse_id is not None:
8629 
      oprot.writeFieldBegin('warehouse_id', TType.I64, 4)
8630 
      oprot.writeI64(self.warehouse_id)
8631 
      oprot.writeFieldEnd()
8632 
    oprot.writeFieldStop()
8633 
    oprot.writeStructEnd()
8634 
 
8635 
  def validate(self):
8636 
    return
8637 
 
8638 
 
8639 
  def __repr__(self):
8640 
    L = ['%s=%r' % (key, value)
8641 
      for key, value in self.__dict__.iteritems()]
8642 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8643 
 
8644 
  def __eq__(self, other):
8645 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8646 
 
8647 
  def __ne__(self, other):
8648 
    return not (self == other)
8649 
 
8650 
class getOrdersInBatch_result:
8651 
  """
8652 
  Attributes:
8653 
   - success
8654 
   - ex
8655 
  """
8656 
 
8657 
  thrift_spec = (
8658 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
8659 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
8660 
  )
8661 
 
8662 
  def __init__(self, success=None, ex=None,):
8663 
    self.success = success
8664 
    self.ex = ex
8665 
 
8666 
  def read(self, iprot):
8667 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8668 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8669 
      return
8670 
    iprot.readStructBegin()
8671 
    while True:
8672 
      (fname, ftype, fid) = iprot.readFieldBegin()
8673 
      if ftype == TType.STOP:
8674 
        break
8675 
      if fid == 0:
8676 
        if ftype == TType.LIST:
8677 
          self.success = []
5031 varun.gupt 8678 
          (_etype101, _size98) = iprot.readListBegin()
8679 
          for _i102 in xrange(_size98):
8680 
            _elem103 = Order()
8681 
            _elem103.read(iprot)
8682 
            self.success.append(_elem103)
4133 chandransh 8683 
          iprot.readListEnd()
8684 
        else:
8685 
          iprot.skip(ftype)
8686 
      elif fid == 1:
8687 
        if ftype == TType.STRUCT:
8688 
          self.ex = TransactionServiceException()
8689 
          self.ex.read(iprot)
8690 
        else:
8691 
          iprot.skip(ftype)
8692 
      else:
8693 
        iprot.skip(ftype)
8694 
      iprot.readFieldEnd()
8695 
    iprot.readStructEnd()
8696 
 
8697 
  def write(self, oprot):
8698 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8699 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8700 
      return
8701 
    oprot.writeStructBegin('getOrdersInBatch_result')
8702 
    if self.success is not None:
8703 
      oprot.writeFieldBegin('success', TType.LIST, 0)
8704 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
5031 varun.gupt 8705 
      for iter104 in self.success:
8706 
        iter104.write(oprot)
4133 chandransh 8707 
      oprot.writeListEnd()
8708 
      oprot.writeFieldEnd()
8709 
    if self.ex is not None:
8710 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
8711 
      self.ex.write(oprot)
8712 
      oprot.writeFieldEnd()
8713 
    oprot.writeFieldStop()
8714 
    oprot.writeStructEnd()
8715 
 
8716 
  def validate(self):
8717 
    return
8718 
 
8719 
 
8720 
  def __repr__(self):
8721 
    L = ['%s=%r' % (key, value)
8722 
      for key, value in self.__dict__.iteritems()]
8723 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8724 
 
8725 
  def __eq__(self, other):
8726 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8727 
 
8728 
  def __ne__(self, other):
8729 
    return not (self == other)
8730 
 
8731 
class getOrderCount_args:
8732 
  """
8733 
  Attributes:
8734 
   - statuses
8735 
   - warehouseId
8736 
  """
8737 
 
8738 
  thrift_spec = (
8739 
    None, # 0
8740 
    (1, TType.LIST, 'statuses', (TType.I32,None), None, ), # 1
8741 
    (2, TType.I64, 'warehouseId', None, None, ), # 2
8742 
  )
8743 
 
8744 
  def __init__(self, statuses=None, warehouseId=None,):
8745 
    self.statuses = statuses
8746 
    self.warehouseId = warehouseId
8747 
 
8748 
  def read(self, iprot):
8749 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8750 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8751 
      return
8752 
    iprot.readStructBegin()
8753 
    while True:
8754 
      (fname, ftype, fid) = iprot.readFieldBegin()
8755 
      if ftype == TType.STOP:
8756 
        break
8757 
      if fid == 1:
8758 
        if ftype == TType.LIST:
8759 
          self.statuses = []
5031 varun.gupt 8760 
          (_etype108, _size105) = iprot.readListBegin()
8761 
          for _i109 in xrange(_size105):
8762 
            _elem110 = iprot.readI32();
8763 
            self.statuses.append(_elem110)
4133 chandransh 8764 
          iprot.readListEnd()
8765 
        else:
8766 
          iprot.skip(ftype)
8767 
      elif fid == 2:
8768 
        if ftype == TType.I64:
8769 
          self.warehouseId = iprot.readI64();
8770 
        else:
8771 
          iprot.skip(ftype)
8772 
      else:
8773 
        iprot.skip(ftype)
8774 
      iprot.readFieldEnd()
8775 
    iprot.readStructEnd()
8776 
 
8777 
  def write(self, oprot):
8778 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8779 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8780 
      return
8781 
    oprot.writeStructBegin('getOrderCount_args')
8782 
    if self.statuses is not None:
8783 
      oprot.writeFieldBegin('statuses', TType.LIST, 1)
8784 
      oprot.writeListBegin(TType.I32, len(self.statuses))
5031 varun.gupt 8785 
      for iter111 in self.statuses:
8786 
        oprot.writeI32(iter111)
4133 chandransh 8787 
      oprot.writeListEnd()
8788 
      oprot.writeFieldEnd()
8789 
    if self.warehouseId is not None:
8790 
      oprot.writeFieldBegin('warehouseId', TType.I64, 2)
8791 
      oprot.writeI64(self.warehouseId)
8792 
      oprot.writeFieldEnd()
8793 
    oprot.writeFieldStop()
8794 
    oprot.writeStructEnd()
8795 
 
8796 
  def validate(self):
8797 
    return
8798 
 
8799 
 
8800 
  def __repr__(self):
8801 
    L = ['%s=%r' % (key, value)
8802 
      for key, value in self.__dict__.iteritems()]
8803 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8804 
 
8805 
  def __eq__(self, other):
8806 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8807 
 
8808 
  def __ne__(self, other):
8809 
    return not (self == other)
8810 
 
8811 
class getOrderCount_result:
8812 
  """
8813 
  Attributes:
8814 
   - success
8815 
   - ex
8816 
  """
8817 
 
8818 
  thrift_spec = (
8819 
    (0, TType.I32, 'success', None, None, ), # 0
8820 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
8821 
  )
8822 
 
8823 
  def __init__(self, success=None, ex=None,):
8824 
    self.success = success
8825 
    self.ex = ex
8826 
 
8827 
  def read(self, iprot):
8828 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8829 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8830 
      return
8831 
    iprot.readStructBegin()
8832 
    while True:
8833 
      (fname, ftype, fid) = iprot.readFieldBegin()
8834 
      if ftype == TType.STOP:
8835 
        break
8836 
      if fid == 0:
8837 
        if ftype == TType.I32:
8838 
          self.success = iprot.readI32();
8839 
        else:
8840 
          iprot.skip(ftype)
8841 
      elif fid == 1:
8842 
        if ftype == TType.STRUCT:
8843 
          self.ex = TransactionServiceException()
8844 
          self.ex.read(iprot)
8845 
        else:
8846 
          iprot.skip(ftype)
8847 
      else:
8848 
        iprot.skip(ftype)
8849 
      iprot.readFieldEnd()
8850 
    iprot.readStructEnd()
8851 
 
8852 
  def write(self, oprot):
8853 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8854 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8855 
      return
8856 
    oprot.writeStructBegin('getOrderCount_result')
8857 
    if self.success is not None:
8858 
      oprot.writeFieldBegin('success', TType.I32, 0)
8859 
      oprot.writeI32(self.success)
8860 
      oprot.writeFieldEnd()
8861 
    if self.ex is not None:
8862 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
8863 
      self.ex.write(oprot)
8864 
      oprot.writeFieldEnd()
8865 
    oprot.writeFieldStop()
8866 
    oprot.writeStructEnd()
8867 
 
8868 
  def validate(self):
8869 
    return
8870 
 
8871 
 
8872 
  def __repr__(self):
8873 
    L = ['%s=%r' % (key, value)
8874 
      for key, value in self.__dict__.iteritems()]
8875 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8876 
 
8877 
  def __eq__(self, other):
8878 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8879 
 
8880 
  def __ne__(self, other):
8881 
    return not (self == other)
8882 
 
999 varun.gupt 8883 
class getOrdersByBillingDate_args:
8884 
  """
8885 
  Attributes:
8886 
   - status
8887 
   - start_billing_date
8888 
   - end_billing_date
8889 
   - warehouse_id
8890 
  """
8891 
 
8892 
  thrift_spec = (
8893 
    None, # 0
8894 
    (1, TType.I32, 'status', None, None, ), # 1
8895 
    (2, TType.I64, 'start_billing_date', None, None, ), # 2
8896 
    (3, TType.I64, 'end_billing_date', None, None, ), # 3
8897 
    (4, TType.I64, 'warehouse_id', None, None, ), # 4
8898 
  )
8899 
 
8900 
  def __init__(self, status=None, start_billing_date=None, end_billing_date=None, warehouse_id=None,):
8901 
    self.status = status
8902 
    self.start_billing_date = start_billing_date
8903 
    self.end_billing_date = end_billing_date
8904 
    self.warehouse_id = warehouse_id
8905 
 
8906 
  def read(self, iprot):
8907 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8908 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8909 
      return
8910 
    iprot.readStructBegin()
8911 
    while True:
8912 
      (fname, ftype, fid) = iprot.readFieldBegin()
8913 
      if ftype == TType.STOP:
8914 
        break
8915 
      if fid == 1:
8916 
        if ftype == TType.I32:
8917 
          self.status = iprot.readI32();
8918 
        else:
8919 
          iprot.skip(ftype)
8920 
      elif fid == 2:
8921 
        if ftype == TType.I64:
8922 
          self.start_billing_date = iprot.readI64();
8923 
        else:
8924 
          iprot.skip(ftype)
8925 
      elif fid == 3:
8926 
        if ftype == TType.I64:
8927 
          self.end_billing_date = iprot.readI64();
8928 
        else:
8929 
          iprot.skip(ftype)
8930 
      elif fid == 4:
8931 
        if ftype == TType.I64:
8932 
          self.warehouse_id = iprot.readI64();
8933 
        else:
8934 
          iprot.skip(ftype)
8935 
      else:
8936 
        iprot.skip(ftype)
8937 
      iprot.readFieldEnd()
8938 
    iprot.readStructEnd()
8939 
 
8940 
  def write(self, oprot):
8941 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8942 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8943 
      return
8944 
    oprot.writeStructBegin('getOrdersByBillingDate_args')
3431 rajveer 8945 
    if self.status is not None:
999 varun.gupt 8946 
      oprot.writeFieldBegin('status', TType.I32, 1)
8947 
      oprot.writeI32(self.status)
8948 
      oprot.writeFieldEnd()
3431 rajveer 8949 
    if self.start_billing_date is not None:
999 varun.gupt 8950 
      oprot.writeFieldBegin('start_billing_date', TType.I64, 2)
8951 
      oprot.writeI64(self.start_billing_date)
8952 
      oprot.writeFieldEnd()
3431 rajveer 8953 
    if self.end_billing_date is not None:
999 varun.gupt 8954 
      oprot.writeFieldBegin('end_billing_date', TType.I64, 3)
8955 
      oprot.writeI64(self.end_billing_date)
8956 
      oprot.writeFieldEnd()
3431 rajveer 8957 
    if self.warehouse_id is not None:
999 varun.gupt 8958 
      oprot.writeFieldBegin('warehouse_id', TType.I64, 4)
8959 
      oprot.writeI64(self.warehouse_id)
8960 
      oprot.writeFieldEnd()
8961 
    oprot.writeFieldStop()
8962 
    oprot.writeStructEnd()
8963 
 
3431 rajveer 8964 
  def validate(self):
8965 
    return
8966 
 
8967 
 
999 varun.gupt 8968 
  def __repr__(self):
8969 
    L = ['%s=%r' % (key, value)
8970 
      for key, value in self.__dict__.iteritems()]
8971 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8972 
 
8973 
  def __eq__(self, other):
8974 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8975 
 
8976 
  def __ne__(self, other):
8977 
    return not (self == other)
8978 
 
8979 
class getOrdersByBillingDate_result:
8980 
  """
8981 
  Attributes:
8982 
   - success
8983 
   - ex
8984 
  """
8985 
 
8986 
  thrift_spec = (
8987 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
8988 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
8989 
  )
8990 
 
8991 
  def __init__(self, success=None, ex=None,):
8992 
    self.success = success
8993 
    self.ex = ex
8994 
 
8995 
  def read(self, iprot):
8996 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8997 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8998 
      return
8999 
    iprot.readStructBegin()
9000 
    while True:
9001 
      (fname, ftype, fid) = iprot.readFieldBegin()
9002 
      if ftype == TType.STOP:
9003 
        break
9004 
      if fid == 0:
9005 
        if ftype == TType.LIST:
9006 
          self.success = []
5031 varun.gupt 9007 
          (_etype115, _size112) = iprot.readListBegin()
9008 
          for _i116 in xrange(_size112):
9009 
            _elem117 = Order()
9010 
            _elem117.read(iprot)
9011 
            self.success.append(_elem117)
999 varun.gupt 9012 
          iprot.readListEnd()
9013 
        else:
9014 
          iprot.skip(ftype)
9015 
      elif fid == 1:
9016 
        if ftype == TType.STRUCT:
9017 
          self.ex = TransactionServiceException()
9018 
          self.ex.read(iprot)
9019 
        else:
9020 
          iprot.skip(ftype)
9021 
      else:
9022 
        iprot.skip(ftype)
9023 
      iprot.readFieldEnd()
9024 
    iprot.readStructEnd()
9025 
 
9026 
  def write(self, oprot):
9027 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9028 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9029 
      return
9030 
    oprot.writeStructBegin('getOrdersByBillingDate_result')
3431 rajveer 9031 
    if self.success is not None:
999 varun.gupt 9032 
      oprot.writeFieldBegin('success', TType.LIST, 0)
9033 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
5031 varun.gupt 9034 
      for iter118 in self.success:
9035 
        iter118.write(oprot)
999 varun.gupt 9036 
      oprot.writeListEnd()
9037 
      oprot.writeFieldEnd()
3431 rajveer 9038 
    if self.ex is not None:
999 varun.gupt 9039 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
9040 
      self.ex.write(oprot)
9041 
      oprot.writeFieldEnd()
9042 
    oprot.writeFieldStop()
9043 
    oprot.writeStructEnd()
9044 
 
3431 rajveer 9045 
  def validate(self):
9046 
    return
9047 
 
9048 
 
999 varun.gupt 9049 
  def __repr__(self):
9050 
    L = ['%s=%r' % (key, value)
9051 
      for key, value in self.__dict__.iteritems()]
9052 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9053 
 
9054 
  def __eq__(self, other):
9055 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9056 
 
9057 
  def __ne__(self, other):
9058 
    return not (self == other)
9059 
 
3427 chandransh 9060 
class getOrdersByShippingDate_args:
9061 
  """
9062 
  Attributes:
9063 
   - fromShippingDate
9064 
   - toShippingDate
9065 
   - providerId
9066 
   - warehouseId
3451 chandransh 9067 
   - cod
3427 chandransh 9068 
  """
9069 
 
9070 
  thrift_spec = (
9071 
    None, # 0
9072 
    (1, TType.I64, 'fromShippingDate', None, None, ), # 1
9073 
    (2, TType.I64, 'toShippingDate', None, None, ), # 2
9074 
    (3, TType.I64, 'providerId', None, None, ), # 3
9075 
    (4, TType.I64, 'warehouseId', None, None, ), # 4
3451 chandransh 9076 
    (5, TType.BOOL, 'cod', None, None, ), # 5
3427 chandransh 9077 
  )
9078 
 
3451 chandransh 9079 
  def __init__(self, fromShippingDate=None, toShippingDate=None, providerId=None, warehouseId=None, cod=None,):
3427 chandransh 9080 
    self.fromShippingDate = fromShippingDate
9081 
    self.toShippingDate = toShippingDate
9082 
    self.providerId = providerId
9083 
    self.warehouseId = warehouseId
3451 chandransh 9084 
    self.cod = cod
3427 chandransh 9085 
 
9086 
  def read(self, iprot):
9087 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9088 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9089 
      return
9090 
    iprot.readStructBegin()
9091 
    while True:
9092 
      (fname, ftype, fid) = iprot.readFieldBegin()
9093 
      if ftype == TType.STOP:
9094 
        break
9095 
      if fid == 1:
9096 
        if ftype == TType.I64:
9097 
          self.fromShippingDate = iprot.readI64();
9098 
        else:
9099 
          iprot.skip(ftype)
9100 
      elif fid == 2:
9101 
        if ftype == TType.I64:
9102 
          self.toShippingDate = iprot.readI64();
9103 
        else:
9104 
          iprot.skip(ftype)
9105 
      elif fid == 3:
9106 
        if ftype == TType.I64:
9107 
          self.providerId = iprot.readI64();
9108 
        else:
9109 
          iprot.skip(ftype)
9110 
      elif fid == 4:
9111 
        if ftype == TType.I64:
9112 
          self.warehouseId = iprot.readI64();
9113 
        else:
9114 
          iprot.skip(ftype)
3451 chandransh 9115 
      elif fid == 5:
9116 
        if ftype == TType.BOOL:
9117 
          self.cod = iprot.readBool();
9118 
        else:
9119 
          iprot.skip(ftype)
3427 chandransh 9120 
      else:
9121 
        iprot.skip(ftype)
9122 
      iprot.readFieldEnd()
9123 
    iprot.readStructEnd()
9124 
 
9125 
  def write(self, oprot):
9126 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9127 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9128 
      return
9129 
    oprot.writeStructBegin('getOrdersByShippingDate_args')
3431 rajveer 9130 
    if self.fromShippingDate is not None:
3427 chandransh 9131 
      oprot.writeFieldBegin('fromShippingDate', TType.I64, 1)
9132 
      oprot.writeI64(self.fromShippingDate)
9133 
      oprot.writeFieldEnd()
3431 rajveer 9134 
    if self.toShippingDate is not None:
3427 chandransh 9135 
      oprot.writeFieldBegin('toShippingDate', TType.I64, 2)
9136 
      oprot.writeI64(self.toShippingDate)
9137 
      oprot.writeFieldEnd()
3431 rajveer 9138 
    if self.providerId is not None:
3427 chandransh 9139 
      oprot.writeFieldBegin('providerId', TType.I64, 3)
9140 
      oprot.writeI64(self.providerId)
9141 
      oprot.writeFieldEnd()
3431 rajveer 9142 
    if self.warehouseId is not None:
3427 chandransh 9143 
      oprot.writeFieldBegin('warehouseId', TType.I64, 4)
9144 
      oprot.writeI64(self.warehouseId)
9145 
      oprot.writeFieldEnd()
3451 chandransh 9146 
    if self.cod is not None:
9147 
      oprot.writeFieldBegin('cod', TType.BOOL, 5)
9148 
      oprot.writeBool(self.cod)
9149 
      oprot.writeFieldEnd()
3427 chandransh 9150 
    oprot.writeFieldStop()
9151 
    oprot.writeStructEnd()
9152 
 
3431 rajveer 9153 
  def validate(self):
9154 
    return
9155 
 
9156 
 
3427 chandransh 9157 
  def __repr__(self):
9158 
    L = ['%s=%r' % (key, value)
9159 
      for key, value in self.__dict__.iteritems()]
9160 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9161 
 
9162 
  def __eq__(self, other):
9163 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9164 
 
9165 
  def __ne__(self, other):
9166 
    return not (self == other)
9167 
 
9168 
class getOrdersByShippingDate_result:
9169 
  """
9170 
  Attributes:
9171 
   - success
9172 
   - ex
9173 
  """
9174 
 
9175 
  thrift_spec = (
9176 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
9177 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
9178 
  )
9179 
 
9180 
  def __init__(self, success=None, ex=None,):
9181 
    self.success = success
9182 
    self.ex = ex
9183 
 
9184 
  def read(self, iprot):
9185 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9186 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9187 
      return
9188 
    iprot.readStructBegin()
9189 
    while True:
9190 
      (fname, ftype, fid) = iprot.readFieldBegin()
9191 
      if ftype == TType.STOP:
9192 
        break
9193 
      if fid == 0:
9194 
        if ftype == TType.LIST:
9195 
          self.success = []
5031 varun.gupt 9196 
          (_etype122, _size119) = iprot.readListBegin()
9197 
          for _i123 in xrange(_size119):
9198 
            _elem124 = Order()
9199 
            _elem124.read(iprot)
9200 
            self.success.append(_elem124)
3427 chandransh 9201 
          iprot.readListEnd()
9202 
        else:
9203 
          iprot.skip(ftype)
9204 
      elif fid == 1:
9205 
        if ftype == TType.STRUCT:
9206 
          self.ex = TransactionServiceException()
9207 
          self.ex.read(iprot)
9208 
        else:
9209 
          iprot.skip(ftype)
9210 
      else:
9211 
        iprot.skip(ftype)
9212 
      iprot.readFieldEnd()
9213 
    iprot.readStructEnd()
9214 
 
9215 
  def write(self, oprot):
9216 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9217 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9218 
      return
9219 
    oprot.writeStructBegin('getOrdersByShippingDate_result')
3431 rajveer 9220 
    if self.success is not None:
3427 chandransh 9221 
      oprot.writeFieldBegin('success', TType.LIST, 0)
9222 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
5031 varun.gupt 9223 
      for iter125 in self.success:
9224 
        iter125.write(oprot)
3427 chandransh 9225 
      oprot.writeListEnd()
9226 
      oprot.writeFieldEnd()
3431 rajveer 9227 
    if self.ex is not None:
3427 chandransh 9228 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
9229 
      self.ex.write(oprot)
9230 
      oprot.writeFieldEnd()
9231 
    oprot.writeFieldStop()
9232 
    oprot.writeStructEnd()
9233 
 
3431 rajveer 9234 
  def validate(self):
9235 
    return
9236 
 
9237 
 
3427 chandransh 9238 
  def __repr__(self):
9239 
    L = ['%s=%r' % (key, value)
9240 
      for key, value in self.__dict__.iteritems()]
9241 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9242 
 
9243 
  def __eq__(self, other):
9244 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9245 
 
9246 
  def __ne__(self, other):
9247 
    return not (self == other)
9248 
 
1382 varun.gupt 9249 
class getReturnableOrdersForCustomer_args:
9250 
  """
9251 
  Attributes:
9252 
   - customer_id
9253 
   - limit
9254 
  """
9255 
 
9256 
  thrift_spec = (
9257 
    None, # 0
9258 
    (1, TType.I64, 'customer_id', None, None, ), # 1
9259 
    (2, TType.I64, 'limit', None, None, ), # 2
9260 
  )
9261 
 
9262 
  def __init__(self, customer_id=None, limit=None,):
9263 
    self.customer_id = customer_id
9264 
    self.limit = limit
9265 
 
9266 
  def read(self, iprot):
9267 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9268 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9269 
      return
9270 
    iprot.readStructBegin()
9271 
    while True:
9272 
      (fname, ftype, fid) = iprot.readFieldBegin()
9273 
      if ftype == TType.STOP:
9274 
        break
9275 
      if fid == 1:
9276 
        if ftype == TType.I64:
9277 
          self.customer_id = iprot.readI64();
9278 
        else:
9279 
          iprot.skip(ftype)
9280 
      elif fid == 2:
9281 
        if ftype == TType.I64:
9282 
          self.limit = iprot.readI64();
9283 
        else:
9284 
          iprot.skip(ftype)
9285 
      else:
9286 
        iprot.skip(ftype)
9287 
      iprot.readFieldEnd()
9288 
    iprot.readStructEnd()
9289 
 
9290 
  def write(self, oprot):
9291 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9292 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9293 
      return
9294 
    oprot.writeStructBegin('getReturnableOrdersForCustomer_args')
3431 rajveer 9295 
    if self.customer_id is not None:
1382 varun.gupt 9296 
      oprot.writeFieldBegin('customer_id', TType.I64, 1)
9297 
      oprot.writeI64(self.customer_id)
9298 
      oprot.writeFieldEnd()
3431 rajveer 9299 
    if self.limit is not None:
1382 varun.gupt 9300 
      oprot.writeFieldBegin('limit', TType.I64, 2)
9301 
      oprot.writeI64(self.limit)
9302 
      oprot.writeFieldEnd()
9303 
    oprot.writeFieldStop()
9304 
    oprot.writeStructEnd()
9305 
 
3431 rajveer 9306 
  def validate(self):
9307 
    return
9308 
 
9309 
 
1382 varun.gupt 9310 
  def __repr__(self):
9311 
    L = ['%s=%r' % (key, value)
9312 
      for key, value in self.__dict__.iteritems()]
9313 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9314 
 
9315 
  def __eq__(self, other):
9316 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9317 
 
9318 
  def __ne__(self, other):
9319 
    return not (self == other)
9320 
 
9321 
class getReturnableOrdersForCustomer_result:
9322 
  """
9323 
  Attributes:
9324 
   - success
9325 
   - ex
9326 
  """
9327 
 
9328 
  thrift_spec = (
9329 
    (0, TType.LIST, 'success', (TType.I64,None), None, ), # 0
9330 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
9331 
  )
9332 
 
9333 
  def __init__(self, success=None, ex=None,):
9334 
    self.success = success
9335 
    self.ex = ex
9336 
 
9337 
  def read(self, iprot):
9338 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9339 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9340 
      return
9341 
    iprot.readStructBegin()
9342 
    while True:
9343 
      (fname, ftype, fid) = iprot.readFieldBegin()
9344 
      if ftype == TType.STOP:
9345 
        break
9346 
      if fid == 0:
9347 
        if ftype == TType.LIST:
9348 
          self.success = []
5031 varun.gupt 9349 
          (_etype129, _size126) = iprot.readListBegin()
9350 
          for _i130 in xrange(_size126):
9351 
            _elem131 = iprot.readI64();
9352 
            self.success.append(_elem131)
1382 varun.gupt 9353 
          iprot.readListEnd()
9354 
        else:
9355 
          iprot.skip(ftype)
9356 
      elif fid == 1:
9357 
        if ftype == TType.STRUCT:
9358 
          self.ex = TransactionServiceException()
9359 
          self.ex.read(iprot)
9360 
        else:
9361 
          iprot.skip(ftype)
9362 
      else:
9363 
        iprot.skip(ftype)
9364 
      iprot.readFieldEnd()
9365 
    iprot.readStructEnd()
9366 
 
9367 
  def write(self, oprot):
9368 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9369 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9370 
      return
9371 
    oprot.writeStructBegin('getReturnableOrdersForCustomer_result')
3431 rajveer 9372 
    if self.success is not None:
1382 varun.gupt 9373 
      oprot.writeFieldBegin('success', TType.LIST, 0)
9374 
      oprot.writeListBegin(TType.I64, len(self.success))
5031 varun.gupt 9375 
      for iter132 in self.success:
9376 
        oprot.writeI64(iter132)
1382 varun.gupt 9377 
      oprot.writeListEnd()
9378 
      oprot.writeFieldEnd()
3431 rajveer 9379 
    if self.ex is not None:
1382 varun.gupt 9380 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
9381 
      self.ex.write(oprot)
9382 
      oprot.writeFieldEnd()
9383 
    oprot.writeFieldStop()
9384 
    oprot.writeStructEnd()
9385 
 
3431 rajveer 9386 
  def validate(self):
9387 
    return
9388 
 
9389 
 
1382 varun.gupt 9390 
  def __repr__(self):
9391 
    L = ['%s=%r' % (key, value)
9392 
      for key, value in self.__dict__.iteritems()]
9393 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9394 
 
9395 
  def __eq__(self, other):
9396 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9397 
 
9398 
  def __ne__(self, other):
9399 
    return not (self == other)
9400 
 
9401 
class getCancellableOrdersForCustomer_args:
9402 
  """
9403 
  Attributes:
9404 
   - customer_id
9405 
   - limit
9406 
  """
9407 
 
9408 
  thrift_spec = (
9409 
    None, # 0
9410 
    (1, TType.I64, 'customer_id', None, None, ), # 1
9411 
    (2, TType.I64, 'limit', None, None, ), # 2
9412 
  )
9413 
 
9414 
  def __init__(self, customer_id=None, limit=None,):
9415 
    self.customer_id = customer_id
9416 
    self.limit = limit
9417 
 
9418 
  def read(self, iprot):
9419 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9420 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9421 
      return
9422 
    iprot.readStructBegin()
9423 
    while True:
9424 
      (fname, ftype, fid) = iprot.readFieldBegin()
9425 
      if ftype == TType.STOP:
9426 
        break
9427 
      if fid == 1:
9428 
        if ftype == TType.I64:
9429 
          self.customer_id = iprot.readI64();
9430 
        else:
9431 
          iprot.skip(ftype)
9432 
      elif fid == 2:
9433 
        if ftype == TType.I64:
9434 
          self.limit = iprot.readI64();
9435 
        else:
9436 
          iprot.skip(ftype)
9437 
      else:
9438 
        iprot.skip(ftype)
9439 
      iprot.readFieldEnd()
9440 
    iprot.readStructEnd()
9441 
 
9442 
  def write(self, oprot):
9443 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9444 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9445 
      return
9446 
    oprot.writeStructBegin('getCancellableOrdersForCustomer_args')
3431 rajveer 9447 
    if self.customer_id is not None:
1382 varun.gupt 9448 
      oprot.writeFieldBegin('customer_id', TType.I64, 1)
9449 
      oprot.writeI64(self.customer_id)
9450 
      oprot.writeFieldEnd()
3431 rajveer 9451 
    if self.limit is not None:
1382 varun.gupt 9452 
      oprot.writeFieldBegin('limit', TType.I64, 2)
9453 
      oprot.writeI64(self.limit)
9454 
      oprot.writeFieldEnd()
9455 
    oprot.writeFieldStop()
9456 
    oprot.writeStructEnd()
9457 
 
3431 rajveer 9458 
  def validate(self):
9459 
    return
9460 
 
9461 
 
1382 varun.gupt 9462 
  def __repr__(self):
9463 
    L = ['%s=%r' % (key, value)
9464 
      for key, value in self.__dict__.iteritems()]
9465 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9466 
 
9467 
  def __eq__(self, other):
9468 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9469 
 
9470 
  def __ne__(self, other):
9471 
    return not (self == other)
9472 
 
9473 
class getCancellableOrdersForCustomer_result:
9474 
  """
9475 
  Attributes:
9476 
   - success
9477 
   - ex
9478 
  """
9479 
 
9480 
  thrift_spec = (
9481 
    (0, TType.LIST, 'success', (TType.I64,None), None, ), # 0
9482 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
9483 
  )
9484 
 
9485 
  def __init__(self, success=None, ex=None,):
9486 
    self.success = success
9487 
    self.ex = ex
9488 
 
9489 
  def read(self, iprot):
9490 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9491 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9492 
      return
9493 
    iprot.readStructBegin()
9494 
    while True:
9495 
      (fname, ftype, fid) = iprot.readFieldBegin()
9496 
      if ftype == TType.STOP:
9497 
        break
9498 
      if fid == 0:
9499 
        if ftype == TType.LIST:
9500 
          self.success = []
5031 varun.gupt 9501 
          (_etype136, _size133) = iprot.readListBegin()
9502 
          for _i137 in xrange(_size133):
9503 
            _elem138 = iprot.readI64();
9504 
            self.success.append(_elem138)
1382 varun.gupt 9505 
          iprot.readListEnd()
9506 
        else:
9507 
          iprot.skip(ftype)
9508 
      elif fid == 1:
9509 
        if ftype == TType.STRUCT:
9510 
          self.ex = TransactionServiceException()
9511 
          self.ex.read(iprot)
9512 
        else:
9513 
          iprot.skip(ftype)
9514 
      else:
9515 
        iprot.skip(ftype)
9516 
      iprot.readFieldEnd()
9517 
    iprot.readStructEnd()
9518 
 
9519 
  def write(self, oprot):
9520 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9521 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9522 
      return
9523 
    oprot.writeStructBegin('getCancellableOrdersForCustomer_result')
3431 rajveer 9524 
    if self.success is not None:
1382 varun.gupt 9525 
      oprot.writeFieldBegin('success', TType.LIST, 0)
9526 
      oprot.writeListBegin(TType.I64, len(self.success))
5031 varun.gupt 9527 
      for iter139 in self.success:
9528 
        oprot.writeI64(iter139)
1382 varun.gupt 9529 
      oprot.writeListEnd()
9530 
      oprot.writeFieldEnd()
3431 rajveer 9531 
    if self.ex is not None:
1382 varun.gupt 9532 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
9533 
      self.ex.write(oprot)
9534 
      oprot.writeFieldEnd()
9535 
    oprot.writeFieldStop()
9536 
    oprot.writeStructEnd()
9537 
 
3431 rajveer 9538 
  def validate(self):
9539 
    return
9540 
 
9541 
 
1382 varun.gupt 9542 
  def __repr__(self):
9543 
    L = ['%s=%r' % (key, value)
9544 
      for key, value in self.__dict__.iteritems()]
9545 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9546 
 
9547 
  def __eq__(self, other):
9548 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9549 
 
9550 
  def __ne__(self, other):
9551 
    return not (self == other)
9552 
 
483 rajveer 9553 
class changeOrderStatus_args:
94 ashish 9554 
  """
9555 
  Attributes:
483 rajveer 9556 
   - orderId
9557 
   - status
9558 
   - description
94 ashish 9559 
  """
9560 
 
9561 
  thrift_spec = (
9562 
    None, # 0
483 rajveer 9563 
    (1, TType.I64, 'orderId', None, None, ), # 1
9564 
    (2, TType.I32, 'status', None, None, ), # 2
9565 
    (3, TType.STRING, 'description', None, None, ), # 3
94 ashish 9566 
  )
9567 
 
483 rajveer 9568 
  def __init__(self, orderId=None, status=None, description=None,):
9569 
    self.orderId = orderId
9570 
    self.status = status
9571 
    self.description = description
94 ashish 9572 
 
9573 
  def read(self, iprot):
9574 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9575 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9576 
      return
9577 
    iprot.readStructBegin()
9578 
    while True:
9579 
      (fname, ftype, fid) = iprot.readFieldBegin()
9580 
      if ftype == TType.STOP:
9581 
        break
9582 
      if fid == 1:
9583 
        if ftype == TType.I64:
483 rajveer 9584 
          self.orderId = iprot.readI64();
94 ashish 9585 
        else:
9586 
          iprot.skip(ftype)
9587 
      elif fid == 2:
483 rajveer 9588 
        if ftype == TType.I32:
9589 
          self.status = iprot.readI32();
94 ashish 9590 
        else:
9591 
          iprot.skip(ftype)
483 rajveer 9592 
      elif fid == 3:
9593 
        if ftype == TType.STRING:
9594 
          self.description = iprot.readString();
9595 
        else:
9596 
          iprot.skip(ftype)
94 ashish 9597 
      else:
9598 
        iprot.skip(ftype)
9599 
      iprot.readFieldEnd()
9600 
    iprot.readStructEnd()
9601 
 
9602 
  def write(self, oprot):
9603 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9604 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9605 
      return
483 rajveer 9606 
    oprot.writeStructBegin('changeOrderStatus_args')
3431 rajveer 9607 
    if self.orderId is not None:
483 rajveer 9608 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
9609 
      oprot.writeI64(self.orderId)
94 ashish 9610 
      oprot.writeFieldEnd()
3431 rajveer 9611 
    if self.status is not None:
483 rajveer 9612 
      oprot.writeFieldBegin('status', TType.I32, 2)
9613 
      oprot.writeI32(self.status)
94 ashish 9614 
      oprot.writeFieldEnd()
3431 rajveer 9615 
    if self.description is not None:
483 rajveer 9616 
      oprot.writeFieldBegin('description', TType.STRING, 3)
9617 
      oprot.writeString(self.description)
9618 
      oprot.writeFieldEnd()
94 ashish 9619 
    oprot.writeFieldStop()
9620 
    oprot.writeStructEnd()
9621 
 
3431 rajveer 9622 
  def validate(self):
9623 
    return
9624 
 
9625 
 
94 ashish 9626 
  def __repr__(self):
9627 
    L = ['%s=%r' % (key, value)
9628 
      for key, value in self.__dict__.iteritems()]
9629 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9630 
 
9631 
  def __eq__(self, other):
9632 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9633 
 
9634 
  def __ne__(self, other):
9635 
    return not (self == other)
9636 
 
483 rajveer 9637 
class changeOrderStatus_result:
94 ashish 9638 
  """
9639 
  Attributes:
9640 
   - success
9641 
   - ex
9642 
  """
9643 
 
9644 
  thrift_spec = (
9645 
    (0, TType.BOOL, 'success', None, None, ), # 0
9646 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
9647 
  )
9648 
 
9649 
  def __init__(self, success=None, ex=None,):
9650 
    self.success = success
9651 
    self.ex = ex
9652 
 
9653 
  def read(self, iprot):
9654 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9655 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9656 
      return
9657 
    iprot.readStructBegin()
9658 
    while True:
9659 
      (fname, ftype, fid) = iprot.readFieldBegin()
9660 
      if ftype == TType.STOP:
9661 
        break
9662 
      if fid == 0:
9663 
        if ftype == TType.BOOL:
9664 
          self.success = iprot.readBool();
9665 
        else:
9666 
          iprot.skip(ftype)
9667 
      elif fid == 1:
9668 
        if ftype == TType.STRUCT:
9669 
          self.ex = TransactionServiceException()
9670 
          self.ex.read(iprot)
9671 
        else:
9672 
          iprot.skip(ftype)
9673 
      else:
9674 
        iprot.skip(ftype)
9675 
      iprot.readFieldEnd()
9676 
    iprot.readStructEnd()
9677 
 
9678 
  def write(self, oprot):
9679 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9680 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9681 
      return
483 rajveer 9682 
    oprot.writeStructBegin('changeOrderStatus_result')
3431 rajveer 9683 
    if self.success is not None:
94 ashish 9684 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
9685 
      oprot.writeBool(self.success)
9686 
      oprot.writeFieldEnd()
3431 rajveer 9687 
    if self.ex is not None:
94 ashish 9688 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
9689 
      self.ex.write(oprot)
9690 
      oprot.writeFieldEnd()
9691 
    oprot.writeFieldStop()
9692 
    oprot.writeStructEnd()
9693 
 
3431 rajveer 9694 
  def validate(self):
9695 
    return
9696 
 
9697 
 
94 ashish 9698 
  def __repr__(self):
9699 
    L = ['%s=%r' % (key, value)
9700 
      for key, value in self.__dict__.iteritems()]
9701 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9702 
 
9703 
  def __eq__(self, other):
9704 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9705 
 
9706 
  def __ne__(self, other):
9707 
    return not (self == other)
9708 
 
3064 chandransh 9709 
class getOrdersForTransaction_args:
494 rajveer 9710 
  """
9711 
  Attributes:
3064 chandransh 9712 
   - transactionId
9713 
   - customerId
494 rajveer 9714 
  """
9715 
 
9716 
  thrift_spec = (
9717 
    None, # 0
3064 chandransh 9718 
    (1, TType.I64, 'transactionId', None, None, ), # 1
9719 
    (2, TType.I64, 'customerId', None, None, ), # 2
494 rajveer 9720 
  )
9721 
 
3064 chandransh 9722 
  def __init__(self, transactionId=None, customerId=None,):
9723 
    self.transactionId = transactionId
9724 
    self.customerId = customerId
494 rajveer 9725 
 
9726 
  def read(self, iprot):
9727 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9728 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9729 
      return
9730 
    iprot.readStructBegin()
9731 
    while True:
9732 
      (fname, ftype, fid) = iprot.readFieldBegin()
9733 
      if ftype == TType.STOP:
9734 
        break
9735 
      if fid == 1:
9736 
        if ftype == TType.I64:
3064 chandransh 9737 
          self.transactionId = iprot.readI64();
494 rajveer 9738 
        else:
9739 
          iprot.skip(ftype)
9740 
      elif fid == 2:
3064 chandransh 9741 
        if ftype == TType.I64:
9742 
          self.customerId = iprot.readI64();
494 rajveer 9743 
        else:
9744 
          iprot.skip(ftype)
9745 
      else:
9746 
        iprot.skip(ftype)
9747 
      iprot.readFieldEnd()
9748 
    iprot.readStructEnd()
9749 
 
9750 
  def write(self, oprot):
9751 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9752 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9753 
      return
3064 chandransh 9754 
    oprot.writeStructBegin('getOrdersForTransaction_args')
3431 rajveer 9755 
    if self.transactionId is not None:
3064 chandransh 9756 
      oprot.writeFieldBegin('transactionId', TType.I64, 1)
9757 
      oprot.writeI64(self.transactionId)
494 rajveer 9758 
      oprot.writeFieldEnd()
3431 rajveer 9759 
    if self.customerId is not None:
3064 chandransh 9760 
      oprot.writeFieldBegin('customerId', TType.I64, 2)
9761 
      oprot.writeI64(self.customerId)
494 rajveer 9762 
      oprot.writeFieldEnd()
9763 
    oprot.writeFieldStop()
9764 
    oprot.writeStructEnd()
9765 
 
3431 rajveer 9766 
  def validate(self):
9767 
    return
9768 
 
9769 
 
494 rajveer 9770 
  def __repr__(self):
9771 
    L = ['%s=%r' % (key, value)
9772 
      for key, value in self.__dict__.iteritems()]
9773 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9774 
 
9775 
  def __eq__(self, other):
9776 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9777 
 
9778 
  def __ne__(self, other):
9779 
    return not (self == other)
9780 
 
3064 chandransh 9781 
class getOrdersForTransaction_result:
494 rajveer 9782 
  """
9783 
  Attributes:
9784 
   - success
9785 
   - ex
9786 
  """
9787 
 
9788 
  thrift_spec = (
3064 chandransh 9789 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
494 rajveer 9790 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
9791 
  )
9792 
 
9793 
  def __init__(self, success=None, ex=None,):
9794 
    self.success = success
9795 
    self.ex = ex
9796 
 
9797 
  def read(self, iprot):
9798 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9799 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9800 
      return
9801 
    iprot.readStructBegin()
9802 
    while True:
9803 
      (fname, ftype, fid) = iprot.readFieldBegin()
9804 
      if ftype == TType.STOP:
9805 
        break
9806 
      if fid == 0:
3064 chandransh 9807 
        if ftype == TType.LIST:
9808 
          self.success = []
5031 varun.gupt 9809 
          (_etype143, _size140) = iprot.readListBegin()
9810 
          for _i144 in xrange(_size140):
9811 
            _elem145 = Order()
9812 
            _elem145.read(iprot)
9813 
            self.success.append(_elem145)
3064 chandransh 9814 
          iprot.readListEnd()
494 rajveer 9815 
        else:
9816 
          iprot.skip(ftype)
9817 
      elif fid == 1:
9818 
        if ftype == TType.STRUCT:
9819 
          self.ex = TransactionServiceException()
9820 
          self.ex.read(iprot)
9821 
        else:
9822 
          iprot.skip(ftype)
9823 
      else:
9824 
        iprot.skip(ftype)
9825 
      iprot.readFieldEnd()
9826 
    iprot.readStructEnd()
9827 
 
9828 
  def write(self, oprot):
9829 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9830 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9831 
      return
3064 chandransh 9832 
    oprot.writeStructBegin('getOrdersForTransaction_result')
3431 rajveer 9833 
    if self.success is not None:
3064 chandransh 9834 
      oprot.writeFieldBegin('success', TType.LIST, 0)
9835 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
5031 varun.gupt 9836 
      for iter146 in self.success:
9837 
        iter146.write(oprot)
3064 chandransh 9838 
      oprot.writeListEnd()
494 rajveer 9839 
      oprot.writeFieldEnd()
3431 rajveer 9840 
    if self.ex is not None:
494 rajveer 9841 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
9842 
      self.ex.write(oprot)
9843 
      oprot.writeFieldEnd()
9844 
    oprot.writeFieldStop()
9845 
    oprot.writeStructEnd()
9846 
 
3431 rajveer 9847 
  def validate(self):
9848 
    return
9849 
 
9850 
 
494 rajveer 9851 
  def __repr__(self):
9852 
    L = ['%s=%r' % (key, value)
9853 
      for key, value in self.__dict__.iteritems()]
9854 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9855 
 
9856 
  def __eq__(self, other):
9857 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9858 
 
9859 
  def __ne__(self, other):
9860 
    return not (self == other)
9861 
 
3064 chandransh 9862 
class getOrdersForCustomer_args:
1149 chandransh 9863 
  """
9864 
  Attributes:
3064 chandransh 9865 
   - customerId
9866 
   - from_date
9867 
   - to_date
9868 
   - statuses
1149 chandransh 9869 
  """
9870 
 
9871 
  thrift_spec = (
9872 
    None, # 0
3064 chandransh 9873 
    (1, TType.I64, 'customerId', None, None, ), # 1
9874 
    (2, TType.I64, 'from_date', None, None, ), # 2
9875 
    (3, TType.I64, 'to_date', None, None, ), # 3
9876 
    (4, TType.LIST, 'statuses', (TType.I32,None), None, ), # 4
1149 chandransh 9877 
  )
9878 
 
3064 chandransh 9879 
  def __init__(self, customerId=None, from_date=None, to_date=None, statuses=None,):
9880 
    self.customerId = customerId
9881 
    self.from_date = from_date
9882 
    self.to_date = to_date
9883 
    self.statuses = statuses
1149 chandransh 9884 
 
9885 
  def read(self, iprot):
9886 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9887 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9888 
      return
9889 
    iprot.readStructBegin()
9890 
    while True:
9891 
      (fname, ftype, fid) = iprot.readFieldBegin()
9892 
      if ftype == TType.STOP:
9893 
        break
9894 
      if fid == 1:
9895 
        if ftype == TType.I64:
3064 chandransh 9896 
          self.customerId = iprot.readI64();
1149 chandransh 9897 
        else:
9898 
          iprot.skip(ftype)
9899 
      elif fid == 2:
9900 
        if ftype == TType.I64:
3064 chandransh 9901 
          self.from_date = iprot.readI64();
1149 chandransh 9902 
        else:
9903 
          iprot.skip(ftype)
2783 chandransh 9904 
      elif fid == 3:
9905 
        if ftype == TType.I64:
3064 chandransh 9906 
          self.to_date = iprot.readI64();
2783 chandransh 9907 
        else:
9908 
          iprot.skip(ftype)
9909 
      elif fid == 4:
3064 chandransh 9910 
        if ftype == TType.LIST:
9911 
          self.statuses = []
5031 varun.gupt 9912 
          (_etype150, _size147) = iprot.readListBegin()
9913 
          for _i151 in xrange(_size147):
9914 
            _elem152 = iprot.readI32();
9915 
            self.statuses.append(_elem152)
3064 chandransh 9916 
          iprot.readListEnd()
2783 chandransh 9917 
        else:
9918 
          iprot.skip(ftype)
1149 chandransh 9919 
      else:
9920 
        iprot.skip(ftype)
9921 
      iprot.readFieldEnd()
9922 
    iprot.readStructEnd()
9923 
 
9924 
  def write(self, oprot):
9925 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9926 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9927 
      return
3064 chandransh 9928 
    oprot.writeStructBegin('getOrdersForCustomer_args')
3431 rajveer 9929 
    if self.customerId is not None:
3064 chandransh 9930 
      oprot.writeFieldBegin('customerId', TType.I64, 1)
9931 
      oprot.writeI64(self.customerId)
1149 chandransh 9932 
      oprot.writeFieldEnd()
3431 rajveer 9933 
    if self.from_date is not None:
3064 chandransh 9934 
      oprot.writeFieldBegin('from_date', TType.I64, 2)
9935 
      oprot.writeI64(self.from_date)
1149 chandransh 9936 
      oprot.writeFieldEnd()
3431 rajveer 9937 
    if self.to_date is not None:
3064 chandransh 9938 
      oprot.writeFieldBegin('to_date', TType.I64, 3)
9939 
      oprot.writeI64(self.to_date)
2783 chandransh 9940 
      oprot.writeFieldEnd()
3431 rajveer 9941 
    if self.statuses is not None:
3064 chandransh 9942 
      oprot.writeFieldBegin('statuses', TType.LIST, 4)
9943 
      oprot.writeListBegin(TType.I32, len(self.statuses))
5031 varun.gupt 9944 
      for iter153 in self.statuses:
9945 
        oprot.writeI32(iter153)
3064 chandransh 9946 
      oprot.writeListEnd()
2783 chandransh 9947 
      oprot.writeFieldEnd()
1149 chandransh 9948 
    oprot.writeFieldStop()
9949 
    oprot.writeStructEnd()
9950 
 
3431 rajveer 9951 
  def validate(self):
9952 
    return
9953 
 
9954 
 
1149 chandransh 9955 
  def __repr__(self):
9956 
    L = ['%s=%r' % (key, value)
9957 
      for key, value in self.__dict__.iteritems()]
9958 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9959 
 
9960 
  def __eq__(self, other):
9961 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9962 
 
9963 
  def __ne__(self, other):
9964 
    return not (self == other)
9965 
 
3064 chandransh 9966 
class getOrdersForCustomer_result:
1149 chandransh 9967 
  """
9968 
  Attributes:
9969 
   - success
9970 
   - ex
9971 
  """
9972 
 
9973 
  thrift_spec = (
3064 chandransh 9974 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
1149 chandransh 9975 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
9976 
  )
9977 
 
9978 
  def __init__(self, success=None, ex=None,):
9979 
    self.success = success
9980 
    self.ex = ex
9981 
 
9982 
  def read(self, iprot):
9983 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9984 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9985 
      return
9986 
    iprot.readStructBegin()
9987 
    while True:
9988 
      (fname, ftype, fid) = iprot.readFieldBegin()
9989 
      if ftype == TType.STOP:
9990 
        break
9991 
      if fid == 0:
3064 chandransh 9992 
        if ftype == TType.LIST:
9993 
          self.success = []
5031 varun.gupt 9994 
          (_etype157, _size154) = iprot.readListBegin()
9995 
          for _i158 in xrange(_size154):
9996 
            _elem159 = Order()
9997 
            _elem159.read(iprot)
9998 
            self.success.append(_elem159)
3064 chandransh 9999 
          iprot.readListEnd()
1149 chandransh 10000 
        else:
10001 
          iprot.skip(ftype)
10002 
      elif fid == 1:
10003 
        if ftype == TType.STRUCT:
10004 
          self.ex = TransactionServiceException()
10005 
          self.ex.read(iprot)
10006 
        else:
10007 
          iprot.skip(ftype)
10008 
      else:
10009 
        iprot.skip(ftype)
10010 
      iprot.readFieldEnd()
10011 
    iprot.readStructEnd()
10012 
 
10013 
  def write(self, oprot):
10014 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10015 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10016 
      return
3064 chandransh 10017 
    oprot.writeStructBegin('getOrdersForCustomer_result')
3431 rajveer 10018 
    if self.success is not None:
3064 chandransh 10019 
      oprot.writeFieldBegin('success', TType.LIST, 0)
10020 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
5031 varun.gupt 10021 
      for iter160 in self.success:
10022 
        iter160.write(oprot)
3064 chandransh 10023 
      oprot.writeListEnd()
1149 chandransh 10024 
      oprot.writeFieldEnd()
3431 rajveer 10025 
    if self.ex is not None:
1149 chandransh 10026 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
10027 
      self.ex.write(oprot)
10028 
      oprot.writeFieldEnd()
10029 
    oprot.writeFieldStop()
10030 
    oprot.writeStructEnd()
10031 
 
3431 rajveer 10032 
  def validate(self):
10033 
    return
10034 
 
10035 
 
1149 chandransh 10036 
  def __repr__(self):
10037 
    L = ['%s=%r' % (key, value)
10038 
      for key, value in self.__dict__.iteritems()]
10039 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10040 
 
10041 
  def __eq__(self, other):
10042 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10043 
 
10044 
  def __ne__(self, other):
10045 
    return not (self == other)
10046 
 
3064 chandransh 10047 
class createOrder_args:
921 rajveer 10048 
  """
10049 
  Attributes:
3064 chandransh 10050 
   - order
921 rajveer 10051 
  """
10052 
 
10053 
  thrift_spec = (
10054 
    None, # 0
3064 chandransh 10055 
    (1, TType.STRUCT, 'order', (Order, Order.thrift_spec), None, ), # 1
921 rajveer 10056 
  )
10057 
 
3064 chandransh 10058 
  def __init__(self, order=None,):
10059 
    self.order = order
921 rajveer 10060 
 
10061 
  def read(self, iprot):
10062 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10063 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10064 
      return
10065 
    iprot.readStructBegin()
10066 
    while True:
10067 
      (fname, ftype, fid) = iprot.readFieldBegin()
10068 
      if ftype == TType.STOP:
10069 
        break
10070 
      if fid == 1:
3064 chandransh 10071 
        if ftype == TType.STRUCT:
10072 
          self.order = Order()
10073 
          self.order.read(iprot)
921 rajveer 10074 
        else:
10075 
          iprot.skip(ftype)
10076 
      else:
10077 
        iprot.skip(ftype)
10078 
      iprot.readFieldEnd()
10079 
    iprot.readStructEnd()
10080 
 
10081 
  def write(self, oprot):
10082 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10083 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10084 
      return
3064 chandransh 10085 
    oprot.writeStructBegin('createOrder_args')
3431 rajveer 10086 
    if self.order is not None:
3064 chandransh 10087 
      oprot.writeFieldBegin('order', TType.STRUCT, 1)
10088 
      self.order.write(oprot)
921 rajveer 10089 
      oprot.writeFieldEnd()
10090 
    oprot.writeFieldStop()
10091 
    oprot.writeStructEnd()
10092 
 
3431 rajveer 10093 
  def validate(self):
10094 
    return
10095 
 
10096 
 
921 rajveer 10097 
  def __repr__(self):
10098 
    L = ['%s=%r' % (key, value)
10099 
      for key, value in self.__dict__.iteritems()]
10100 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10101 
 
10102 
  def __eq__(self, other):
10103 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10104 
 
10105 
  def __ne__(self, other):
10106 
    return not (self == other)
10107 
 
3064 chandransh 10108 
class createOrder_result:
921 rajveer 10109 
  """
10110 
  Attributes:
10111 
   - success
10112 
   - ex
10113 
  """
10114 
 
10115 
  thrift_spec = (
3064 chandransh 10116 
    (0, TType.I64, 'success', None, None, ), # 0
921 rajveer 10117 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
10118 
  )
10119 
 
10120 
  def __init__(self, success=None, ex=None,):
10121 
    self.success = success
10122 
    self.ex = ex
10123 
 
10124 
  def read(self, iprot):
10125 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10126 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10127 
      return
10128 
    iprot.readStructBegin()
10129 
    while True:
10130 
      (fname, ftype, fid) = iprot.readFieldBegin()
10131 
      if ftype == TType.STOP:
10132 
        break
10133 
      if fid == 0:
3064 chandransh 10134 
        if ftype == TType.I64:
10135 
          self.success = iprot.readI64();
921 rajveer 10136 
        else:
10137 
          iprot.skip(ftype)
10138 
      elif fid == 1:
10139 
        if ftype == TType.STRUCT:
10140 
          self.ex = TransactionServiceException()
10141 
          self.ex.read(iprot)
10142 
        else:
10143 
          iprot.skip(ftype)
10144 
      else:
10145 
        iprot.skip(ftype)
10146 
      iprot.readFieldEnd()
10147 
    iprot.readStructEnd()
10148 
 
10149 
  def write(self, oprot):
10150 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10151 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10152 
      return
3064 chandransh 10153 
    oprot.writeStructBegin('createOrder_result')
3431 rajveer 10154 
    if self.success is not None:
3064 chandransh 10155 
      oprot.writeFieldBegin('success', TType.I64, 0)
10156 
      oprot.writeI64(self.success)
921 rajveer 10157 
      oprot.writeFieldEnd()
3431 rajveer 10158 
    if self.ex is not None:
921 rajveer 10159 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
10160 
      self.ex.write(oprot)
10161 
      oprot.writeFieldEnd()
10162 
    oprot.writeFieldStop()
10163 
    oprot.writeStructEnd()
10164 
 
3431 rajveer 10165 
  def validate(self):
10166 
    return
10167 
 
10168 
 
921 rajveer 10169 
  def __repr__(self):
10170 
    L = ['%s=%r' % (key, value)
10171 
      for key, value in self.__dict__.iteritems()]
10172 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10173 
 
10174 
  def __eq__(self, other):
10175 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10176 
 
10177 
  def __ne__(self, other):
10178 
    return not (self == other)
10179 
 
3064 chandransh 10180 
class getOrder_args:
921 rajveer 10181 
  """
10182 
  Attributes:
3064 chandransh 10183 
   - id
921 rajveer 10184 
  """
10185 
 
10186 
  thrift_spec = (
10187 
    None, # 0
3064 chandransh 10188 
    (1, TType.I64, 'id', None, None, ), # 1
921 rajveer 10189 
  )
10190 
 
3064 chandransh 10191 
  def __init__(self, id=None,):
10192 
    self.id = id
921 rajveer 10193 
 
10194 
  def read(self, iprot):
10195 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10196 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10197 
      return
10198 
    iprot.readStructBegin()
10199 
    while True:
10200 
      (fname, ftype, fid) = iprot.readFieldBegin()
10201 
      if ftype == TType.STOP:
10202 
        break
10203 
      if fid == 1:
10204 
        if ftype == TType.I64:
3064 chandransh 10205 
          self.id = iprot.readI64();
921 rajveer 10206 
        else:
10207 
          iprot.skip(ftype)
10208 
      else:
10209 
        iprot.skip(ftype)
10210 
      iprot.readFieldEnd()
10211 
    iprot.readStructEnd()
10212 
 
10213 
  def write(self, oprot):
10214 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10215 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10216 
      return
3064 chandransh 10217 
    oprot.writeStructBegin('getOrder_args')
3431 rajveer 10218 
    if self.id is not None:
3064 chandransh 10219 
      oprot.writeFieldBegin('id', TType.I64, 1)
10220 
      oprot.writeI64(self.id)
921 rajveer 10221 
      oprot.writeFieldEnd()
10222 
    oprot.writeFieldStop()
10223 
    oprot.writeStructEnd()
10224 
 
3431 rajveer 10225 
  def validate(self):
10226 
    return
10227 
 
10228 
 
921 rajveer 10229 
  def __repr__(self):
10230 
    L = ['%s=%r' % (key, value)
10231 
      for key, value in self.__dict__.iteritems()]
10232 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10233 
 
10234 
  def __eq__(self, other):
10235 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10236 
 
10237 
  def __ne__(self, other):
10238 
    return not (self == other)
10239 
 
3064 chandransh 10240 
class getOrder_result:
921 rajveer 10241 
  """
10242 
  Attributes:
10243 
   - success
10244 
   - ex
10245 
  """
10246 
 
10247 
  thrift_spec = (
3064 chandransh 10248 
    (0, TType.STRUCT, 'success', (Order, Order.thrift_spec), None, ), # 0
921 rajveer 10249 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
10250 
  )
10251 
 
10252 
  def __init__(self, success=None, ex=None,):
10253 
    self.success = success
10254 
    self.ex = ex
10255 
 
10256 
  def read(self, iprot):
10257 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10258 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10259 
      return
10260 
    iprot.readStructBegin()
10261 
    while True:
10262 
      (fname, ftype, fid) = iprot.readFieldBegin()
10263 
      if ftype == TType.STOP:
10264 
        break
10265 
      if fid == 0:
3064 chandransh 10266 
        if ftype == TType.STRUCT:
10267 
          self.success = Order()
10268 
          self.success.read(iprot)
921 rajveer 10269 
        else:
10270 
          iprot.skip(ftype)
10271 
      elif fid == 1:
10272 
        if ftype == TType.STRUCT:
10273 
          self.ex = TransactionServiceException()
10274 
          self.ex.read(iprot)
10275 
        else:
10276 
          iprot.skip(ftype)
10277 
      else:
10278 
        iprot.skip(ftype)
10279 
      iprot.readFieldEnd()
10280 
    iprot.readStructEnd()
10281 
 
10282 
  def write(self, oprot):
10283 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10284 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10285 
      return
3064 chandransh 10286 
    oprot.writeStructBegin('getOrder_result')
3431 rajveer 10287 
    if self.success is not None:
3064 chandransh 10288 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
10289 
      self.success.write(oprot)
921 rajveer 10290 
      oprot.writeFieldEnd()
3431 rajveer 10291 
    if self.ex is not None:
921 rajveer 10292 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
10293 
      self.ex.write(oprot)
10294 
      oprot.writeFieldEnd()
10295 
    oprot.writeFieldStop()
10296 
    oprot.writeStructEnd()
10297 
 
3431 rajveer 10298 
  def validate(self):
10299 
    return
10300 
 
10301 
 
921 rajveer 10302 
  def __repr__(self):
10303 
    L = ['%s=%r' % (key, value)
10304 
      for key, value in self.__dict__.iteritems()]
10305 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10306 
 
10307 
  def __eq__(self, other):
10308 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10309 
 
10310 
  def __ne__(self, other):
10311 
    return not (self == other)
10312 
 
3064 chandransh 10313 
class getLineItemsForOrder_args:
94 ashish 10314 
  """
10315 
  Attributes:
3064 chandransh 10316 
   - orderId
94 ashish 10317 
  """
10318 
 
10319 
  thrift_spec = (
10320 
    None, # 0
3064 chandransh 10321 
    (1, TType.I64, 'orderId', None, None, ), # 1
94 ashish 10322 
  )
10323 
 
3064 chandransh 10324 
  def __init__(self, orderId=None,):
10325 
    self.orderId = orderId
94 ashish 10326 
 
10327 
  def read(self, iprot):
10328 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10329 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10330 
      return
10331 
    iprot.readStructBegin()
10332 
    while True:
10333 
      (fname, ftype, fid) = iprot.readFieldBegin()
10334 
      if ftype == TType.STOP:
10335 
        break
10336 
      if fid == 1:
10337 
        if ftype == TType.I64:
3064 chandransh 10338 
          self.orderId = iprot.readI64();
94 ashish 10339 
        else:
10340 
          iprot.skip(ftype)
10341 
      else:
10342 
        iprot.skip(ftype)
10343 
      iprot.readFieldEnd()
10344 
    iprot.readStructEnd()
10345 
 
10346 
  def write(self, oprot):
10347 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10348 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10349 
      return
3064 chandransh 10350 
    oprot.writeStructBegin('getLineItemsForOrder_args')
3431 rajveer 10351 
    if self.orderId is not None:
3064 chandransh 10352 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
10353 
      oprot.writeI64(self.orderId)
94 ashish 10354 
      oprot.writeFieldEnd()
10355 
    oprot.writeFieldStop()
10356 
    oprot.writeStructEnd()
10357 
 
3431 rajveer 10358 
  def validate(self):
10359 
    return
10360 
 
10361 
 
94 ashish 10362 
  def __repr__(self):
10363 
    L = ['%s=%r' % (key, value)
10364 
      for key, value in self.__dict__.iteritems()]
10365 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10366 
 
10367 
  def __eq__(self, other):
10368 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10369 
 
10370 
  def __ne__(self, other):
10371 
    return not (self == other)
10372 
 
3064 chandransh 10373 
class getLineItemsForOrder_result:
94 ashish 10374 
  """
10375 
  Attributes:
10376 
   - success
10377 
   - ex
10378 
  """
10379 
 
10380 
  thrift_spec = (
3064 chandransh 10381 
    (0, TType.LIST, 'success', (TType.STRUCT,(LineItem, LineItem.thrift_spec)), None, ), # 0
94 ashish 10382 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
10383 
  )
10384 
 
10385 
  def __init__(self, success=None, ex=None,):
10386 
    self.success = success
10387 
    self.ex = ex
10388 
 
10389 
  def read(self, iprot):
10390 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10391 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10392 
      return
10393 
    iprot.readStructBegin()
10394 
    while True:
10395 
      (fname, ftype, fid) = iprot.readFieldBegin()
10396 
      if ftype == TType.STOP:
10397 
        break
10398 
      if fid == 0:
483 rajveer 10399 
        if ftype == TType.LIST:
10400 
          self.success = []
5031 varun.gupt 10401 
          (_etype164, _size161) = iprot.readListBegin()
10402 
          for _i165 in xrange(_size161):
10403 
            _elem166 = LineItem()
10404 
            _elem166.read(iprot)
10405 
            self.success.append(_elem166)
483 rajveer 10406 
          iprot.readListEnd()
94 ashish 10407 
        else:
10408 
          iprot.skip(ftype)
10409 
      elif fid == 1:
10410 
        if ftype == TType.STRUCT:
10411 
          self.ex = TransactionServiceException()
10412 
          self.ex.read(iprot)
10413 
        else:
10414 
          iprot.skip(ftype)
10415 
      else:
10416 
        iprot.skip(ftype)
10417 
      iprot.readFieldEnd()
10418 
    iprot.readStructEnd()
10419 
 
10420 
  def write(self, oprot):
10421 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10422 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10423 
      return
3064 chandransh 10424 
    oprot.writeStructBegin('getLineItemsForOrder_result')
3431 rajveer 10425 
    if self.success is not None:
483 rajveer 10426 
      oprot.writeFieldBegin('success', TType.LIST, 0)
10427 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
5031 varun.gupt 10428 
      for iter167 in self.success:
10429 
        iter167.write(oprot)
483 rajveer 10430 
      oprot.writeListEnd()
94 ashish 10431 
      oprot.writeFieldEnd()
3431 rajveer 10432 
    if self.ex is not None:
94 ashish 10433 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
10434 
      self.ex.write(oprot)
10435 
      oprot.writeFieldEnd()
10436 
    oprot.writeFieldStop()
10437 
    oprot.writeStructEnd()
10438 
 
3431 rajveer 10439 
  def validate(self):
10440 
    return
10441 
 
10442 
 
94 ashish 10443 
  def __repr__(self):
10444 
    L = ['%s=%r' % (key, value)
10445 
      for key, value in self.__dict__.iteritems()]
10446 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10447 
 
10448 
  def __eq__(self, other):
10449 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10450 
 
10451 
  def __ne__(self, other):
10452 
    return not (self == other)
10453 
 
4999 phani.kuma 10454 
class getOrderList_args:
10455 
  """
10456 
  Attributes:
10457 
   - order_ids
10458 
  """
10459 
 
10460 
  thrift_spec = (
10461 
    None, # 0
10462 
    (1, TType.LIST, 'order_ids', (TType.I64,None), None, ), # 1
10463 
  )
10464 
 
10465 
  def __init__(self, order_ids=None,):
10466 
    self.order_ids = order_ids
10467 
 
10468 
  def read(self, iprot):
10469 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10470 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10471 
      return
10472 
    iprot.readStructBegin()
10473 
    while True:
10474 
      (fname, ftype, fid) = iprot.readFieldBegin()
10475 
      if ftype == TType.STOP:
10476 
        break
10477 
      if fid == 1:
10478 
        if ftype == TType.LIST:
10479 
          self.order_ids = []
5031 varun.gupt 10480 
          (_etype171, _size168) = iprot.readListBegin()
10481 
          for _i172 in xrange(_size168):
10482 
            _elem173 = iprot.readI64();
10483 
            self.order_ids.append(_elem173)
4999 phani.kuma 10484 
          iprot.readListEnd()
10485 
        else:
10486 
          iprot.skip(ftype)
10487 
      else:
10488 
        iprot.skip(ftype)
10489 
      iprot.readFieldEnd()
10490 
    iprot.readStructEnd()
10491 
 
10492 
  def write(self, oprot):
10493 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10494 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10495 
      return
10496 
    oprot.writeStructBegin('getOrderList_args')
10497 
    if self.order_ids is not None:
10498 
      oprot.writeFieldBegin('order_ids', TType.LIST, 1)
10499 
      oprot.writeListBegin(TType.I64, len(self.order_ids))
5031 varun.gupt 10500 
      for iter174 in self.order_ids:
10501 
        oprot.writeI64(iter174)
4999 phani.kuma 10502 
      oprot.writeListEnd()
10503 
      oprot.writeFieldEnd()
10504 
    oprot.writeFieldStop()
10505 
    oprot.writeStructEnd()
10506 
 
10507 
  def validate(self):
10508 
    return
10509 
 
10510 
 
10511 
  def __repr__(self):
10512 
    L = ['%s=%r' % (key, value)
10513 
      for key, value in self.__dict__.iteritems()]
10514 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10515 
 
10516 
  def __eq__(self, other):
10517 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10518 
 
10519 
  def __ne__(self, other):
10520 
    return not (self == other)
10521 
 
10522 
class getOrderList_result:
10523 
  """
10524 
  Attributes:
10525 
   - success
10526 
  """
10527 
 
10528 
  thrift_spec = (
10529 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
10530 
  )
10531 
 
10532 
  def __init__(self, success=None,):
10533 
    self.success = success
10534 
 
10535 
  def read(self, iprot):
10536 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10537 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10538 
      return
10539 
    iprot.readStructBegin()
10540 
    while True:
10541 
      (fname, ftype, fid) = iprot.readFieldBegin()
10542 
      if ftype == TType.STOP:
10543 
        break
10544 
      if fid == 0:
10545 
        if ftype == TType.LIST:
10546 
          self.success = []
5031 varun.gupt 10547 
          (_etype178, _size175) = iprot.readListBegin()
10548 
          for _i179 in xrange(_size175):
10549 
            _elem180 = Order()
10550 
            _elem180.read(iprot)
10551 
            self.success.append(_elem180)
4999 phani.kuma 10552 
          iprot.readListEnd()
10553 
        else:
10554 
          iprot.skip(ftype)
10555 
      else:
10556 
        iprot.skip(ftype)
10557 
      iprot.readFieldEnd()
10558 
    iprot.readStructEnd()
10559 
 
10560 
  def write(self, oprot):
10561 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10562 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10563 
      return
10564 
    oprot.writeStructBegin('getOrderList_result')
10565 
    if self.success is not None:
10566 
      oprot.writeFieldBegin('success', TType.LIST, 0)
10567 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
5031 varun.gupt 10568 
      for iter181 in self.success:
10569 
        iter181.write(oprot)
4999 phani.kuma 10570 
      oprot.writeListEnd()
10571 
      oprot.writeFieldEnd()
10572 
    oprot.writeFieldStop()
10573 
    oprot.writeStructEnd()
10574 
 
10575 
  def validate(self):
10576 
    return
10577 
 
10578 
 
10579 
  def __repr__(self):
10580 
    L = ['%s=%r' % (key, value)
10581 
      for key, value in self.__dict__.iteritems()]
10582 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10583 
 
10584 
  def __eq__(self, other):
10585 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10586 
 
10587 
  def __ne__(self, other):
10588 
    return not (self == other)
10589 
 
5386 phani.kuma 10590 
class getOrderListForVendor_args:
10591 
  """
10592 
  Attributes:
10593 
   - order_ids
10594 
   - vendorId
10595 
  """
10596 
 
10597 
  thrift_spec = (
10598 
    None, # 0
10599 
    (1, TType.LIST, 'order_ids', (TType.I64,None), None, ), # 1
10600 
    (2, TType.I64, 'vendorId', None, None, ), # 2
10601 
  )
10602 
 
10603 
  def __init__(self, order_ids=None, vendorId=None,):
10604 
    self.order_ids = order_ids
10605 
    self.vendorId = vendorId
10606 
 
10607 
  def read(self, iprot):
10608 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10609 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10610 
      return
10611 
    iprot.readStructBegin()
10612 
    while True:
10613 
      (fname, ftype, fid) = iprot.readFieldBegin()
10614 
      if ftype == TType.STOP:
10615 
        break
10616 
      if fid == 1:
10617 
        if ftype == TType.LIST:
10618 
          self.order_ids = []
10619 
          (_etype185, _size182) = iprot.readListBegin()
10620 
          for _i186 in xrange(_size182):
10621 
            _elem187 = iprot.readI64();
10622 
            self.order_ids.append(_elem187)
10623 
          iprot.readListEnd()
10624 
        else:
10625 
          iprot.skip(ftype)
10626 
      elif fid == 2:
10627 
        if ftype == TType.I64:
10628 
          self.vendorId = iprot.readI64();
10629 
        else:
10630 
          iprot.skip(ftype)
10631 
      else:
10632 
        iprot.skip(ftype)
10633 
      iprot.readFieldEnd()
10634 
    iprot.readStructEnd()
10635 
 
10636 
  def write(self, oprot):
10637 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10638 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10639 
      return
10640 
    oprot.writeStructBegin('getOrderListForVendor_args')
10641 
    if self.order_ids is not None:
10642 
      oprot.writeFieldBegin('order_ids', TType.LIST, 1)
10643 
      oprot.writeListBegin(TType.I64, len(self.order_ids))
10644 
      for iter188 in self.order_ids:
10645 
        oprot.writeI64(iter188)
10646 
      oprot.writeListEnd()
10647 
      oprot.writeFieldEnd()
10648 
    if self.vendorId is not None:
10649 
      oprot.writeFieldBegin('vendorId', TType.I64, 2)
10650 
      oprot.writeI64(self.vendorId)
10651 
      oprot.writeFieldEnd()
10652 
    oprot.writeFieldStop()
10653 
    oprot.writeStructEnd()
10654 
 
10655 
  def validate(self):
10656 
    return
10657 
 
10658 
 
10659 
  def __repr__(self):
10660 
    L = ['%s=%r' % (key, value)
10661 
      for key, value in self.__dict__.iteritems()]
10662 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10663 
 
10664 
  def __eq__(self, other):
10665 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10666 
 
10667 
  def __ne__(self, other):
10668 
    return not (self == other)
10669 
 
10670 
class getOrderListForVendor_result:
10671 
  """
10672 
  Attributes:
10673 
   - success
10674 
  """
10675 
 
10676 
  thrift_spec = (
10677 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
10678 
  )
10679 
 
10680 
  def __init__(self, success=None,):
10681 
    self.success = success
10682 
 
10683 
  def read(self, iprot):
10684 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10685 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10686 
      return
10687 
    iprot.readStructBegin()
10688 
    while True:
10689 
      (fname, ftype, fid) = iprot.readFieldBegin()
10690 
      if ftype == TType.STOP:
10691 
        break
10692 
      if fid == 0:
10693 
        if ftype == TType.LIST:
10694 
          self.success = []
10695 
          (_etype192, _size189) = iprot.readListBegin()
10696 
          for _i193 in xrange(_size189):
10697 
            _elem194 = Order()
10698 
            _elem194.read(iprot)
10699 
            self.success.append(_elem194)
10700 
          iprot.readListEnd()
10701 
        else:
10702 
          iprot.skip(ftype)
10703 
      else:
10704 
        iprot.skip(ftype)
10705 
      iprot.readFieldEnd()
10706 
    iprot.readStructEnd()
10707 
 
10708 
  def write(self, oprot):
10709 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10710 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10711 
      return
10712 
    oprot.writeStructBegin('getOrderListForVendor_result')
10713 
    if self.success is not None:
10714 
      oprot.writeFieldBegin('success', TType.LIST, 0)
10715 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
10716 
      for iter195 in self.success:
10717 
        iter195.write(oprot)
10718 
      oprot.writeListEnd()
10719 
      oprot.writeFieldEnd()
10720 
    oprot.writeFieldStop()
10721 
    oprot.writeStructEnd()
10722 
 
10723 
  def validate(self):
10724 
    return
10725 
 
10726 
 
10727 
  def __repr__(self):
10728 
    L = ['%s=%r' % (key, value)
10729 
      for key, value in self.__dict__.iteritems()]
10730 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10731 
 
10732 
  def __eq__(self, other):
10733 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10734 
 
10735 
  def __ne__(self, other):
10736 
    return not (self == other)
10737 
 
3064 chandransh 10738 
class getOrderForCustomer_args:
94 ashish 10739 
  """
10740 
  Attributes:
3064 chandransh 10741 
   - orderId
483 rajveer 10742 
   - customerId
94 ashish 10743 
  """
10744 
 
10745 
  thrift_spec = (
10746 
    None, # 0
3064 chandransh 10747 
    (1, TType.I64, 'orderId', None, None, ), # 1
10748 
    (2, TType.I64, 'customerId', None, None, ), # 2
94 ashish 10749 
  )
10750 
 
3064 chandransh 10751 
  def __init__(self, orderId=None, customerId=None,):
10752 
    self.orderId = orderId
483 rajveer 10753 
    self.customerId = customerId
94 ashish 10754 
 
10755 
  def read(self, iprot):
10756 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10757 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10758 
      return
10759 
    iprot.readStructBegin()
10760 
    while True:
10761 
      (fname, ftype, fid) = iprot.readFieldBegin()
10762 
      if ftype == TType.STOP:
10763 
        break
10764 
      if fid == 1:
10765 
        if ftype == TType.I64:
3064 chandransh 10766 
          self.orderId = iprot.readI64();
94 ashish 10767 
        else:
10768 
          iprot.skip(ftype)
10769 
      elif fid == 2:
10770 
        if ftype == TType.I64:
3064 chandransh 10771 
          self.customerId = iprot.readI64();
94 ashish 10772 
        else:
10773 
          iprot.skip(ftype)
10774 
      else:
10775 
        iprot.skip(ftype)
10776 
      iprot.readFieldEnd()
10777 
    iprot.readStructEnd()
10778 
 
10779 
  def write(self, oprot):
10780 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10781 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10782 
      return
3064 chandransh 10783 
    oprot.writeStructBegin('getOrderForCustomer_args')
3431 rajveer 10784 
    if self.orderId is not None:
3064 chandransh 10785 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
10786 
      oprot.writeI64(self.orderId)
10787 
      oprot.writeFieldEnd()
3431 rajveer 10788 
    if self.customerId is not None:
3064 chandransh 10789 
      oprot.writeFieldBegin('customerId', TType.I64, 2)
483 rajveer 10790 
      oprot.writeI64(self.customerId)
94 ashish 10791 
      oprot.writeFieldEnd()
10792 
    oprot.writeFieldStop()
10793 
    oprot.writeStructEnd()
10794 
 
3431 rajveer 10795 
  def validate(self):
10796 
    return
10797 
 
10798 
 
94 ashish 10799 
  def __repr__(self):
10800 
    L = ['%s=%r' % (key, value)
10801 
      for key, value in self.__dict__.iteritems()]
10802 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10803 
 
10804 
  def __eq__(self, other):
10805 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10806 
 
10807 
  def __ne__(self, other):
10808 
    return not (self == other)
10809 
 
3064 chandransh 10810 
class getOrderForCustomer_result:
94 ashish 10811 
  """
10812 
  Attributes:
10813 
   - success
10814 
   - ex
10815 
  """
10816 
 
10817 
  thrift_spec = (
3064 chandransh 10818 
    (0, TType.STRUCT, 'success', (Order, Order.thrift_spec), None, ), # 0
94 ashish 10819 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
10820 
  )
10821 
 
10822 
  def __init__(self, success=None, ex=None,):
10823 
    self.success = success
10824 
    self.ex = ex
10825 
 
10826 
  def read(self, iprot):
10827 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10828 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10829 
      return
10830 
    iprot.readStructBegin()
10831 
    while True:
10832 
      (fname, ftype, fid) = iprot.readFieldBegin()
10833 
      if ftype == TType.STOP:
10834 
        break
10835 
      if fid == 0:
3064 chandransh 10836 
        if ftype == TType.STRUCT:
10837 
          self.success = Order()
10838 
          self.success.read(iprot)
94 ashish 10839 
        else:
10840 
          iprot.skip(ftype)
10841 
      elif fid == 1:
10842 
        if ftype == TType.STRUCT:
10843 
          self.ex = TransactionServiceException()
10844 
          self.ex.read(iprot)
10845 
        else:
10846 
          iprot.skip(ftype)
10847 
      else:
10848 
        iprot.skip(ftype)
10849 
      iprot.readFieldEnd()
10850 
    iprot.readStructEnd()
10851 
 
10852 
  def write(self, oprot):
10853 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10854 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10855 
      return
3064 chandransh 10856 
    oprot.writeStructBegin('getOrderForCustomer_result')
3431 rajveer 10857 
    if self.success is not None:
3064 chandransh 10858 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
10859 
      self.success.write(oprot)
94 ashish 10860 
      oprot.writeFieldEnd()
3431 rajveer 10861 
    if self.ex is not None:
94 ashish 10862 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
10863 
      self.ex.write(oprot)
10864 
      oprot.writeFieldEnd()
10865 
    oprot.writeFieldStop()
10866 
    oprot.writeStructEnd()
10867 
 
3431 rajveer 10868 
  def validate(self):
10869 
    return
10870 
 
10871 
 
94 ashish 10872 
  def __repr__(self):
10873 
    L = ['%s=%r' % (key, value)
10874 
      for key, value in self.__dict__.iteritems()]
10875 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10876 
 
10877 
  def __eq__(self, other):
10878 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10879 
 
10880 
  def __ne__(self, other):
10881 
    return not (self == other)
10882 
 
3064 chandransh 10883 
class getAlerts_args:
94 ashish 10884 
  """
10885 
  Attributes:
4394 rajveer 10886 
   - type
4444 rajveer 10887 
   - warehouseId
4394 rajveer 10888 
   - status
10889 
   - timestamp
94 ashish 10890 
  """
10891 
 
10892 
  thrift_spec = (
10893 
    None, # 0
4394 rajveer 10894 
    (1, TType.I64, 'type', None, None, ), # 1
4444 rajveer 10895 
    (2, TType.I64, 'warehouseId', None, None, ), # 2
10896 
    (3, TType.I64, 'status', None, None, ), # 3
10897 
    (4, TType.I64, 'timestamp', None, None, ), # 4
94 ashish 10898 
  )
10899 
 
4444 rajveer 10900 
  def __init__(self, type=None, warehouseId=None, status=None, timestamp=None,):
4394 rajveer 10901 
    self.type = type
4444 rajveer 10902 
    self.warehouseId = warehouseId
4394 rajveer 10903 
    self.status = status
10904 
    self.timestamp = timestamp
94 ashish 10905 
 
10906 
  def read(self, iprot):
10907 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10908 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10909 
      return
10910 
    iprot.readStructBegin()
10911 
    while True:
10912 
      (fname, ftype, fid) = iprot.readFieldBegin()
10913 
      if ftype == TType.STOP:
10914 
        break
10915 
      if fid == 1:
3064 chandransh 10916 
        if ftype == TType.I64:
4394 rajveer 10917 
          self.type = iprot.readI64();
94 ashish 10918 
        else:
10919 
          iprot.skip(ftype)
3064 chandransh 10920 
      elif fid == 2:
4394 rajveer 10921 
        if ftype == TType.I64:
4444 rajveer 10922 
          self.warehouseId = iprot.readI64();
3064 chandransh 10923 
        else:
10924 
          iprot.skip(ftype)
4394 rajveer 10925 
      elif fid == 3:
10926 
        if ftype == TType.I64:
4444 rajveer 10927 
          self.status = iprot.readI64();
10928 
        else:
10929 
          iprot.skip(ftype)
10930 
      elif fid == 4:
10931 
        if ftype == TType.I64:
4394 rajveer 10932 
          self.timestamp = iprot.readI64();
10933 
        else:
10934 
          iprot.skip(ftype)
94 ashish 10935 
      else:
10936 
        iprot.skip(ftype)
10937 
      iprot.readFieldEnd()
10938 
    iprot.readStructEnd()
10939 
 
10940 
  def write(self, oprot):
10941 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10942 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10943 
      return
3064 chandransh 10944 
    oprot.writeStructBegin('getAlerts_args')
4394 rajveer 10945 
    if self.type is not None:
10946 
      oprot.writeFieldBegin('type', TType.I64, 1)
10947 
      oprot.writeI64(self.type)
94 ashish 10948 
      oprot.writeFieldEnd()
4444 rajveer 10949 
    if self.warehouseId is not None:
10950 
      oprot.writeFieldBegin('warehouseId', TType.I64, 2)
10951 
      oprot.writeI64(self.warehouseId)
10952 
      oprot.writeFieldEnd()
4394 rajveer 10953 
    if self.status is not None:
4444 rajveer 10954 
      oprot.writeFieldBegin('status', TType.I64, 3)
4394 rajveer 10955 
      oprot.writeI64(self.status)
3064 chandransh 10956 
      oprot.writeFieldEnd()
4394 rajveer 10957 
    if self.timestamp is not None:
4444 rajveer 10958 
      oprot.writeFieldBegin('timestamp', TType.I64, 4)
4394 rajveer 10959 
      oprot.writeI64(self.timestamp)
10960 
      oprot.writeFieldEnd()
94 ashish 10961 
    oprot.writeFieldStop()
10962 
    oprot.writeStructEnd()
10963 
 
3431 rajveer 10964 
  def validate(self):
10965 
    return
10966 
 
10967 
 
94 ashish 10968 
  def __repr__(self):
10969 
    L = ['%s=%r' % (key, value)
10970 
      for key, value in self.__dict__.iteritems()]
10971 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10972 
 
10973 
  def __eq__(self, other):
10974 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10975 
 
10976 
  def __ne__(self, other):
10977 
    return not (self == other)
10978 
 
3064 chandransh 10979 
class getAlerts_result:
94 ashish 10980 
  """
10981 
  Attributes:
10982 
   - success
10983 
  """
10984 
 
10985 
  thrift_spec = (
3064 chandransh 10986 
    (0, TType.LIST, 'success', (TType.STRUCT,(Alert, Alert.thrift_spec)), None, ), # 0
94 ashish 10987 
  )
10988 
 
3064 chandransh 10989 
  def __init__(self, success=None,):
94 ashish 10990 
    self.success = success
10991 
 
10992 
  def read(self, iprot):
10993 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10994 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10995 
      return
10996 
    iprot.readStructBegin()
10997 
    while True:
10998 
      (fname, ftype, fid) = iprot.readFieldBegin()
10999 
      if ftype == TType.STOP:
11000 
        break
11001 
      if fid == 0:
3064 chandransh 11002 
        if ftype == TType.LIST:
11003 
          self.success = []
5386 phani.kuma 11004 
          (_etype199, _size196) = iprot.readListBegin()
11005 
          for _i200 in xrange(_size196):
11006 
            _elem201 = Alert()
11007 
            _elem201.read(iprot)
11008 
            self.success.append(_elem201)
3064 chandransh 11009 
          iprot.readListEnd()
94 ashish 11010 
        else:
11011 
          iprot.skip(ftype)
11012 
      else:
11013 
        iprot.skip(ftype)
11014 
      iprot.readFieldEnd()
11015 
    iprot.readStructEnd()
11016 
 
11017 
  def write(self, oprot):
11018 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11019 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11020 
      return
3064 chandransh 11021 
    oprot.writeStructBegin('getAlerts_result')
3431 rajveer 11022 
    if self.success is not None:
3064 chandransh 11023 
      oprot.writeFieldBegin('success', TType.LIST, 0)
11024 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
5386 phani.kuma 11025 
      for iter202 in self.success:
11026 
        iter202.write(oprot)
3064 chandransh 11027 
      oprot.writeListEnd()
94 ashish 11028 
      oprot.writeFieldEnd()
11029 
    oprot.writeFieldStop()
11030 
    oprot.writeStructEnd()
11031 
 
3431 rajveer 11032 
  def validate(self):
11033 
    return
11034 
 
11035 
 
94 ashish 11036 
  def __repr__(self):
11037 
    L = ['%s=%r' % (key, value)
11038 
      for key, value in self.__dict__.iteritems()]
11039 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11040 
 
11041 
  def __eq__(self, other):
11042 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11043 
 
11044 
  def __ne__(self, other):
11045 
    return not (self == other)
11046 
 
4394 rajveer 11047 
class addAlert_args:
94 ashish 11048 
  """
11049 
  Attributes:
3064 chandransh 11050 
   - type
4444 rajveer 11051 
   - warehouseId
4394 rajveer 11052 
   - description
94 ashish 11053 
  """
11054 
 
11055 
  thrift_spec = (
11056 
    None, # 0
4394 rajveer 11057 
    (1, TType.I64, 'type', None, None, ), # 1
4444 rajveer 11058 
    (2, TType.I64, 'warehouseId', None, None, ), # 2
11059 
    (3, TType.STRING, 'description', None, None, ), # 3
94 ashish 11060 
  )
11061 
 
4444 rajveer 11062 
  def __init__(self, type=None, warehouseId=None, description=None,):
3064 chandransh 11063 
    self.type = type
4444 rajveer 11064 
    self.warehouseId = warehouseId
4394 rajveer 11065 
    self.description = description
94 ashish 11066 
 
11067 
  def read(self, iprot):
11068 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11069 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11070 
      return
11071 
    iprot.readStructBegin()
11072 
    while True:
11073 
      (fname, ftype, fid) = iprot.readFieldBegin()
11074 
      if ftype == TType.STOP:
11075 
        break
11076 
      if fid == 1:
11077 
        if ftype == TType.I64:
4394 rajveer 11078 
          self.type = iprot.readI64();
94 ashish 11079 
        else:
11080 
          iprot.skip(ftype)
3064 chandransh 11081 
      elif fid == 2:
4444 rajveer 11082 
        if ftype == TType.I64:
11083 
          self.warehouseId = iprot.readI64();
11084 
        else:
11085 
          iprot.skip(ftype)
11086 
      elif fid == 3:
3064 chandransh 11087 
        if ftype == TType.STRING:
4394 rajveer 11088 
          self.description = iprot.readString();
3064 chandransh 11089 
        else:
11090 
          iprot.skip(ftype)
94 ashish 11091 
      else:
11092 
        iprot.skip(ftype)
11093 
      iprot.readFieldEnd()
11094 
    iprot.readStructEnd()
11095 
 
11096 
  def write(self, oprot):
11097 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11098 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11099 
      return
4394 rajveer 11100 
    oprot.writeStructBegin('addAlert_args')
3431 rajveer 11101 
    if self.type is not None:
4394 rajveer 11102 
      oprot.writeFieldBegin('type', TType.I64, 1)
3064 chandransh 11103 
      oprot.writeI64(self.type)
11104 
      oprot.writeFieldEnd()
4444 rajveer 11105 
    if self.warehouseId is not None:
11106 
      oprot.writeFieldBegin('warehouseId', TType.I64, 2)
11107 
      oprot.writeI64(self.warehouseId)
11108 
      oprot.writeFieldEnd()
4394 rajveer 11109 
    if self.description is not None:
4444 rajveer 11110 
      oprot.writeFieldBegin('description', TType.STRING, 3)
4394 rajveer 11111 
      oprot.writeString(self.description)
3064 chandransh 11112 
      oprot.writeFieldEnd()
94 ashish 11113 
    oprot.writeFieldStop()
11114 
    oprot.writeStructEnd()
11115 
 
3431 rajveer 11116 
  def validate(self):
11117 
    return
11118 
 
11119 
 
94 ashish 11120 
  def __repr__(self):
11121 
    L = ['%s=%r' % (key, value)
11122 
      for key, value in self.__dict__.iteritems()]
11123 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11124 
 
11125 
  def __eq__(self, other):
11126 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11127 
 
11128 
  def __ne__(self, other):
11129 
    return not (self == other)
11130 
 
4394 rajveer 11131 
class addAlert_result:
3064 chandransh 11132 
 
11133 
  thrift_spec = (
11134 
  )
11135 
 
11136 
  def read(self, iprot):
11137 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11138 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11139 
      return
11140 
    iprot.readStructBegin()
11141 
    while True:
11142 
      (fname, ftype, fid) = iprot.readFieldBegin()
11143 
      if ftype == TType.STOP:
11144 
        break
11145 
      else:
11146 
        iprot.skip(ftype)
11147 
      iprot.readFieldEnd()
11148 
    iprot.readStructEnd()
11149 
 
11150 
  def write(self, oprot):
11151 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11152 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11153 
      return
4394 rajveer 11154 
    oprot.writeStructBegin('addAlert_result')
3064 chandransh 11155 
    oprot.writeFieldStop()
11156 
    oprot.writeStructEnd()
11157 
 
3431 rajveer 11158 
  def validate(self):
11159 
    return
11160 
 
11161 
 
3064 chandransh 11162 
  def __repr__(self):
11163 
    L = ['%s=%r' % (key, value)
11164 
      for key, value in self.__dict__.iteritems()]
11165 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11166 
 
11167 
  def __eq__(self, other):
11168 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11169 
 
11170 
  def __ne__(self, other):
11171 
    return not (self == other)
11172 
 
4444 rajveer 11173 
class markAlertsAsSeen_args:
11174 
  """
11175 
  Attributes:
11176 
   - warehouseId
11177 
  """
11178 
 
11179 
  thrift_spec = (
11180 
    None, # 0
11181 
    (1, TType.I64, 'warehouseId', None, None, ), # 1
11182 
  )
11183 
 
11184 
  def __init__(self, warehouseId=None,):
11185 
    self.warehouseId = warehouseId
11186 
 
11187 
  def read(self, iprot):
11188 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11189 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11190 
      return
11191 
    iprot.readStructBegin()
11192 
    while True:
11193 
      (fname, ftype, fid) = iprot.readFieldBegin()
11194 
      if ftype == TType.STOP:
11195 
        break
11196 
      if fid == 1:
11197 
        if ftype == TType.I64:
11198 
          self.warehouseId = iprot.readI64();
11199 
        else:
11200 
          iprot.skip(ftype)
11201 
      else:
11202 
        iprot.skip(ftype)
11203 
      iprot.readFieldEnd()
11204 
    iprot.readStructEnd()
11205 
 
11206 
  def write(self, oprot):
11207 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11208 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11209 
      return
11210 
    oprot.writeStructBegin('markAlertsAsSeen_args')
11211 
    if self.warehouseId is not None:
11212 
      oprot.writeFieldBegin('warehouseId', TType.I64, 1)
11213 
      oprot.writeI64(self.warehouseId)
11214 
      oprot.writeFieldEnd()
11215 
    oprot.writeFieldStop()
11216 
    oprot.writeStructEnd()
11217 
 
11218 
  def validate(self):
11219 
    return
11220 
 
11221 
 
11222 
  def __repr__(self):
11223 
    L = ['%s=%r' % (key, value)
11224 
      for key, value in self.__dict__.iteritems()]
11225 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11226 
 
11227 
  def __eq__(self, other):
11228 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11229 
 
11230 
  def __ne__(self, other):
11231 
    return not (self == other)
11232 
 
11233 
class markAlertsAsSeen_result:
11234 
 
11235 
  thrift_spec = (
11236 
  )
11237 
 
11238 
  def read(self, iprot):
11239 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11240 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11241 
      return
11242 
    iprot.readStructBegin()
11243 
    while True:
11244 
      (fname, ftype, fid) = iprot.readFieldBegin()
11245 
      if ftype == TType.STOP:
11246 
        break
11247 
      else:
11248 
        iprot.skip(ftype)
11249 
      iprot.readFieldEnd()
11250 
    iprot.readStructEnd()
11251 
 
11252 
  def write(self, oprot):
11253 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11254 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11255 
      return
11256 
    oprot.writeStructBegin('markAlertsAsSeen_result')
11257 
    oprot.writeFieldStop()
11258 
    oprot.writeStructEnd()
11259 
 
11260 
  def validate(self):
11261 
    return
11262 
 
11263 
 
11264 
  def __repr__(self):
11265 
    L = ['%s=%r' % (key, value)
11266 
      for key, value in self.__dict__.iteritems()]
11267 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11268 
 
11269 
  def __eq__(self, other):
11270 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11271 
 
11272 
  def __ne__(self, other):
11273 
    return not (self == other)
11274 
 
3064 chandransh 11275 
class getValidOrderCount_args:
11276 
 
11277 
  thrift_spec = (
11278 
  )
11279 
 
11280 
  def read(self, iprot):
11281 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11282 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11283 
      return
11284 
    iprot.readStructBegin()
11285 
    while True:
11286 
      (fname, ftype, fid) = iprot.readFieldBegin()
11287 
      if ftype == TType.STOP:
11288 
        break
11289 
      else:
11290 
        iprot.skip(ftype)
11291 
      iprot.readFieldEnd()
11292 
    iprot.readStructEnd()
11293 
 
11294 
  def write(self, oprot):
11295 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11296 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11297 
      return
11298 
    oprot.writeStructBegin('getValidOrderCount_args')
11299 
    oprot.writeFieldStop()
11300 
    oprot.writeStructEnd()
11301 
 
3431 rajveer 11302 
  def validate(self):
11303 
    return
11304 
 
11305 
 
3064 chandransh 11306 
  def __repr__(self):
11307 
    L = ['%s=%r' % (key, value)
11308 
      for key, value in self.__dict__.iteritems()]
11309 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11310 
 
11311 
  def __eq__(self, other):
11312 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11313 
 
11314 
  def __ne__(self, other):
11315 
    return not (self == other)
11316 
 
11317 
class getValidOrderCount_result:
94 ashish 11318 
  """
11319 
  Attributes:
11320 
   - success
11321 
  """
11322 
 
11323 
  thrift_spec = (
3064 chandransh 11324 
    (0, TType.I64, 'success', None, None, ), # 0
94 ashish 11325 
  )
11326 
 
3064 chandransh 11327 
  def __init__(self, success=None,):
94 ashish 11328 
    self.success = success
11329 
 
11330 
  def read(self, iprot):
11331 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11332 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11333 
      return
11334 
    iprot.readStructBegin()
11335 
    while True:
11336 
      (fname, ftype, fid) = iprot.readFieldBegin()
11337 
      if ftype == TType.STOP:
11338 
        break
11339 
      if fid == 0:
3064 chandransh 11340 
        if ftype == TType.I64:
11341 
          self.success = iprot.readI64();
94 ashish 11342 
        else:
11343 
          iprot.skip(ftype)
11344 
      else:
11345 
        iprot.skip(ftype)
11346 
      iprot.readFieldEnd()
11347 
    iprot.readStructEnd()
11348 
 
11349 
  def write(self, oprot):
11350 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11351 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11352 
      return
3064 chandransh 11353 
    oprot.writeStructBegin('getValidOrderCount_result')
3431 rajveer 11354 
    if self.success is not None:
3064 chandransh 11355 
      oprot.writeFieldBegin('success', TType.I64, 0)
11356 
      oprot.writeI64(self.success)
94 ashish 11357 
      oprot.writeFieldEnd()
11358 
    oprot.writeFieldStop()
11359 
    oprot.writeStructEnd()
11360 
 
3431 rajveer 11361 
  def validate(self):
11362 
    return
11363 
 
11364 
 
94 ashish 11365 
  def __repr__(self):
11366 
    L = ['%s=%r' % (key, value)
11367 
      for key, value in self.__dict__.iteritems()]
11368 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11369 
 
11370 
  def __eq__(self, other):
11371 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11372 
 
11373 
  def __ne__(self, other):
11374 
    return not (self == other)
11375 
 
3064 chandransh 11376 
class getNoOfCustomersWithSuccessfulTransaction_args:
11377 
 
11378 
  thrift_spec = (
11379 
  )
11380 
 
11381 
  def read(self, iprot):
11382 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11383 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11384 
      return
11385 
    iprot.readStructBegin()
11386 
    while True:
11387 
      (fname, ftype, fid) = iprot.readFieldBegin()
11388 
      if ftype == TType.STOP:
11389 
        break
11390 
      else:
11391 
        iprot.skip(ftype)
11392 
      iprot.readFieldEnd()
11393 
    iprot.readStructEnd()
11394 
 
11395 
  def write(self, oprot):
11396 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11397 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11398 
      return
11399 
    oprot.writeStructBegin('getNoOfCustomersWithSuccessfulTransaction_args')
11400 
    oprot.writeFieldStop()
11401 
    oprot.writeStructEnd()
11402 
 
3431 rajveer 11403 
  def validate(self):
11404 
    return
11405 
 
11406 
 
3064 chandransh 11407 
  def __repr__(self):
11408 
    L = ['%s=%r' % (key, value)
11409 
      for key, value in self.__dict__.iteritems()]
11410 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11411 
 
11412 
  def __eq__(self, other):
11413 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11414 
 
11415 
  def __ne__(self, other):
11416 
    return not (self == other)
11417 
 
11418 
class getNoOfCustomersWithSuccessfulTransaction_result:
94 ashish 11419 
  """
11420 
  Attributes:
3064 chandransh 11421 
   - success
94 ashish 11422 
  """
11423 
 
11424 
  thrift_spec = (
3064 chandransh 11425 
    (0, TType.I64, 'success', None, None, ), # 0
94 ashish 11426 
  )
11427 
 
3064 chandransh 11428 
  def __init__(self, success=None,):
11429 
    self.success = success
94 ashish 11430 
 
11431 
  def read(self, iprot):
11432 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11433 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11434 
      return
11435 
    iprot.readStructBegin()
11436 
    while True:
11437 
      (fname, ftype, fid) = iprot.readFieldBegin()
11438 
      if ftype == TType.STOP:
11439 
        break
3064 chandransh 11440 
      if fid == 0:
94 ashish 11441 
        if ftype == TType.I64:
3064 chandransh 11442 
          self.success = iprot.readI64();
94 ashish 11443 
        else:
11444 
          iprot.skip(ftype)
11445 
      else:
11446 
        iprot.skip(ftype)
11447 
      iprot.readFieldEnd()
11448 
    iprot.readStructEnd()
11449 
 
11450 
  def write(self, oprot):
11451 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11452 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11453 
      return
3064 chandransh 11454 
    oprot.writeStructBegin('getNoOfCustomersWithSuccessfulTransaction_result')
3431 rajveer 11455 
    if self.success is not None:
3064 chandransh 11456 
      oprot.writeFieldBegin('success', TType.I64, 0)
11457 
      oprot.writeI64(self.success)
94 ashish 11458 
      oprot.writeFieldEnd()
11459 
    oprot.writeFieldStop()
11460 
    oprot.writeStructEnd()
11461 
 
3431 rajveer 11462 
  def validate(self):
11463 
    return
11464 
 
11465 
 
94 ashish 11466 
  def __repr__(self):
11467 
    L = ['%s=%r' % (key, value)
11468 
      for key, value in self.__dict__.iteritems()]
11469 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11470 
 
11471 
  def __eq__(self, other):
11472 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11473 
 
11474 
  def __ne__(self, other):
11475 
    return not (self == other)
11476 
 
3064 chandransh 11477 
class getValidOrdersAmountRange_args:
11478 
 
11479 
  thrift_spec = (
11480 
  )
11481 
 
11482 
  def read(self, iprot):
11483 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11484 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11485 
      return
11486 
    iprot.readStructBegin()
11487 
    while True:
11488 
      (fname, ftype, fid) = iprot.readFieldBegin()
11489 
      if ftype == TType.STOP:
11490 
        break
11491 
      else:
11492 
        iprot.skip(ftype)
11493 
      iprot.readFieldEnd()
11494 
    iprot.readStructEnd()
11495 
 
11496 
  def write(self, oprot):
11497 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11498 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11499 
      return
11500 
    oprot.writeStructBegin('getValidOrdersAmountRange_args')
11501 
    oprot.writeFieldStop()
11502 
    oprot.writeStructEnd()
11503 
 
3431 rajveer 11504 
  def validate(self):
11505 
    return
11506 
 
11507 
 
3064 chandransh 11508 
  def __repr__(self):
11509 
    L = ['%s=%r' % (key, value)
11510 
      for key, value in self.__dict__.iteritems()]
11511 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11512 
 
11513 
  def __eq__(self, other):
11514 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11515 
 
11516 
  def __ne__(self, other):
11517 
    return not (self == other)
11518 
 
11519 
class getValidOrdersAmountRange_result:
94 ashish 11520 
  """
11521 
  Attributes:
11522 
   - success
11523 
  """
11524 
 
11525 
  thrift_spec = (
3064 chandransh 11526 
    (0, TType.LIST, 'success', (TType.DOUBLE,None), None, ), # 0
94 ashish 11527 
  )
11528 
 
3064 chandransh 11529 
  def __init__(self, success=None,):
94 ashish 11530 
    self.success = success
11531 
 
11532 
  def read(self, iprot):
11533 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11534 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11535 
      return
11536 
    iprot.readStructBegin()
11537 
    while True:
11538 
      (fname, ftype, fid) = iprot.readFieldBegin()
11539 
      if ftype == TType.STOP:
11540 
        break
11541 
      if fid == 0:
483 rajveer 11542 
        if ftype == TType.LIST:
11543 
          self.success = []
5386 phani.kuma 11544 
          (_etype206, _size203) = iprot.readListBegin()
11545 
          for _i207 in xrange(_size203):
11546 
            _elem208 = iprot.readDouble();
11547 
            self.success.append(_elem208)
483 rajveer 11548 
          iprot.readListEnd()
94 ashish 11549 
        else:
11550 
          iprot.skip(ftype)
11551 
      else:
11552 
        iprot.skip(ftype)
11553 
      iprot.readFieldEnd()
11554 
    iprot.readStructEnd()
11555 
 
11556 
  def write(self, oprot):
11557 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11558 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11559 
      return
3064 chandransh 11560 
    oprot.writeStructBegin('getValidOrdersAmountRange_result')
3431 rajveer 11561 
    if self.success is not None:
483 rajveer 11562 
      oprot.writeFieldBegin('success', TType.LIST, 0)
3064 chandransh 11563 
      oprot.writeListBegin(TType.DOUBLE, len(self.success))
5386 phani.kuma 11564 
      for iter209 in self.success:
11565 
        oprot.writeDouble(iter209)
483 rajveer 11566 
      oprot.writeListEnd()
94 ashish 11567 
      oprot.writeFieldEnd()
11568 
    oprot.writeFieldStop()
11569 
    oprot.writeStructEnd()
11570 
 
3431 rajveer 11571 
  def validate(self):
11572 
    return
11573 
 
11574 
 
94 ashish 11575 
  def __repr__(self):
11576 
    L = ['%s=%r' % (key, value)
11577 
      for key, value in self.__dict__.iteritems()]
11578 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11579 
 
11580 
  def __eq__(self, other):
11581 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11582 
 
11583 
  def __ne__(self, other):
11584 
    return not (self == other)
11585 
 
3064 chandransh 11586 
class getValidOrders_args:
1528 ankur.sing 11587 
  """
11588 
  Attributes:
3064 chandransh 11589 
   - limit
1528 ankur.sing 11590 
  """
11591 
 
11592 
  thrift_spec = (
11593 
    None, # 0
3064 chandransh 11594 
    (1, TType.I64, 'limit', None, None, ), # 1
1528 ankur.sing 11595 
  )
11596 
 
3064 chandransh 11597 
  def __init__(self, limit=None,):
11598 
    self.limit = limit
1528 ankur.sing 11599 
 
11600 
  def read(self, iprot):
11601 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11602 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11603 
      return
11604 
    iprot.readStructBegin()
11605 
    while True:
11606 
      (fname, ftype, fid) = iprot.readFieldBegin()
11607 
      if ftype == TType.STOP:
11608 
        break
11609 
      if fid == 1:
11610 
        if ftype == TType.I64:
3064 chandransh 11611 
          self.limit = iprot.readI64();
1528 ankur.sing 11612 
        else:
11613 
          iprot.skip(ftype)
11614 
      else:
11615 
        iprot.skip(ftype)
11616 
      iprot.readFieldEnd()
11617 
    iprot.readStructEnd()
11618 
 
11619 
  def write(self, oprot):
11620 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11621 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11622 
      return
3064 chandransh 11623 
    oprot.writeStructBegin('getValidOrders_args')
3431 rajveer 11624 
    if self.limit is not None:
3064 chandransh 11625 
      oprot.writeFieldBegin('limit', TType.I64, 1)
11626 
      oprot.writeI64(self.limit)
1528 ankur.sing 11627 
      oprot.writeFieldEnd()
11628 
    oprot.writeFieldStop()
11629 
    oprot.writeStructEnd()
11630 
 
3431 rajveer 11631 
  def validate(self):
11632 
    return
11633 
 
11634 
 
1528 ankur.sing 11635 
  def __repr__(self):
11636 
    L = ['%s=%r' % (key, value)
11637 
      for key, value in self.__dict__.iteritems()]
11638 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11639 
 
11640 
  def __eq__(self, other):
11641 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11642 
 
11643 
  def __ne__(self, other):
11644 
    return not (self == other)
11645 
 
3064 chandransh 11646 
class getValidOrders_result:
1528 ankur.sing 11647 
  """
11648 
  Attributes:
11649 
   - success
11650 
  """
11651 
 
11652 
  thrift_spec = (
3064 chandransh 11653 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
1528 ankur.sing 11654 
  )
11655 
 
3064 chandransh 11656 
  def __init__(self, success=None,):
1528 ankur.sing 11657 
    self.success = success
11658 
 
11659 
  def read(self, iprot):
11660 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11661 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11662 
      return
11663 
    iprot.readStructBegin()
11664 
    while True:
11665 
      (fname, ftype, fid) = iprot.readFieldBegin()
11666 
      if ftype == TType.STOP:
11667 
        break
11668 
      if fid == 0:
3064 chandransh 11669 
        if ftype == TType.LIST:
11670 
          self.success = []
5386 phani.kuma 11671 
          (_etype213, _size210) = iprot.readListBegin()
11672 
          for _i214 in xrange(_size210):
11673 
            _elem215 = Order()
11674 
            _elem215.read(iprot)
11675 
            self.success.append(_elem215)
3064 chandransh 11676 
          iprot.readListEnd()
1528 ankur.sing 11677 
        else:
11678 
          iprot.skip(ftype)
11679 
      else:
11680 
        iprot.skip(ftype)
11681 
      iprot.readFieldEnd()
11682 
    iprot.readStructEnd()
11683 
 
11684 
  def write(self, oprot):
11685 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11686 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11687 
      return
3064 chandransh 11688 
    oprot.writeStructBegin('getValidOrders_result')
3431 rajveer 11689 
    if self.success is not None:
3064 chandransh 11690 
      oprot.writeFieldBegin('success', TType.LIST, 0)
11691 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
5386 phani.kuma 11692 
      for iter216 in self.success:
11693 
        iter216.write(oprot)
3064 chandransh 11694 
      oprot.writeListEnd()
1528 ankur.sing 11695 
      oprot.writeFieldEnd()
11696 
    oprot.writeFieldStop()
11697 
    oprot.writeStructEnd()
11698 
 
3431 rajveer 11699 
  def validate(self):
11700 
    return
11701 
 
11702 
 
1528 ankur.sing 11703 
  def __repr__(self):
11704 
    L = ['%s=%r' % (key, value)
11705 
      for key, value in self.__dict__.iteritems()]
11706 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11707 
 
11708 
  def __eq__(self, other):
11709 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11710 
 
11711 
  def __ne__(self, other):
11712 
    return not (self == other)
11713 
 
1220 chandransh 11714 
class batchOrders_args:
11715 
  """
11716 
  Attributes:
11717 
   - warehouseId
11718 
  """
11719 
 
11720 
  thrift_spec = (
11721 
    None, # 0
11722 
    (1, TType.I64, 'warehouseId', None, None, ), # 1
11723 
  )
11724 
 
11725 
  def __init__(self, warehouseId=None,):
11726 
    self.warehouseId = warehouseId
11727 
 
11728 
  def read(self, iprot):
11729 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11730 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11731 
      return
11732 
    iprot.readStructBegin()
11733 
    while True:
11734 
      (fname, ftype, fid) = iprot.readFieldBegin()
11735 
      if ftype == TType.STOP:
11736 
        break
11737 
      if fid == 1:
11738 
        if ftype == TType.I64:
11739 
          self.warehouseId = iprot.readI64();
11740 
        else:
11741 
          iprot.skip(ftype)
11742 
      else:
11743 
        iprot.skip(ftype)
11744 
      iprot.readFieldEnd()
11745 
    iprot.readStructEnd()
11746 
 
11747 
  def write(self, oprot):
11748 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11749 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11750 
      return
11751 
    oprot.writeStructBegin('batchOrders_args')
3431 rajveer 11752 
    if self.warehouseId is not None:
1220 chandransh 11753 
      oprot.writeFieldBegin('warehouseId', TType.I64, 1)
11754 
      oprot.writeI64(self.warehouseId)
11755 
      oprot.writeFieldEnd()
11756 
    oprot.writeFieldStop()
11757 
    oprot.writeStructEnd()
11758 
 
3431 rajveer 11759 
  def validate(self):
11760 
    return
11761 
 
11762 
 
1220 chandransh 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 
 
11774 
class batchOrders_result:
11775 
  """
11776 
  Attributes:
11777 
   - success
11778 
   - ex
11779 
  """
11780 
 
11781 
  thrift_spec = (
11782 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
11783 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
11784 
  )
11785 
 
11786 
  def __init__(self, success=None, ex=None,):
11787 
    self.success = success
11788 
    self.ex = ex
11789 
 
11790 
  def read(self, iprot):
11791 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11792 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11793 
      return
11794 
    iprot.readStructBegin()
11795 
    while True:
11796 
      (fname, ftype, fid) = iprot.readFieldBegin()
11797 
      if ftype == TType.STOP:
11798 
        break
11799 
      if fid == 0:
11800 
        if ftype == TType.LIST:
11801 
          self.success = []
5386 phani.kuma 11802 
          (_etype220, _size217) = iprot.readListBegin()
11803 
          for _i221 in xrange(_size217):
11804 
            _elem222 = Order()
11805 
            _elem222.read(iprot)
11806 
            self.success.append(_elem222)
1220 chandransh 11807 
          iprot.readListEnd()
11808 
        else:
11809 
          iprot.skip(ftype)
11810 
      elif fid == 1:
11811 
        if ftype == TType.STRUCT:
11812 
          self.ex = TransactionServiceException()
11813 
          self.ex.read(iprot)
11814 
        else:
11815 
          iprot.skip(ftype)
11816 
      else:
11817 
        iprot.skip(ftype)
11818 
      iprot.readFieldEnd()
11819 
    iprot.readStructEnd()
11820 
 
11821 
  def write(self, oprot):
11822 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11823 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11824 
      return
11825 
    oprot.writeStructBegin('batchOrders_result')
3431 rajveer 11826 
    if self.success is not None:
1220 chandransh 11827 
      oprot.writeFieldBegin('success', TType.LIST, 0)
11828 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
5386 phani.kuma 11829 
      for iter223 in self.success:
11830 
        iter223.write(oprot)
1220 chandransh 11831 
      oprot.writeListEnd()
11832 
      oprot.writeFieldEnd()
3431 rajveer 11833 
    if self.ex is not None:
1220 chandransh 11834 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
11835 
      self.ex.write(oprot)
11836 
      oprot.writeFieldEnd()
11837 
    oprot.writeFieldStop()
11838 
    oprot.writeStructEnd()
11839 
 
3431 rajveer 11840 
  def validate(self):
11841 
    return
11842 
 
11843 
 
1220 chandransh 11844 
  def __repr__(self):
11845 
    L = ['%s=%r' % (key, value)
11846 
      for key, value in self.__dict__.iteritems()]
11847 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11848 
 
11849 
  def __eq__(self, other):
11850 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11851 
 
11852 
  def __ne__(self, other):
11853 
    return not (self == other)
11854 
 
1208 chandransh 11855 
class markOrderAsOutOfStock_args:
11856 
  """
11857 
  Attributes:
11858 
   - orderId
11859 
  """
11860 
 
11861 
  thrift_spec = (
11862 
    None, # 0
11863 
    (1, TType.I64, 'orderId', None, None, ), # 1
11864 
  )
11865 
 
11866 
  def __init__(self, orderId=None,):
11867 
    self.orderId = orderId
11868 
 
11869 
  def read(self, iprot):
11870 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11871 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11872 
      return
11873 
    iprot.readStructBegin()
11874 
    while True:
11875 
      (fname, ftype, fid) = iprot.readFieldBegin()
11876 
      if ftype == TType.STOP:
11877 
        break
11878 
      if fid == 1:
11879 
        if ftype == TType.I64:
11880 
          self.orderId = iprot.readI64();
11881 
        else:
11882 
          iprot.skip(ftype)
11883 
      else:
11884 
        iprot.skip(ftype)
11885 
      iprot.readFieldEnd()
11886 
    iprot.readStructEnd()
11887 
 
11888 
  def write(self, oprot):
11889 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11890 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11891 
      return
11892 
    oprot.writeStructBegin('markOrderAsOutOfStock_args')
3431 rajveer 11893 
    if self.orderId is not None:
1208 chandransh 11894 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
11895 
      oprot.writeI64(self.orderId)
11896 
      oprot.writeFieldEnd()
11897 
    oprot.writeFieldStop()
11898 
    oprot.writeStructEnd()
11899 
 
3431 rajveer 11900 
  def validate(self):
11901 
    return
11902 
 
11903 
 
1208 chandransh 11904 
  def __repr__(self):
11905 
    L = ['%s=%r' % (key, value)
11906 
      for key, value in self.__dict__.iteritems()]
11907 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11908 
 
11909 
  def __eq__(self, other):
11910 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11911 
 
11912 
  def __ne__(self, other):
11913 
    return not (self == other)
11914 
 
11915 
class markOrderAsOutOfStock_result:
11916 
  """
11917 
  Attributes:
11918 
   - success
11919 
   - ex
11920 
  """
11921 
 
11922 
  thrift_spec = (
11923 
    (0, TType.BOOL, 'success', None, None, ), # 0
11924 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
11925 
  )
11926 
 
11927 
  def __init__(self, success=None, ex=None,):
11928 
    self.success = success
11929 
    self.ex = ex
11930 
 
11931 
  def read(self, iprot):
11932 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11933 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11934 
      return
11935 
    iprot.readStructBegin()
11936 
    while True:
11937 
      (fname, ftype, fid) = iprot.readFieldBegin()
11938 
      if ftype == TType.STOP:
11939 
        break
11940 
      if fid == 0:
11941 
        if ftype == TType.BOOL:
11942 
          self.success = iprot.readBool();
11943 
        else:
11944 
          iprot.skip(ftype)
11945 
      elif fid == 1:
11946 
        if ftype == TType.STRUCT:
11947 
          self.ex = TransactionServiceException()
11948 
          self.ex.read(iprot)
11949 
        else:
11950 
          iprot.skip(ftype)
11951 
      else:
11952 
        iprot.skip(ftype)
11953 
      iprot.readFieldEnd()
11954 
    iprot.readStructEnd()
11955 
 
11956 
  def write(self, oprot):
11957 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11958 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11959 
      return
11960 
    oprot.writeStructBegin('markOrderAsOutOfStock_result')
3431 rajveer 11961 
    if self.success is not None:
1208 chandransh 11962 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
11963 
      oprot.writeBool(self.success)
11964 
      oprot.writeFieldEnd()
3431 rajveer 11965 
    if self.ex is not None:
1208 chandransh 11966 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
11967 
      self.ex.write(oprot)
11968 
      oprot.writeFieldEnd()
11969 
    oprot.writeFieldStop()
11970 
    oprot.writeStructEnd()
11971 
 
3431 rajveer 11972 
  def validate(self):
11973 
    return
11974 
 
11975 
 
1208 chandransh 11976 
  def __repr__(self):
11977 
    L = ['%s=%r' % (key, value)
11978 
      for key, value in self.__dict__.iteritems()]
11979 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11980 
 
11981 
  def __eq__(self, other):
11982 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11983 
 
11984 
  def __ne__(self, other):
11985 
    return not (self == other)
11986 
 
3064 chandransh 11987 
class verifyOrder_args:
759 chandransh 11988 
  """
11989 
  Attributes:
3064 chandransh 11990 
   - orderId
759 chandransh 11991 
  """
11992 
 
11993 
  thrift_spec = (
11994 
    None, # 0
3064 chandransh 11995 
    (1, TType.I64, 'orderId', None, None, ), # 1
759 chandransh 11996 
  )
11997 
 
3064 chandransh 11998 
  def __init__(self, orderId=None,):
11999 
    self.orderId = orderId
759 chandransh 12000 
 
12001 
  def read(self, iprot):
12002 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12003 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12004 
      return
12005 
    iprot.readStructBegin()
12006 
    while True:
12007 
      (fname, ftype, fid) = iprot.readFieldBegin()
12008 
      if ftype == TType.STOP:
12009 
        break
12010 
      if fid == 1:
12011 
        if ftype == TType.I64:
3064 chandransh 12012 
          self.orderId = iprot.readI64();
759 chandransh 12013 
        else:
12014 
          iprot.skip(ftype)
12015 
      else:
12016 
        iprot.skip(ftype)
12017 
      iprot.readFieldEnd()
12018 
    iprot.readStructEnd()
12019 
 
12020 
  def write(self, oprot):
12021 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12022 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12023 
      return
3064 chandransh 12024 
    oprot.writeStructBegin('verifyOrder_args')
3431 rajveer 12025 
    if self.orderId is not None:
3064 chandransh 12026 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
12027 
      oprot.writeI64(self.orderId)
759 chandransh 12028 
      oprot.writeFieldEnd()
12029 
    oprot.writeFieldStop()
12030 
    oprot.writeStructEnd()
12031 
 
3431 rajveer 12032 
  def validate(self):
12033 
    return
12034 
 
12035 
 
759 chandransh 12036 
  def __repr__(self):
12037 
    L = ['%s=%r' % (key, value)
12038 
      for key, value in self.__dict__.iteritems()]
12039 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12040 
 
12041 
  def __eq__(self, other):
12042 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12043 
 
12044 
  def __ne__(self, other):
12045 
    return not (self == other)
12046 
 
3064 chandransh 12047 
class verifyOrder_result:
759 chandransh 12048 
  """
12049 
  Attributes:
12050 
   - success
12051 
   - ex
12052 
  """
12053 
 
12054 
  thrift_spec = (
12055 
    (0, TType.BOOL, 'success', None, None, ), # 0
12056 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
12057 
  )
12058 
 
12059 
  def __init__(self, success=None, ex=None,):
12060 
    self.success = success
12061 
    self.ex = ex
12062 
 
12063 
  def read(self, iprot):
12064 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12065 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12066 
      return
12067 
    iprot.readStructBegin()
12068 
    while True:
12069 
      (fname, ftype, fid) = iprot.readFieldBegin()
12070 
      if ftype == TType.STOP:
12071 
        break
12072 
      if fid == 0:
12073 
        if ftype == TType.BOOL:
12074 
          self.success = iprot.readBool();
12075 
        else:
12076 
          iprot.skip(ftype)
12077 
      elif fid == 1:
12078 
        if ftype == TType.STRUCT:
12079 
          self.ex = TransactionServiceException()
12080 
          self.ex.read(iprot)
12081 
        else:
12082 
          iprot.skip(ftype)
12083 
      else:
12084 
        iprot.skip(ftype)
12085 
      iprot.readFieldEnd()
12086 
    iprot.readStructEnd()
12087 
 
12088 
  def write(self, oprot):
12089 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12090 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12091 
      return
3064 chandransh 12092 
    oprot.writeStructBegin('verifyOrder_result')
3431 rajveer 12093 
    if self.success is not None:
759 chandransh 12094 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
12095 
      oprot.writeBool(self.success)
12096 
      oprot.writeFieldEnd()
3431 rajveer 12097 
    if self.ex is not None:
759 chandransh 12098 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
12099 
      self.ex.write(oprot)
12100 
      oprot.writeFieldEnd()
12101 
    oprot.writeFieldStop()
12102 
    oprot.writeStructEnd()
12103 
 
3431 rajveer 12104 
  def validate(self):
12105 
    return
12106 
 
12107 
 
759 chandransh 12108 
  def __repr__(self):
12109 
    L = ['%s=%r' % (key, value)
12110 
      for key, value in self.__dict__.iteritems()]
12111 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12112 
 
12113 
  def __eq__(self, other):
12114 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12115 
 
12116 
  def __ne__(self, other):
12117 
    return not (self == other)
12118 
 
3064 chandransh 12119 
class acceptOrder_args:
1113 chandransh 12120 
  """
12121 
  Attributes:
3064 chandransh 12122 
   - orderId
1113 chandransh 12123 
  """
12124 
 
12125 
  thrift_spec = (
12126 
    None, # 0
3064 chandransh 12127 
    (1, TType.I64, 'orderId', None, None, ), # 1
1113 chandransh 12128 
  )
12129 
 
3064 chandransh 12130 
  def __init__(self, orderId=None,):
12131 
    self.orderId = orderId
1113 chandransh 12132 
 
12133 
  def read(self, iprot):
12134 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12135 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12136 
      return
12137 
    iprot.readStructBegin()
12138 
    while True:
12139 
      (fname, ftype, fid) = iprot.readFieldBegin()
12140 
      if ftype == TType.STOP:
12141 
        break
12142 
      if fid == 1:
12143 
        if ftype == TType.I64:
3064 chandransh 12144 
          self.orderId = iprot.readI64();
1113 chandransh 12145 
        else:
12146 
          iprot.skip(ftype)
12147 
      else:
12148 
        iprot.skip(ftype)
12149 
      iprot.readFieldEnd()
12150 
    iprot.readStructEnd()
12151 
 
12152 
  def write(self, oprot):
12153 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12154 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12155 
      return
3064 chandransh 12156 
    oprot.writeStructBegin('acceptOrder_args')
3431 rajveer 12157 
    if self.orderId is not None:
3064 chandransh 12158 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
12159 
      oprot.writeI64(self.orderId)
1113 chandransh 12160 
      oprot.writeFieldEnd()
12161 
    oprot.writeFieldStop()
12162 
    oprot.writeStructEnd()
12163 
 
3431 rajveer 12164 
  def validate(self):
12165 
    return
12166 
 
12167 
 
1113 chandransh 12168 
  def __repr__(self):
12169 
    L = ['%s=%r' % (key, value)
12170 
      for key, value in self.__dict__.iteritems()]
12171 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12172 
 
12173 
  def __eq__(self, other):
12174 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12175 
 
12176 
  def __ne__(self, other):
12177 
    return not (self == other)
12178 
 
3064 chandransh 12179 
class acceptOrder_result:
1113 chandransh 12180 
  """
12181 
  Attributes:
12182 
   - success
12183 
   - ex
12184 
  """
12185 
 
12186 
  thrift_spec = (
3064 chandransh 12187 
    (0, TType.BOOL, 'success', None, None, ), # 0
1113 chandransh 12188 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
12189 
  )
12190 
 
12191 
  def __init__(self, success=None, ex=None,):
12192 
    self.success = success
12193 
    self.ex = ex
12194 
 
12195 
  def read(self, iprot):
12196 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12197 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12198 
      return
12199 
    iprot.readStructBegin()
12200 
    while True:
12201 
      (fname, ftype, fid) = iprot.readFieldBegin()
12202 
      if ftype == TType.STOP:
12203 
        break
12204 
      if fid == 0:
3064 chandransh 12205 
        if ftype == TType.BOOL:
12206 
          self.success = iprot.readBool();
1113 chandransh 12207 
        else:
12208 
          iprot.skip(ftype)
12209 
      elif fid == 1:
12210 
        if ftype == TType.STRUCT:
12211 
          self.ex = TransactionServiceException()
12212 
          self.ex.read(iprot)
12213 
        else:
12214 
          iprot.skip(ftype)
12215 
      else:
12216 
        iprot.skip(ftype)
12217 
      iprot.readFieldEnd()
12218 
    iprot.readStructEnd()
12219 
 
12220 
  def write(self, oprot):
12221 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12222 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12223 
      return
3064 chandransh 12224 
    oprot.writeStructBegin('acceptOrder_result')
3431 rajveer 12225 
    if self.success is not None:
3064 chandransh 12226 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
12227 
      oprot.writeBool(self.success)
1113 chandransh 12228 
      oprot.writeFieldEnd()
3431 rajveer 12229 
    if self.ex is not None:
1113 chandransh 12230 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
12231 
      self.ex.write(oprot)
12232 
      oprot.writeFieldEnd()
12233 
    oprot.writeFieldStop()
12234 
    oprot.writeStructEnd()
12235 
 
3431 rajveer 12236 
  def validate(self):
12237 
    return
12238 
 
12239 
 
1113 chandransh 12240 
  def __repr__(self):
12241 
    L = ['%s=%r' % (key, value)
12242 
      for key, value in self.__dict__.iteritems()]
12243 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12244 
 
12245 
  def __eq__(self, other):
12246 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12247 
 
12248 
  def __ne__(self, other):
12249 
    return not (self == other)
12250 
 
3064 chandransh 12251 
class addBillingDetails_args:
1135 chandransh 12252 
  """
12253 
  Attributes:
3064 chandransh 12254 
   - orderId
12255 
   - invoice_number
4658 mandeep.dh 12256 
   - serialNumber
4283 anupam.sin 12257 
   - itemNumber
3064 chandransh 12258 
   - billed_by
4264 rajveer 12259 
   - jacketNumber
4283 anupam.sin 12260 
   - billingType
5110 mandeep.dh 12261 
   - fulfilmentWarehouseId
4763 rajveer 12262 
   - authorize
1135 chandransh 12263 
  """
12264 
 
12265 
  thrift_spec = (
12266 
    None, # 0
3064 chandransh 12267 
    (1, TType.I64, 'orderId', None, None, ), # 1
12268 
    (2, TType.STRING, 'invoice_number', None, None, ), # 2
5411 rajveer 12269 
    (3, TType.LIST, 'serialNumber', (TType.STRING,None), None, ), # 3
12270 
    (4, TType.LIST, 'itemNumber', (TType.STRING,None), None, ), # 4
4283 anupam.sin 12271 
    (5, TType.STRING, 'billed_by', None, None, ), # 5
12272 
    (6, TType.I64, 'jacketNumber', None, None, ), # 6
12273 
    (7, TType.I64, 'billingType', None, None, ), # 7
5110 mandeep.dh 12274 
    (8, TType.I64, 'fulfilmentWarehouseId', None, None, ), # 8
4763 rajveer 12275 
    (9, TType.BOOL, 'authorize', None, None, ), # 9
1135 chandransh 12276 
  )
12277 
 
5110 mandeep.dh 12278 
  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 12279 
    self.orderId = orderId
12280 
    self.invoice_number = invoice_number
4658 mandeep.dh 12281 
    self.serialNumber = serialNumber
4283 anupam.sin 12282 
    self.itemNumber = itemNumber
3064 chandransh 12283 
    self.billed_by = billed_by
4264 rajveer 12284 
    self.jacketNumber = jacketNumber
4283 anupam.sin 12285 
    self.billingType = billingType
5110 mandeep.dh 12286 
    self.fulfilmentWarehouseId = fulfilmentWarehouseId
4763 rajveer 12287 
    self.authorize = authorize
1135 chandransh 12288 
 
12289 
  def read(self, iprot):
12290 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12291 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12292 
      return
12293 
    iprot.readStructBegin()
12294 
    while True:
12295 
      (fname, ftype, fid) = iprot.readFieldBegin()
12296 
      if ftype == TType.STOP:
12297 
        break
12298 
      if fid == 1:
12299 
        if ftype == TType.I64:
3064 chandransh 12300 
          self.orderId = iprot.readI64();
1135 chandransh 12301 
        else:
12302 
          iprot.skip(ftype)
12303 
      elif fid == 2:
3064 chandransh 12304 
        if ftype == TType.STRING:
12305 
          self.invoice_number = iprot.readString();
1135 chandransh 12306 
        else:
12307 
          iprot.skip(ftype)
3064 chandransh 12308 
      elif fid == 3:
5411 rajveer 12309 
        if ftype == TType.LIST:
12310 
          self.serialNumber = []
12311 
          (_etype227, _size224) = iprot.readListBegin()
12312 
          for _i228 in xrange(_size224):
12313 
            _elem229 = iprot.readString();
12314 
            self.serialNumber.append(_elem229)
12315 
          iprot.readListEnd()
3064 chandransh 12316 
        else:
12317 
          iprot.skip(ftype)
12318 
      elif fid == 4:
5411 rajveer 12319 
        if ftype == TType.LIST:
12320 
          self.itemNumber = []
12321 
          (_etype233, _size230) = iprot.readListBegin()
12322 
          for _i234 in xrange(_size230):
12323 
            _elem235 = iprot.readString();
12324 
            self.itemNumber.append(_elem235)
12325 
          iprot.readListEnd()
3064 chandransh 12326 
        else:
12327 
          iprot.skip(ftype)
12328 
      elif fid == 5:
12329 
        if ftype == TType.STRING:
4283 anupam.sin 12330 
          self.billed_by = iprot.readString();
3064 chandransh 12331 
        else:
12332 
          iprot.skip(ftype)
12333 
      elif fid == 6:
12334 
        if ftype == TType.I64:
4283 anupam.sin 12335 
          self.jacketNumber = iprot.readI64();
12336 
        else:
12337 
          iprot.skip(ftype)
12338 
      elif fid == 7:
12339 
        if ftype == TType.I64:
3064 chandransh 12340 
          self.billingType = iprot.readI64();
12341 
        else:
12342 
          iprot.skip(ftype)
4283 anupam.sin 12343 
      elif fid == 8:
12344 
        if ftype == TType.I64:
5110 mandeep.dh 12345 
          self.fulfilmentWarehouseId = iprot.readI64();
4283 anupam.sin 12346 
        else:
12347 
          iprot.skip(ftype)
4763 rajveer 12348 
      elif fid == 9:
12349 
        if ftype == TType.BOOL:
12350 
          self.authorize = iprot.readBool();
12351 
        else:
12352 
          iprot.skip(ftype)
1246 chandransh 12353 
      else:
12354 
        iprot.skip(ftype)
12355 
      iprot.readFieldEnd()
12356 
    iprot.readStructEnd()
12357 
 
12358 
  def write(self, oprot):
12359 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12360 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12361 
      return
4283 anupam.sin 12362 
    oprot.writeStructBegin('addBillingDetails_args')
3431 rajveer 12363 
    if self.orderId is not None:
3064 chandransh 12364 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
12365 
      oprot.writeI64(self.orderId)
1246 chandransh 12366 
      oprot.writeFieldEnd()
4283 anupam.sin 12367 
    if self.invoice_number is not None:
12368 
      oprot.writeFieldBegin('invoice_number', TType.STRING, 2)
12369 
      oprot.writeString(self.invoice_number)
1246 chandransh 12370 
      oprot.writeFieldEnd()
4658 mandeep.dh 12371 
    if self.serialNumber is not None:
5411 rajveer 12372 
      oprot.writeFieldBegin('serialNumber', TType.LIST, 3)
12373 
      oprot.writeListBegin(TType.STRING, len(self.serialNumber))
12374 
      for iter236 in self.serialNumber:
12375 
        oprot.writeString(iter236)
12376 
      oprot.writeListEnd()
3064 chandransh 12377 
      oprot.writeFieldEnd()
3431 rajveer 12378 
    if self.itemNumber is not None:
5411 rajveer 12379 
      oprot.writeFieldBegin('itemNumber', TType.LIST, 4)
12380 
      oprot.writeListBegin(TType.STRING, len(self.itemNumber))
12381 
      for iter237 in self.itemNumber:
12382 
        oprot.writeString(iter237)
12383 
      oprot.writeListEnd()
3064 chandransh 12384 
      oprot.writeFieldEnd()
4283 anupam.sin 12385 
    if self.billed_by is not None:
12386 
      oprot.writeFieldBegin('billed_by', TType.STRING, 5)
12387 
      oprot.writeString(self.billed_by)
3064 chandransh 12388 
      oprot.writeFieldEnd()
4283 anupam.sin 12389 
    if self.jacketNumber is not None:
12390 
      oprot.writeFieldBegin('jacketNumber', TType.I64, 6)
12391 
      oprot.writeI64(self.jacketNumber)
12392 
      oprot.writeFieldEnd()
3431 rajveer 12393 
    if self.billingType is not None:
4283 anupam.sin 12394 
      oprot.writeFieldBegin('billingType', TType.I64, 7)
3064 chandransh 12395 
      oprot.writeI64(self.billingType)
12396 
      oprot.writeFieldEnd()
5110 mandeep.dh 12397 
    if self.fulfilmentWarehouseId is not None:
12398 
      oprot.writeFieldBegin('fulfilmentWarehouseId', TType.I64, 8)
12399 
      oprot.writeI64(self.fulfilmentWarehouseId)
4283 anupam.sin 12400 
      oprot.writeFieldEnd()
4763 rajveer 12401 
    if self.authorize is not None:
12402 
      oprot.writeFieldBegin('authorize', TType.BOOL, 9)
12403 
      oprot.writeBool(self.authorize)
12404 
      oprot.writeFieldEnd()
1246 chandransh 12405 
    oprot.writeFieldStop()
12406 
    oprot.writeStructEnd()
12407 
 
3431 rajveer 12408 
  def validate(self):
12409 
    return
12410 
 
12411 
 
1246 chandransh 12412 
  def __repr__(self):
12413 
    L = ['%s=%r' % (key, value)
12414 
      for key, value in self.__dict__.iteritems()]
12415 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12416 
 
12417 
  def __eq__(self, other):
12418 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12419 
 
12420 
  def __ne__(self, other):
12421 
    return not (self == other)
12422 
 
4283 anupam.sin 12423 
class addBillingDetails_result:
1246 chandransh 12424 
  """
12425 
  Attributes:
3064 chandransh 12426 
   - success
1246 chandransh 12427 
   - ex
12428 
  """
12429 
 
12430 
  thrift_spec = (
3064 chandransh 12431 
    (0, TType.BOOL, 'success', None, None, ), # 0
1246 chandransh 12432 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
12433 
  )
12434 
 
3064 chandransh 12435 
  def __init__(self, success=None, ex=None,):
12436 
    self.success = success
1246 chandransh 12437 
    self.ex = ex
12438 
 
12439 
  def read(self, iprot):
12440 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12441 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12442 
      return
12443 
    iprot.readStructBegin()
12444 
    while True:
12445 
      (fname, ftype, fid) = iprot.readFieldBegin()
12446 
      if ftype == TType.STOP:
12447 
        break
3064 chandransh 12448 
      if fid == 0:
12449 
        if ftype == TType.BOOL:
12450 
          self.success = iprot.readBool();
12451 
        else:
12452 
          iprot.skip(ftype)
12453 
      elif fid == 1:
1246 chandransh 12454 
        if ftype == TType.STRUCT:
12455 
          self.ex = TransactionServiceException()
12456 
          self.ex.read(iprot)
12457 
        else:
12458 
          iprot.skip(ftype)
12459 
      else:
12460 
        iprot.skip(ftype)
12461 
      iprot.readFieldEnd()
12462 
    iprot.readStructEnd()
12463 
 
12464 
  def write(self, oprot):
12465 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12466 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12467 
      return
4283 anupam.sin 12468 
    oprot.writeStructBegin('addBillingDetails_result')
3431 rajveer 12469 
    if self.success is not None:
3064 chandransh 12470 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
12471 
      oprot.writeBool(self.success)
12472 
      oprot.writeFieldEnd()
3431 rajveer 12473 
    if self.ex is not None:
1246 chandransh 12474 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
12475 
      self.ex.write(oprot)
12476 
      oprot.writeFieldEnd()
12477 
    oprot.writeFieldStop()
12478 
    oprot.writeStructEnd()
12479 
 
3431 rajveer 12480 
  def validate(self):
12481 
    return
12482 
 
12483 
 
1246 chandransh 12484 
  def __repr__(self):
12485 
    L = ['%s=%r' % (key, value)
12486 
      for key, value in self.__dict__.iteritems()]
12487 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12488 
 
12489 
  def __eq__(self, other):
12490 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12491 
 
12492 
  def __ne__(self, other):
12493 
    return not (self == other)
12494 
 
4579 rajveer 12495 
class addInvoiceNumber_args:
12496 
  """
12497 
  Attributes:
12498 
   - orderId
12499 
   - invoiceNumber
4763 rajveer 12500 
   - color
4579 rajveer 12501 
  """
12502 
 
12503 
  thrift_spec = (
12504 
    None, # 0
12505 
    (1, TType.I64, 'orderId', None, None, ), # 1
12506 
    (2, TType.STRING, 'invoiceNumber', None, None, ), # 2
4763 rajveer 12507 
    (3, TType.STRING, 'color', None, None, ), # 3
4579 rajveer 12508 
  )
12509 
 
4763 rajveer 12510 
  def __init__(self, orderId=None, invoiceNumber=None, color=None,):
4579 rajveer 12511 
    self.orderId = orderId
12512 
    self.invoiceNumber = invoiceNumber
4763 rajveer 12513 
    self.color = color
4579 rajveer 12514 
 
12515 
  def read(self, iprot):
12516 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12517 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12518 
      return
12519 
    iprot.readStructBegin()
12520 
    while True:
12521 
      (fname, ftype, fid) = iprot.readFieldBegin()
12522 
      if ftype == TType.STOP:
12523 
        break
12524 
      if fid == 1:
12525 
        if ftype == TType.I64:
12526 
          self.orderId = iprot.readI64();
12527 
        else:
12528 
          iprot.skip(ftype)
12529 
      elif fid == 2:
12530 
        if ftype == TType.STRING:
12531 
          self.invoiceNumber = iprot.readString();
12532 
        else:
12533 
          iprot.skip(ftype)
4763 rajveer 12534 
      elif fid == 3:
12535 
        if ftype == TType.STRING:
12536 
          self.color = iprot.readString();
12537 
        else:
12538 
          iprot.skip(ftype)
4579 rajveer 12539 
      else:
12540 
        iprot.skip(ftype)
12541 
      iprot.readFieldEnd()
12542 
    iprot.readStructEnd()
12543 
 
12544 
  def write(self, oprot):
12545 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12546 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12547 
      return
12548 
    oprot.writeStructBegin('addInvoiceNumber_args')
12549 
    if self.orderId is not None:
12550 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
12551 
      oprot.writeI64(self.orderId)
12552 
      oprot.writeFieldEnd()
12553 
    if self.invoiceNumber is not None:
12554 
      oprot.writeFieldBegin('invoiceNumber', TType.STRING, 2)
12555 
      oprot.writeString(self.invoiceNumber)
12556 
      oprot.writeFieldEnd()
4763 rajveer 12557 
    if self.color is not None:
12558 
      oprot.writeFieldBegin('color', TType.STRING, 3)
12559 
      oprot.writeString(self.color)
12560 
      oprot.writeFieldEnd()
4579 rajveer 12561 
    oprot.writeFieldStop()
12562 
    oprot.writeStructEnd()
12563 
 
12564 
  def validate(self):
12565 
    return
12566 
 
12567 
 
12568 
  def __repr__(self):
12569 
    L = ['%s=%r' % (key, value)
12570 
      for key, value in self.__dict__.iteritems()]
12571 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12572 
 
12573 
  def __eq__(self, other):
12574 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12575 
 
12576 
  def __ne__(self, other):
12577 
    return not (self == other)
12578 
 
12579 
class addInvoiceNumber_result:
12580 
  """
12581 
  Attributes:
12582 
   - ex
12583 
  """
12584 
 
12585 
  thrift_spec = (
12586 
    None, # 0
12587 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
12588 
  )
12589 
 
12590 
  def __init__(self, ex=None,):
12591 
    self.ex = ex
12592 
 
12593 
  def read(self, iprot):
12594 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12595 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12596 
      return
12597 
    iprot.readStructBegin()
12598 
    while True:
12599 
      (fname, ftype, fid) = iprot.readFieldBegin()
12600 
      if ftype == TType.STOP:
12601 
        break
12602 
      if fid == 1:
12603 
        if ftype == TType.STRUCT:
12604 
          self.ex = TransactionServiceException()
12605 
          self.ex.read(iprot)
12606 
        else:
12607 
          iprot.skip(ftype)
12608 
      else:
12609 
        iprot.skip(ftype)
12610 
      iprot.readFieldEnd()
12611 
    iprot.readStructEnd()
12612 
 
12613 
  def write(self, oprot):
12614 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12615 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12616 
      return
12617 
    oprot.writeStructBegin('addInvoiceNumber_result')
12618 
    if self.ex is not None:
12619 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
12620 
      self.ex.write(oprot)
12621 
      oprot.writeFieldEnd()
12622 
    oprot.writeFieldStop()
12623 
    oprot.writeStructEnd()
12624 
 
12625 
  def validate(self):
12626 
    return
12627 
 
12628 
 
12629 
  def __repr__(self):
12630 
    L = ['%s=%r' % (key, value)
12631 
      for key, value in self.__dict__.iteritems()]
12632 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12633 
 
12634 
  def __eq__(self, other):
12635 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12636 
 
12637 
  def __ne__(self, other):
12638 
    return not (self == other)
12639 
 
4910 phani.kuma 12640 
class markOrdersAsShippedFromWarehouse_args:
1408 ankur.sing 12641 
  """
12642 
  Attributes:
3064 chandransh 12643 
   - warehouseId
1408 ankur.sing 12644 
   - providerId
3064 chandransh 12645 
   - cod
4910 phani.kuma 12646 
   - orderIds
1408 ankur.sing 12647 
  """
12648 
 
12649 
  thrift_spec = (
12650 
    None, # 0
3064 chandransh 12651 
    (1, TType.I64, 'warehouseId', None, None, ), # 1
12652 
    (2, TType.I64, 'providerId', None, None, ), # 2
12653 
    (3, TType.BOOL, 'cod', None, None, ), # 3
4910 phani.kuma 12654 
    (4, TType.LIST, 'orderIds', (TType.I64,None), None, ), # 4
1408 ankur.sing 12655 
  )
12656 
 
4910 phani.kuma 12657 
  def __init__(self, warehouseId=None, providerId=None, cod=None, orderIds=None,):
3064 chandransh 12658 
    self.warehouseId = warehouseId
1408 ankur.sing 12659 
    self.providerId = providerId
3064 chandransh 12660 
    self.cod = cod
4910 phani.kuma 12661 
    self.orderIds = orderIds
1408 ankur.sing 12662 
 
12663 
  def read(self, iprot):
12664 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12665 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12666 
      return
12667 
    iprot.readStructBegin()
12668 
    while True:
12669 
      (fname, ftype, fid) = iprot.readFieldBegin()
12670 
      if ftype == TType.STOP:
12671 
        break
12672 
      if fid == 1:
12673 
        if ftype == TType.I64:
3064 chandransh 12674 
          self.warehouseId = iprot.readI64();
1408 ankur.sing 12675 
        else:
12676 
          iprot.skip(ftype)
12677 
      elif fid == 2:
12678 
        if ftype == TType.I64:
3064 chandransh 12679 
          self.providerId = iprot.readI64();
1408 ankur.sing 12680 
        else:
12681 
          iprot.skip(ftype)
3064 chandransh 12682 
      elif fid == 3:
12683 
        if ftype == TType.BOOL:
12684 
          self.cod = iprot.readBool();
12685 
        else:
12686 
          iprot.skip(ftype)
4910 phani.kuma 12687 
      elif fid == 4:
12688 
        if ftype == TType.LIST:
12689 
          self.orderIds = []
5411 rajveer 12690 
          (_etype241, _size238) = iprot.readListBegin()
12691 
          for _i242 in xrange(_size238):
12692 
            _elem243 = iprot.readI64();
12693 
            self.orderIds.append(_elem243)
4910 phani.kuma 12694 
          iprot.readListEnd()
12695 
        else:
12696 
          iprot.skip(ftype)
1408 ankur.sing 12697 
      else:
12698 
        iprot.skip(ftype)
12699 
      iprot.readFieldEnd()
12700 
    iprot.readStructEnd()
12701 
 
12702 
  def write(self, oprot):
12703 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12704 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12705 
      return
4910 phani.kuma 12706 
    oprot.writeStructBegin('markOrdersAsShippedFromWarehouse_args')
3431 rajveer 12707 
    if self.warehouseId is not None:
3064 chandransh 12708 
      oprot.writeFieldBegin('warehouseId', TType.I64, 1)
12709 
      oprot.writeI64(self.warehouseId)
12710 
      oprot.writeFieldEnd()
3431 rajveer 12711 
    if self.providerId is not None:
3064 chandransh 12712 
      oprot.writeFieldBegin('providerId', TType.I64, 2)
1408 ankur.sing 12713 
      oprot.writeI64(self.providerId)
12714 
      oprot.writeFieldEnd()
3431 rajveer 12715 
    if self.cod is not None:
3064 chandransh 12716 
      oprot.writeFieldBegin('cod', TType.BOOL, 3)
12717 
      oprot.writeBool(self.cod)
1408 ankur.sing 12718 
      oprot.writeFieldEnd()
4910 phani.kuma 12719 
    if self.orderIds is not None:
12720 
      oprot.writeFieldBegin('orderIds', TType.LIST, 4)
12721 
      oprot.writeListBegin(TType.I64, len(self.orderIds))
5411 rajveer 12722 
      for iter244 in self.orderIds:
12723 
        oprot.writeI64(iter244)
4910 phani.kuma 12724 
      oprot.writeListEnd()
12725 
      oprot.writeFieldEnd()
1408 ankur.sing 12726 
    oprot.writeFieldStop()
12727 
    oprot.writeStructEnd()
12728 
 
3431 rajveer 12729 
  def validate(self):
12730 
    return
12731 
 
12732 
 
1408 ankur.sing 12733 
  def __repr__(self):
12734 
    L = ['%s=%r' % (key, value)
12735 
      for key, value in self.__dict__.iteritems()]
12736 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12737 
 
12738 
  def __eq__(self, other):
12739 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12740 
 
12741 
  def __ne__(self, other):
12742 
    return not (self == other)
12743 
 
4910 phani.kuma 12744 
class markOrdersAsShippedFromWarehouse_result:
1408 ankur.sing 12745 
  """
12746 
  Attributes:
12747 
   - success
3064 chandransh 12748 
   - ex
1408 ankur.sing 12749 
  """
12750 
 
12751 
  thrift_spec = (
3064 chandransh 12752 
    (0, TType.BOOL, 'success', None, None, ), # 0
12753 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
1408 ankur.sing 12754 
  )
12755 
 
3064 chandransh 12756 
  def __init__(self, success=None, ex=None,):
1408 ankur.sing 12757 
    self.success = success
3064 chandransh 12758 
    self.ex = ex
1408 ankur.sing 12759 
 
12760 
  def read(self, iprot):
12761 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12762 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12763 
      return
12764 
    iprot.readStructBegin()
12765 
    while True:
12766 
      (fname, ftype, fid) = iprot.readFieldBegin()
12767 
      if ftype == TType.STOP:
12768 
        break
12769 
      if fid == 0:
3064 chandransh 12770 
        if ftype == TType.BOOL:
12771 
          self.success = iprot.readBool();
1408 ankur.sing 12772 
        else:
12773 
          iprot.skip(ftype)
3064 chandransh 12774 
      elif fid == 1:
12775 
        if ftype == TType.STRUCT:
12776 
          self.ex = TransactionServiceException()
12777 
          self.ex.read(iprot)
12778 
        else:
12779 
          iprot.skip(ftype)
1408 ankur.sing 12780 
      else:
12781 
        iprot.skip(ftype)
12782 
      iprot.readFieldEnd()
12783 
    iprot.readStructEnd()
12784 
 
12785 
  def write(self, oprot):
12786 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12787 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12788 
      return
4910 phani.kuma 12789 
    oprot.writeStructBegin('markOrdersAsShippedFromWarehouse_result')
3431 rajveer 12790 
    if self.success is not None:
3064 chandransh 12791 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
12792 
      oprot.writeBool(self.success)
1408 ankur.sing 12793 
      oprot.writeFieldEnd()
3431 rajveer 12794 
    if self.ex is not None:
3064 chandransh 12795 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
12796 
      self.ex.write(oprot)
12797 
      oprot.writeFieldEnd()
1408 ankur.sing 12798 
    oprot.writeFieldStop()
12799 
    oprot.writeStructEnd()
12800 
 
3431 rajveer 12801 
  def validate(self):
12802 
    return
12803 
 
12804 
 
1408 ankur.sing 12805 
  def __repr__(self):
12806 
    L = ['%s=%r' % (key, value)
12807 
      for key, value in self.__dict__.iteritems()]
12808 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12809 
 
12810 
  def __eq__(self, other):
12811 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12812 
 
12813 
  def __ne__(self, other):
12814 
    return not (self == other)
12815 
 
5676 rajveer 12816 
class markOrdersAsReturnedFromStore_args:
12817 
  """
12818 
  Attributes:
12819 
   - providerId
12820 
   - orderIds
12821 
  """
12822 
 
12823 
  thrift_spec = (
12824 
    None, # 0
12825 
    (1, TType.I64, 'providerId', None, None, ), # 1
12826 
    (2, TType.LIST, 'orderIds', (TType.I64,None), None, ), # 2
12827 
  )
12828 
 
12829 
  def __init__(self, providerId=None, orderIds=None,):
12830 
    self.providerId = providerId
12831 
    self.orderIds = orderIds
12832 
 
12833 
  def read(self, iprot):
12834 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12835 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12836 
      return
12837 
    iprot.readStructBegin()
12838 
    while True:
12839 
      (fname, ftype, fid) = iprot.readFieldBegin()
12840 
      if ftype == TType.STOP:
12841 
        break
12842 
      if fid == 1:
12843 
        if ftype == TType.I64:
12844 
          self.providerId = iprot.readI64();
12845 
        else:
12846 
          iprot.skip(ftype)
12847 
      elif fid == 2:
12848 
        if ftype == TType.LIST:
12849 
          self.orderIds = []
12850 
          (_etype248, _size245) = iprot.readListBegin()
12851 
          for _i249 in xrange(_size245):
12852 
            _elem250 = iprot.readI64();
12853 
            self.orderIds.append(_elem250)
12854 
          iprot.readListEnd()
12855 
        else:
12856 
          iprot.skip(ftype)
12857 
      else:
12858 
        iprot.skip(ftype)
12859 
      iprot.readFieldEnd()
12860 
    iprot.readStructEnd()
12861 
 
12862 
  def write(self, oprot):
12863 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12864 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12865 
      return
12866 
    oprot.writeStructBegin('markOrdersAsReturnedFromStore_args')
12867 
    if self.providerId is not None:
12868 
      oprot.writeFieldBegin('providerId', TType.I64, 1)
12869 
      oprot.writeI64(self.providerId)
12870 
      oprot.writeFieldEnd()
12871 
    if self.orderIds is not None:
12872 
      oprot.writeFieldBegin('orderIds', TType.LIST, 2)
12873 
      oprot.writeListBegin(TType.I64, len(self.orderIds))
12874 
      for iter251 in self.orderIds:
12875 
        oprot.writeI64(iter251)
12876 
      oprot.writeListEnd()
12877 
      oprot.writeFieldEnd()
12878 
    oprot.writeFieldStop()
12879 
    oprot.writeStructEnd()
12880 
 
12881 
  def validate(self):
12882 
    return
12883 
 
12884 
 
12885 
  def __repr__(self):
12886 
    L = ['%s=%r' % (key, value)
12887 
      for key, value in self.__dict__.iteritems()]
12888 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12889 
 
12890 
  def __eq__(self, other):
12891 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12892 
 
12893 
  def __ne__(self, other):
12894 
    return not (self == other)
12895 
 
12896 
class markOrdersAsReturnedFromStore_result:
12897 
  """
12898 
  Attributes:
12899 
   - success
12900 
   - ex
12901 
  """
12902 
 
12903 
  thrift_spec = (
12904 
    (0, TType.BOOL, 'success', None, None, ), # 0
12905 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
12906 
  )
12907 
 
12908 
  def __init__(self, success=None, ex=None,):
12909 
    self.success = success
12910 
    self.ex = ex
12911 
 
12912 
  def read(self, iprot):
12913 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12914 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12915 
      return
12916 
    iprot.readStructBegin()
12917 
    while True:
12918 
      (fname, ftype, fid) = iprot.readFieldBegin()
12919 
      if ftype == TType.STOP:
12920 
        break
12921 
      if fid == 0:
12922 
        if ftype == TType.BOOL:
12923 
          self.success = iprot.readBool();
12924 
        else:
12925 
          iprot.skip(ftype)
12926 
      elif fid == 1:
12927 
        if ftype == TType.STRUCT:
12928 
          self.ex = TransactionServiceException()
12929 
          self.ex.read(iprot)
12930 
        else:
12931 
          iprot.skip(ftype)
12932 
      else:
12933 
        iprot.skip(ftype)
12934 
      iprot.readFieldEnd()
12935 
    iprot.readStructEnd()
12936 
 
12937 
  def write(self, oprot):
12938 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12939 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12940 
      return
12941 
    oprot.writeStructBegin('markOrdersAsReturnedFromStore_result')
12942 
    if self.success is not None:
12943 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
12944 
      oprot.writeBool(self.success)
12945 
      oprot.writeFieldEnd()
12946 
    if self.ex is not None:
12947 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
12948 
      self.ex.write(oprot)
12949 
      oprot.writeFieldEnd()
12950 
    oprot.writeFieldStop()
12951 
    oprot.writeStructEnd()
12952 
 
12953 
  def validate(self):
12954 
    return
12955 
 
12956 
 
12957 
  def __repr__(self):
12958 
    L = ['%s=%r' % (key, value)
12959 
      for key, value in self.__dict__.iteritems()]
12960 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12961 
 
12962 
  def __eq__(self, other):
12963 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12964 
 
12965 
  def __ne__(self, other):
12966 
    return not (self == other)
12967 
 
4910 phani.kuma 12968 
class markOrdersAsPickedUp_args:
4410 rajveer 12969 
  """
12970 
  Attributes:
12971 
   - providerId
4910 phani.kuma 12972 
   - pickupDetails
4410 rajveer 12973 
  """
12974 
 
12975 
  thrift_spec = (
12976 
    None, # 0
4910 phani.kuma 12977 
    (1, TType.I64, 'providerId', None, None, ), # 1
12978 
    (2, TType.MAP, 'pickupDetails', (TType.STRING,None,TType.STRING,None), None, ), # 2
4410 rajveer 12979 
  )
12980 
 
4910 phani.kuma 12981 
  def __init__(self, providerId=None, pickupDetails=None,):
4410 rajveer 12982 
    self.providerId = providerId
4910 phani.kuma 12983 
    self.pickupDetails = pickupDetails
4410 rajveer 12984 
 
12985 
  def read(self, iprot):
12986 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12987 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12988 
      return
12989 
    iprot.readStructBegin()
12990 
    while True:
12991 
      (fname, ftype, fid) = iprot.readFieldBegin()
12992 
      if ftype == TType.STOP:
12993 
        break
12994 
      if fid == 1:
12995 
        if ftype == TType.I64:
4910 phani.kuma 12996 
          self.providerId = iprot.readI64();
4410 rajveer 12997 
        else:
12998 
          iprot.skip(ftype)
12999 
      elif fid == 2:
4910 phani.kuma 13000 
        if ftype == TType.MAP:
13001 
          self.pickupDetails = {}
5676 rajveer 13002 
          (_ktype253, _vtype254, _size252 ) = iprot.readMapBegin()
13003 
          for _i256 in xrange(_size252):
13004 
            _key257 = iprot.readString();
13005 
            _val258 = iprot.readString();
13006 
            self.pickupDetails[_key257] = _val258
4910 phani.kuma 13007 
          iprot.readMapEnd()
4410 rajveer 13008 
        else:
13009 
          iprot.skip(ftype)
13010 
      else:
13011 
        iprot.skip(ftype)
13012 
      iprot.readFieldEnd()
13013 
    iprot.readStructEnd()
13014 
 
13015 
  def write(self, oprot):
13016 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13017 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13018 
      return
4910 phani.kuma 13019 
    oprot.writeStructBegin('markOrdersAsPickedUp_args')
4410 rajveer 13020 
    if self.providerId is not None:
4910 phani.kuma 13021 
      oprot.writeFieldBegin('providerId', TType.I64, 1)
4410 rajveer 13022 
      oprot.writeI64(self.providerId)
13023 
      oprot.writeFieldEnd()
4910 phani.kuma 13024 
    if self.pickupDetails is not None:
13025 
      oprot.writeFieldBegin('pickupDetails', TType.MAP, 2)
13026 
      oprot.writeMapBegin(TType.STRING, TType.STRING, len(self.pickupDetails))
5676 rajveer 13027 
      for kiter259,viter260 in self.pickupDetails.items():
13028 
        oprot.writeString(kiter259)
13029 
        oprot.writeString(viter260)
4910 phani.kuma 13030 
      oprot.writeMapEnd()
4410 rajveer 13031 
      oprot.writeFieldEnd()
13032 
    oprot.writeFieldStop()
13033 
    oprot.writeStructEnd()
13034 
 
13035 
  def validate(self):
13036 
    return
13037 
 
13038 
 
13039 
  def __repr__(self):
13040 
    L = ['%s=%r' % (key, value)
13041 
      for key, value in self.__dict__.iteritems()]
13042 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13043 
 
13044 
  def __eq__(self, other):
13045 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13046 
 
13047 
  def __ne__(self, other):
13048 
    return not (self == other)
13049 
 
4910 phani.kuma 13050 
class markOrdersAsPickedUp_result:
4410 rajveer 13051 
  """
13052 
  Attributes:
13053 
   - ex
13054 
  """
13055 
 
13056 
  thrift_spec = (
4910 phani.kuma 13057 
    None, # 0
4410 rajveer 13058 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
13059 
  )
13060 
 
4910 phani.kuma 13061 
  def __init__(self, ex=None,):
4410 rajveer 13062 
    self.ex = ex
13063 
 
13064 
  def read(self, iprot):
13065 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13066 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13067 
      return
13068 
    iprot.readStructBegin()
13069 
    while True:
13070 
      (fname, ftype, fid) = iprot.readFieldBegin()
13071 
      if ftype == TType.STOP:
13072 
        break
4910 phani.kuma 13073 
      if fid == 1:
4410 rajveer 13074 
        if ftype == TType.STRUCT:
13075 
          self.ex = TransactionServiceException()
13076 
          self.ex.read(iprot)
13077 
        else:
13078 
          iprot.skip(ftype)
13079 
      else:
13080 
        iprot.skip(ftype)
13081 
      iprot.readFieldEnd()
13082 
    iprot.readStructEnd()
13083 
 
13084 
  def write(self, oprot):
13085 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13086 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13087 
      return
4910 phani.kuma 13088 
    oprot.writeStructBegin('markOrdersAsPickedUp_result')
4410 rajveer 13089 
    if self.ex is not None:
13090 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
13091 
      self.ex.write(oprot)
13092 
      oprot.writeFieldEnd()
13093 
    oprot.writeFieldStop()
13094 
    oprot.writeStructEnd()
13095 
 
13096 
  def validate(self):
13097 
    return
13098 
 
13099 
 
13100 
  def __repr__(self):
13101 
    L = ['%s=%r' % (key, value)
13102 
      for key, value in self.__dict__.iteritems()]
13103 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13104 
 
13105 
  def __eq__(self, other):
13106 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13107 
 
13108 
  def __ne__(self, other):
13109 
    return not (self == other)
13110 
 
4910 phani.kuma 13111 
class getOrdersNotPickedUp_args:
304 ashish 13112 
  """
13113 
  Attributes:
3064 chandransh 13114 
   - providerId
304 ashish 13115 
  """
94 ashish 13116 
 
304 ashish 13117 
  thrift_spec = (
13118 
    None, # 0
3064 chandransh 13119 
    (1, TType.I64, 'providerId', None, None, ), # 1
304 ashish 13120 
  )
13121 
 
4910 phani.kuma 13122 
  def __init__(self, providerId=None,):
3064 chandransh 13123 
    self.providerId = providerId
304 ashish 13124 
 
13125 
  def read(self, iprot):
13126 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13127 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13128 
      return
13129 
    iprot.readStructBegin()
13130 
    while True:
13131 
      (fname, ftype, fid) = iprot.readFieldBegin()
13132 
      if ftype == TType.STOP:
13133 
        break
13134 
      if fid == 1:
13135 
        if ftype == TType.I64:
3064 chandransh 13136 
          self.providerId = iprot.readI64();
304 ashish 13137 
        else:
13138 
          iprot.skip(ftype)
13139 
      else:
13140 
        iprot.skip(ftype)
13141 
      iprot.readFieldEnd()
13142 
    iprot.readStructEnd()
13143 
 
13144 
  def write(self, oprot):
13145 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13146 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13147 
      return
4910 phani.kuma 13148 
    oprot.writeStructBegin('getOrdersNotPickedUp_args')
3431 rajveer 13149 
    if self.providerId is not None:
3064 chandransh 13150 
      oprot.writeFieldBegin('providerId', TType.I64, 1)
13151 
      oprot.writeI64(self.providerId)
304 ashish 13152 
      oprot.writeFieldEnd()
13153 
    oprot.writeFieldStop()
13154 
    oprot.writeStructEnd()
13155 
 
3431 rajveer 13156 
  def validate(self):
13157 
    return
13158 
 
13159 
 
304 ashish 13160 
  def __repr__(self):
13161 
    L = ['%s=%r' % (key, value)
13162 
      for key, value in self.__dict__.iteritems()]
13163 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13164 
 
13165 
  def __eq__(self, other):
13166 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13167 
 
13168 
  def __ne__(self, other):
13169 
    return not (self == other)
13170 
 
4910 phani.kuma 13171 
class getOrdersNotPickedUp_result:
304 ashish 13172 
  """
13173 
  Attributes:
13174 
   - success
13175 
  """
13176 
 
13177 
  thrift_spec = (
3064 chandransh 13178 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
304 ashish 13179 
  )
13180 
 
4910 phani.kuma 13181 
  def __init__(self, success=None,):
304 ashish 13182 
    self.success = success
13183 
 
13184 
  def read(self, iprot):
13185 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13186 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13187 
      return
13188 
    iprot.readStructBegin()
13189 
    while True:
13190 
      (fname, ftype, fid) = iprot.readFieldBegin()
13191 
      if ftype == TType.STOP:
13192 
        break
13193 
      if fid == 0:
13194 
        if ftype == TType.LIST:
13195 
          self.success = []
5676 rajveer 13196 
          (_etype264, _size261) = iprot.readListBegin()
13197 
          for _i265 in xrange(_size261):
13198 
            _elem266 = Order()
13199 
            _elem266.read(iprot)
13200 
            self.success.append(_elem266)
304 ashish 13201 
          iprot.readListEnd()
13202 
        else:
13203 
          iprot.skip(ftype)
13204 
      else:
13205 
        iprot.skip(ftype)
13206 
      iprot.readFieldEnd()
13207 
    iprot.readStructEnd()
13208 
 
13209 
  def write(self, oprot):
13210 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13211 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13212 
      return
4910 phani.kuma 13213 
    oprot.writeStructBegin('getOrdersNotPickedUp_result')
3431 rajveer 13214 
    if self.success is not None:
304 ashish 13215 
      oprot.writeFieldBegin('success', TType.LIST, 0)
13216 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
5676 rajveer 13217 
      for iter267 in self.success:
13218 
        iter267.write(oprot)
304 ashish 13219 
      oprot.writeListEnd()
13220 
      oprot.writeFieldEnd()
13221 
    oprot.writeFieldStop()
13222 
    oprot.writeStructEnd()
13223 
 
3431 rajveer 13224 
  def validate(self):
13225 
    return
13226 
 
13227 
 
304 ashish 13228 
  def __repr__(self):
13229 
    L = ['%s=%r' % (key, value)
13230 
      for key, value in self.__dict__.iteritems()]
13231 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13232 
 
13233 
  def __eq__(self, other):
13234 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13235 
 
13236 
  def __ne__(self, other):
13237 
    return not (self == other)
13238 
 
3064 chandransh 13239 
class markOrdersAsDelivered_args:
304 ashish 13240 
  """
13241 
  Attributes:
3064 chandransh 13242 
   - providerId
13243 
   - deliveredOrders
304 ashish 13244 
  """
13245 
 
13246 
  thrift_spec = (
13247 
    None, # 0
3064 chandransh 13248 
    (1, TType.I64, 'providerId', None, None, ), # 1
13249 
    (2, TType.MAP, 'deliveredOrders', (TType.STRING,None,TType.STRING,None), None, ), # 2
304 ashish 13250 
  )
13251 
 
3064 chandransh 13252 
  def __init__(self, providerId=None, deliveredOrders=None,):
13253 
    self.providerId = providerId
13254 
    self.deliveredOrders = deliveredOrders
304 ashish 13255 
 
13256 
  def read(self, iprot):
13257 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13258 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13259 
      return
13260 
    iprot.readStructBegin()
13261 
    while True:
13262 
      (fname, ftype, fid) = iprot.readFieldBegin()
13263 
      if ftype == TType.STOP:
13264 
        break
13265 
      if fid == 1:
13266 
        if ftype == TType.I64:
3064 chandransh 13267 
          self.providerId = iprot.readI64();
304 ashish 13268 
        else:
13269 
          iprot.skip(ftype)
13270 
      elif fid == 2:
3064 chandransh 13271 
        if ftype == TType.MAP:
13272 
          self.deliveredOrders = {}
5676 rajveer 13273 
          (_ktype269, _vtype270, _size268 ) = iprot.readMapBegin()
13274 
          for _i272 in xrange(_size268):
13275 
            _key273 = iprot.readString();
13276 
            _val274 = iprot.readString();
13277 
            self.deliveredOrders[_key273] = _val274
3064 chandransh 13278 
          iprot.readMapEnd()
304 ashish 13279 
        else:
13280 
          iprot.skip(ftype)
13281 
      else:
13282 
        iprot.skip(ftype)
13283 
      iprot.readFieldEnd()
13284 
    iprot.readStructEnd()
13285 
 
13286 
  def write(self, oprot):
13287 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13288 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13289 
      return
3064 chandransh 13290 
    oprot.writeStructBegin('markOrdersAsDelivered_args')
3431 rajveer 13291 
    if self.providerId is not None:
3064 chandransh 13292 
      oprot.writeFieldBegin('providerId', TType.I64, 1)
13293 
      oprot.writeI64(self.providerId)
304 ashish 13294 
      oprot.writeFieldEnd()
3431 rajveer 13295 
    if self.deliveredOrders is not None:
3064 chandransh 13296 
      oprot.writeFieldBegin('deliveredOrders', TType.MAP, 2)
13297 
      oprot.writeMapBegin(TType.STRING, TType.STRING, len(self.deliveredOrders))
5676 rajveer 13298 
      for kiter275,viter276 in self.deliveredOrders.items():
13299 
        oprot.writeString(kiter275)
13300 
        oprot.writeString(viter276)
3064 chandransh 13301 
      oprot.writeMapEnd()
304 ashish 13302 
      oprot.writeFieldEnd()
13303 
    oprot.writeFieldStop()
13304 
    oprot.writeStructEnd()
13305 
 
3431 rajveer 13306 
  def validate(self):
13307 
    return
13308 
 
13309 
 
304 ashish 13310 
  def __repr__(self):
13311 
    L = ['%s=%r' % (key, value)
13312 
      for key, value in self.__dict__.iteritems()]
13313 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13314 
 
13315 
  def __eq__(self, other):
13316 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13317 
 
13318 
  def __ne__(self, other):
13319 
    return not (self == other)
13320 
 
3064 chandransh 13321 
class markOrdersAsDelivered_result:
13322 
  """
13323 
  Attributes:
13324 
   - ex
13325 
  """
304 ashish 13326 
 
13327 
  thrift_spec = (
3064 chandransh 13328 
    None, # 0
13329 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
304 ashish 13330 
  )
13331 
 
3064 chandransh 13332 
  def __init__(self, ex=None,):
13333 
    self.ex = ex
304 ashish 13334 
 
1596 ankur.sing 13335 
  def read(self, iprot):
13336 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13337 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13338 
      return
13339 
    iprot.readStructBegin()
13340 
    while True:
13341 
      (fname, ftype, fid) = iprot.readFieldBegin()
13342 
      if ftype == TType.STOP:
13343 
        break
3064 chandransh 13344 
      if fid == 1:
13345 
        if ftype == TType.STRUCT:
13346 
          self.ex = TransactionServiceException()
13347 
          self.ex.read(iprot)
13348 
        else:
13349 
          iprot.skip(ftype)
1596 ankur.sing 13350 
      else:
13351 
        iprot.skip(ftype)
13352 
      iprot.readFieldEnd()
13353 
    iprot.readStructEnd()
13354 
 
13355 
  def write(self, oprot):
13356 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13357 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13358 
      return
3064 chandransh 13359 
    oprot.writeStructBegin('markOrdersAsDelivered_result')
3431 rajveer 13360 
    if self.ex is not None:
3064 chandransh 13361 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
13362 
      self.ex.write(oprot)
13363 
      oprot.writeFieldEnd()
1596 ankur.sing 13364 
    oprot.writeFieldStop()
13365 
    oprot.writeStructEnd()
13366 
 
3431 rajveer 13367 
  def validate(self):
13368 
    return
13369 
 
13370 
 
1596 ankur.sing 13371 
  def __repr__(self):
13372 
    L = ['%s=%r' % (key, value)
13373 
      for key, value in self.__dict__.iteritems()]
13374 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13375 
 
13376 
  def __eq__(self, other):
13377 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13378 
 
13379 
  def __ne__(self, other):
13380 
    return not (self == other)
13381 
 
4910 phani.kuma 13382 
class markAsRTOrders_args:
1596 ankur.sing 13383 
  """
13384 
  Attributes:
3064 chandransh 13385 
   - providerId
13386 
   - returnedOrders
1596 ankur.sing 13387 
  """
13388 
 
13389 
  thrift_spec = (
3064 chandransh 13390 
    None, # 0
13391 
    (1, TType.I64, 'providerId', None, None, ), # 1
13392 
    (2, TType.MAP, 'returnedOrders', (TType.STRING,None,TType.STRING,None), None, ), # 2
1596 ankur.sing 13393 
  )
13394 
 
3064 chandransh 13395 
  def __init__(self, providerId=None, returnedOrders=None,):
13396 
    self.providerId = providerId
13397 
    self.returnedOrders = returnedOrders
1596 ankur.sing 13398 
 
13399 
  def read(self, iprot):
13400 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13401 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13402 
      return
13403 
    iprot.readStructBegin()
13404 
    while True:
13405 
      (fname, ftype, fid) = iprot.readFieldBegin()
13406 
      if ftype == TType.STOP:
13407 
        break
3064 chandransh 13408 
      if fid == 1:
1596 ankur.sing 13409 
        if ftype == TType.I64:
3064 chandransh 13410 
          self.providerId = iprot.readI64();
1596 ankur.sing 13411 
        else:
13412 
          iprot.skip(ftype)
3064 chandransh 13413 
      elif fid == 2:
13414 
        if ftype == TType.MAP:
13415 
          self.returnedOrders = {}
5676 rajveer 13416 
          (_ktype278, _vtype279, _size277 ) = iprot.readMapBegin()
13417 
          for _i281 in xrange(_size277):
13418 
            _key282 = iprot.readString();
13419 
            _val283 = iprot.readString();
13420 
            self.returnedOrders[_key282] = _val283
3064 chandransh 13421 
          iprot.readMapEnd()
13422 
        else:
13423 
          iprot.skip(ftype)
1596 ankur.sing 13424 
      else:
13425 
        iprot.skip(ftype)
13426 
      iprot.readFieldEnd()
13427 
    iprot.readStructEnd()
13428 
 
13429 
  def write(self, oprot):
13430 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13431 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13432 
      return
4910 phani.kuma 13433 
    oprot.writeStructBegin('markAsRTOrders_args')
3431 rajveer 13434 
    if self.providerId is not None:
3064 chandransh 13435 
      oprot.writeFieldBegin('providerId', TType.I64, 1)
13436 
      oprot.writeI64(self.providerId)
1596 ankur.sing 13437 
      oprot.writeFieldEnd()
3431 rajveer 13438 
    if self.returnedOrders is not None:
3064 chandransh 13439 
      oprot.writeFieldBegin('returnedOrders', TType.MAP, 2)
13440 
      oprot.writeMapBegin(TType.STRING, TType.STRING, len(self.returnedOrders))
5676 rajveer 13441 
      for kiter284,viter285 in self.returnedOrders.items():
13442 
        oprot.writeString(kiter284)
13443 
        oprot.writeString(viter285)
3064 chandransh 13444 
      oprot.writeMapEnd()
13445 
      oprot.writeFieldEnd()
1596 ankur.sing 13446 
    oprot.writeFieldStop()
13447 
    oprot.writeStructEnd()
13448 
 
3431 rajveer 13449 
  def validate(self):
13450 
    return
13451 
 
13452 
 
1596 ankur.sing 13453 
  def __repr__(self):
13454 
    L = ['%s=%r' % (key, value)
13455 
      for key, value in self.__dict__.iteritems()]
13456 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13457 
 
13458 
  def __eq__(self, other):
13459 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13460 
 
13461 
  def __ne__(self, other):
13462 
    return not (self == other)
13463 
 
4910 phani.kuma 13464 
class markAsRTOrders_result:
3064 chandransh 13465 
  """
13466 
  Attributes:
13467 
   - ex
13468 
  """
1596 ankur.sing 13469 
 
1627 ankur.sing 13470 
  thrift_spec = (
3064 chandransh 13471 
    None, # 0
13472 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
1627 ankur.sing 13473 
  )
13474 
 
3064 chandransh 13475 
  def __init__(self, ex=None,):
13476 
    self.ex = ex
13477 
 
1627 ankur.sing 13478 
  def read(self, iprot):
13479 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13480 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13481 
      return
13482 
    iprot.readStructBegin()
13483 
    while True:
13484 
      (fname, ftype, fid) = iprot.readFieldBegin()
13485 
      if ftype == TType.STOP:
13486 
        break
3064 chandransh 13487 
      if fid == 1:
13488 
        if ftype == TType.STRUCT:
13489 
          self.ex = TransactionServiceException()
13490 
          self.ex.read(iprot)
13491 
        else:
13492 
          iprot.skip(ftype)
1627 ankur.sing 13493 
      else:
13494 
        iprot.skip(ftype)
13495 
      iprot.readFieldEnd()
13496 
    iprot.readStructEnd()
13497 
 
13498 
  def write(self, oprot):
13499 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13500 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13501 
      return
4910 phani.kuma 13502 
    oprot.writeStructBegin('markAsRTOrders_result')
3431 rajveer 13503 
    if self.ex is not None:
3064 chandransh 13504 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
13505 
      self.ex.write(oprot)
13506 
      oprot.writeFieldEnd()
1627 ankur.sing 13507 
    oprot.writeFieldStop()
13508 
    oprot.writeStructEnd()
13509 
 
3431 rajveer 13510 
  def validate(self):
13511 
    return
13512 
 
13513 
 
1627 ankur.sing 13514 
  def __repr__(self):
13515 
    L = ['%s=%r' % (key, value)
13516 
      for key, value in self.__dict__.iteritems()]
13517 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13518 
 
13519 
  def __eq__(self, other):
13520 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13521 
 
13522 
  def __ne__(self, other):
13523 
    return not (self == other)
13524 
 
4910 phani.kuma 13525 
class getRTOrders_args:
13526 
  """
13527 
  Attributes:
13528 
   - providerId
13529 
  """
13530 
 
13531 
  thrift_spec = (
13532 
    None, # 0
13533 
    (1, TType.I64, 'providerId', None, None, ), # 1
13534 
  )
13535 
 
13536 
  def __init__(self, providerId=None,):
13537 
    self.providerId = providerId
13538 
 
13539 
  def read(self, iprot):
13540 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13541 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13542 
      return
13543 
    iprot.readStructBegin()
13544 
    while True:
13545 
      (fname, ftype, fid) = iprot.readFieldBegin()
13546 
      if ftype == TType.STOP:
13547 
        break
13548 
      if fid == 1:
13549 
        if ftype == TType.I64:
13550 
          self.providerId = iprot.readI64();
13551 
        else:
13552 
          iprot.skip(ftype)
13553 
      else:
13554 
        iprot.skip(ftype)
13555 
      iprot.readFieldEnd()
13556 
    iprot.readStructEnd()
13557 
 
13558 
  def write(self, oprot):
13559 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13560 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13561 
      return
13562 
    oprot.writeStructBegin('getRTOrders_args')
13563 
    if self.providerId is not None:
13564 
      oprot.writeFieldBegin('providerId', TType.I64, 1)
13565 
      oprot.writeI64(self.providerId)
13566 
      oprot.writeFieldEnd()
13567 
    oprot.writeFieldStop()
13568 
    oprot.writeStructEnd()
13569 
 
13570 
  def validate(self):
13571 
    return
13572 
 
13573 
 
13574 
  def __repr__(self):
13575 
    L = ['%s=%r' % (key, value)
13576 
      for key, value in self.__dict__.iteritems()]
13577 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13578 
 
13579 
  def __eq__(self, other):
13580 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13581 
 
13582 
  def __ne__(self, other):
13583 
    return not (self == other)
13584 
 
13585 
class getRTOrders_result:
13586 
  """
13587 
  Attributes:
13588 
   - success
13589 
  """
13590 
 
13591 
  thrift_spec = (
13592 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
13593 
  )
13594 
 
13595 
  def __init__(self, success=None,):
13596 
    self.success = success
13597 
 
13598 
  def read(self, iprot):
13599 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13600 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13601 
      return
13602 
    iprot.readStructBegin()
13603 
    while True:
13604 
      (fname, ftype, fid) = iprot.readFieldBegin()
13605 
      if ftype == TType.STOP:
13606 
        break
13607 
      if fid == 0:
13608 
        if ftype == TType.LIST:
13609 
          self.success = []
5676 rajveer 13610 
          (_etype289, _size286) = iprot.readListBegin()
13611 
          for _i290 in xrange(_size286):
13612 
            _elem291 = Order()
13613 
            _elem291.read(iprot)
13614 
            self.success.append(_elem291)
4910 phani.kuma 13615 
          iprot.readListEnd()
13616 
        else:
13617 
          iprot.skip(ftype)
13618 
      else:
13619 
        iprot.skip(ftype)
13620 
      iprot.readFieldEnd()
13621 
    iprot.readStructEnd()
13622 
 
13623 
  def write(self, oprot):
13624 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13625 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13626 
      return
13627 
    oprot.writeStructBegin('getRTOrders_result')
13628 
    if self.success is not None:
13629 
      oprot.writeFieldBegin('success', TType.LIST, 0)
13630 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
5676 rajveer 13631 
      for iter292 in self.success:
13632 
        iter292.write(oprot)
4910 phani.kuma 13633 
      oprot.writeListEnd()
13634 
      oprot.writeFieldEnd()
13635 
    oprot.writeFieldStop()
13636 
    oprot.writeStructEnd()
13637 
 
13638 
  def validate(self):
13639 
    return
13640 
 
13641 
 
13642 
  def __repr__(self):
13643 
    L = ['%s=%r' % (key, value)
13644 
      for key, value in self.__dict__.iteritems()]
13645 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13646 
 
13647 
  def __eq__(self, other):
13648 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13649 
 
13650 
  def __ne__(self, other):
13651 
    return not (self == other)
13652 
 
3064 chandransh 13653 
class updateNonDeliveryReason_args:
1627 ankur.sing 13654 
  """
13655 
  Attributes:
3064 chandransh 13656 
   - providerId
13657 
   - undeliveredOrders
1627 ankur.sing 13658 
  """
13659 
 
13660 
  thrift_spec = (
3064 chandransh 13661 
    None, # 0
13662 
    (1, TType.I64, 'providerId', None, None, ), # 1
13663 
    (2, TType.MAP, 'undeliveredOrders', (TType.STRING,None,TType.STRING,None), None, ), # 2
1627 ankur.sing 13664 
  )
13665 
 
3064 chandransh 13666 
  def __init__(self, providerId=None, undeliveredOrders=None,):
13667 
    self.providerId = providerId
13668 
    self.undeliveredOrders = undeliveredOrders
1627 ankur.sing 13669 
 
13670 
  def read(self, iprot):
13671 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13672 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13673 
      return
13674 
    iprot.readStructBegin()
13675 
    while True:
13676 
      (fname, ftype, fid) = iprot.readFieldBegin()
13677 
      if ftype == TType.STOP:
13678 
        break
3064 chandransh 13679 
      if fid == 1:
1627 ankur.sing 13680 
        if ftype == TType.I64:
3064 chandransh 13681 
          self.providerId = iprot.readI64();
1627 ankur.sing 13682 
        else:
13683 
          iprot.skip(ftype)
3064 chandransh 13684 
      elif fid == 2:
13685 
        if ftype == TType.MAP:
13686 
          self.undeliveredOrders = {}
5676 rajveer 13687 
          (_ktype294, _vtype295, _size293 ) = iprot.readMapBegin()
13688 
          for _i297 in xrange(_size293):
13689 
            _key298 = iprot.readString();
13690 
            _val299 = iprot.readString();
13691 
            self.undeliveredOrders[_key298] = _val299
3064 chandransh 13692 
          iprot.readMapEnd()
13693 
        else:
13694 
          iprot.skip(ftype)
1627 ankur.sing 13695 
      else:
13696 
        iprot.skip(ftype)
13697 
      iprot.readFieldEnd()
13698 
    iprot.readStructEnd()
13699 
 
13700 
  def write(self, oprot):
13701 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13702 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13703 
      return
3064 chandransh 13704 
    oprot.writeStructBegin('updateNonDeliveryReason_args')
3431 rajveer 13705 
    if self.providerId is not None:
3064 chandransh 13706 
      oprot.writeFieldBegin('providerId', TType.I64, 1)
13707 
      oprot.writeI64(self.providerId)
1627 ankur.sing 13708 
      oprot.writeFieldEnd()
3431 rajveer 13709 
    if self.undeliveredOrders is not None:
3064 chandransh 13710 
      oprot.writeFieldBegin('undeliveredOrders', TType.MAP, 2)
13711 
      oprot.writeMapBegin(TType.STRING, TType.STRING, len(self.undeliveredOrders))
5676 rajveer 13712 
      for kiter300,viter301 in self.undeliveredOrders.items():
13713 
        oprot.writeString(kiter300)
13714 
        oprot.writeString(viter301)
3064 chandransh 13715 
      oprot.writeMapEnd()
13716 
      oprot.writeFieldEnd()
1627 ankur.sing 13717 
    oprot.writeFieldStop()
13718 
    oprot.writeStructEnd()
13719 
 
3431 rajveer 13720 
  def validate(self):
13721 
    return
13722 
 
13723 
 
1627 ankur.sing 13724 
  def __repr__(self):
13725 
    L = ['%s=%r' % (key, value)
13726 
      for key, value in self.__dict__.iteritems()]
13727 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13728 
 
13729 
  def __eq__(self, other):
13730 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13731 
 
13732 
  def __ne__(self, other):
13733 
    return not (self == other)
13734 
 
3064 chandransh 13735 
class updateNonDeliveryReason_result:
1627 ankur.sing 13736 
  """
13737 
  Attributes:
3064 chandransh 13738 
   - ex
1627 ankur.sing 13739 
  """
13740 
 
13741 
  thrift_spec = (
4910 phani.kuma 13742 
    None, # 0
3064 chandransh 13743 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
1627 ankur.sing 13744 
  )
13745 
 
4910 phani.kuma 13746 
  def __init__(self, ex=None,):
3064 chandransh 13747 
    self.ex = ex
1627 ankur.sing 13748 
 
13749 
  def read(self, iprot):
13750 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13751 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13752 
      return
13753 
    iprot.readStructBegin()
13754 
    while True:
13755 
      (fname, ftype, fid) = iprot.readFieldBegin()
13756 
      if ftype == TType.STOP:
13757 
        break
4910 phani.kuma 13758 
      if fid == 1:
13759 
        if ftype == TType.STRUCT:
13760 
          self.ex = TransactionServiceException()
13761 
          self.ex.read(iprot)
13762 
        else:
13763 
          iprot.skip(ftype)
13764 
      else:
13765 
        iprot.skip(ftype)
13766 
      iprot.readFieldEnd()
13767 
    iprot.readStructEnd()
13768 
 
13769 
  def write(self, oprot):
13770 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13771 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13772 
      return
13773 
    oprot.writeStructBegin('updateNonDeliveryReason_result')
13774 
    if self.ex is not None:
13775 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
13776 
      self.ex.write(oprot)
13777 
      oprot.writeFieldEnd()
13778 
    oprot.writeFieldStop()
13779 
    oprot.writeStructEnd()
13780 
 
13781 
  def validate(self):
13782 
    return
13783 
 
13784 
 
13785 
  def __repr__(self):
13786 
    L = ['%s=%r' % (key, value)
13787 
      for key, value in self.__dict__.iteritems()]
13788 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13789 
 
13790 
  def __eq__(self, other):
13791 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13792 
 
13793 
  def __ne__(self, other):
13794 
    return not (self == other)
13795 
 
13796 
class getNonDeliveredOrdersbyCourier_args:
13797 
  """
13798 
  Attributes:
13799 
   - providerId
13800 
  """
13801 
 
13802 
  thrift_spec = (
13803 
    None, # 0
13804 
    (1, TType.I64, 'providerId', None, None, ), # 1
13805 
  )
13806 
 
13807 
  def __init__(self, providerId=None,):
13808 
    self.providerId = providerId
13809 
 
13810 
  def read(self, iprot):
13811 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13812 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13813 
      return
13814 
    iprot.readStructBegin()
13815 
    while True:
13816 
      (fname, ftype, fid) = iprot.readFieldBegin()
13817 
      if ftype == TType.STOP:
13818 
        break
13819 
      if fid == 1:
13820 
        if ftype == TType.I64:
13821 
          self.providerId = iprot.readI64();
13822 
        else:
13823 
          iprot.skip(ftype)
13824 
      else:
13825 
        iprot.skip(ftype)
13826 
      iprot.readFieldEnd()
13827 
    iprot.readStructEnd()
13828 
 
13829 
  def write(self, oprot):
13830 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13831 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13832 
      return
13833 
    oprot.writeStructBegin('getNonDeliveredOrdersbyCourier_args')
13834 
    if self.providerId is not None:
13835 
      oprot.writeFieldBegin('providerId', TType.I64, 1)
13836 
      oprot.writeI64(self.providerId)
13837 
      oprot.writeFieldEnd()
13838 
    oprot.writeFieldStop()
13839 
    oprot.writeStructEnd()
13840 
 
13841 
  def validate(self):
13842 
    return
13843 
 
13844 
 
13845 
  def __repr__(self):
13846 
    L = ['%s=%r' % (key, value)
13847 
      for key, value in self.__dict__.iteritems()]
13848 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13849 
 
13850 
  def __eq__(self, other):
13851 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13852 
 
13853 
  def __ne__(self, other):
13854 
    return not (self == other)
13855 
 
13856 
class getNonDeliveredOrdersbyCourier_result:
13857 
  """
13858 
  Attributes:
13859 
   - success
13860 
  """
13861 
 
13862 
  thrift_spec = (
13863 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
13864 
  )
13865 
 
13866 
  def __init__(self, success=None,):
13867 
    self.success = success
13868 
 
13869 
  def read(self, iprot):
13870 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13871 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13872 
      return
13873 
    iprot.readStructBegin()
13874 
    while True:
13875 
      (fname, ftype, fid) = iprot.readFieldBegin()
13876 
      if ftype == TType.STOP:
13877 
        break
4581 phani.kuma 13878 
      if fid == 0:
13879 
        if ftype == TType.LIST:
13880 
          self.success = []
5676 rajveer 13881 
          (_etype305, _size302) = iprot.readListBegin()
13882 
          for _i306 in xrange(_size302):
13883 
            _elem307 = Order()
13884 
            _elem307.read(iprot)
13885 
            self.success.append(_elem307)
4581 phani.kuma 13886 
          iprot.readListEnd()
13887 
        else:
13888 
          iprot.skip(ftype)
4910 phani.kuma 13889 
      else:
13890 
        iprot.skip(ftype)
13891 
      iprot.readFieldEnd()
13892 
    iprot.readStructEnd()
13893 
 
13894 
  def write(self, oprot):
13895 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13896 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13897 
      return
13898 
    oprot.writeStructBegin('getNonDeliveredOrdersbyCourier_result')
13899 
    if self.success is not None:
13900 
      oprot.writeFieldBegin('success', TType.LIST, 0)
13901 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
5676 rajveer 13902 
      for iter308 in self.success:
13903 
        iter308.write(oprot)
4910 phani.kuma 13904 
      oprot.writeListEnd()
13905 
      oprot.writeFieldEnd()
13906 
    oprot.writeFieldStop()
13907 
    oprot.writeStructEnd()
13908 
 
13909 
  def validate(self):
13910 
    return
13911 
 
13912 
 
13913 
  def __repr__(self):
13914 
    L = ['%s=%r' % (key, value)
13915 
      for key, value in self.__dict__.iteritems()]
13916 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13917 
 
13918 
  def __eq__(self, other):
13919 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13920 
 
13921 
  def __ne__(self, other):
13922 
    return not (self == other)
13923 
 
13924 
class markOrdersAsLocalConnected_args:
13925 
  """
13926 
  Attributes:
13927 
   - providerId
13928 
   - local_connected_orders
13929 
  """
13930 
 
13931 
  thrift_spec = (
13932 
    None, # 0
13933 
    (1, TType.I64, 'providerId', None, None, ), # 1
13934 
    (2, TType.MAP, 'local_connected_orders', (TType.STRING,None,TType.STRING,None), None, ), # 2
13935 
  )
13936 
 
13937 
  def __init__(self, providerId=None, local_connected_orders=None,):
13938 
    self.providerId = providerId
13939 
    self.local_connected_orders = local_connected_orders
13940 
 
13941 
  def read(self, iprot):
13942 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13943 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13944 
      return
13945 
    iprot.readStructBegin()
13946 
    while True:
13947 
      (fname, ftype, fid) = iprot.readFieldBegin()
13948 
      if ftype == TType.STOP:
13949 
        break
13950 
      if fid == 1:
13951 
        if ftype == TType.I64:
13952 
          self.providerId = iprot.readI64();
13953 
        else:
13954 
          iprot.skip(ftype)
13955 
      elif fid == 2:
13956 
        if ftype == TType.MAP:
13957 
          self.local_connected_orders = {}
5676 rajveer 13958 
          (_ktype310, _vtype311, _size309 ) = iprot.readMapBegin()
13959 
          for _i313 in xrange(_size309):
13960 
            _key314 = iprot.readString();
13961 
            _val315 = iprot.readString();
13962 
            self.local_connected_orders[_key314] = _val315
4910 phani.kuma 13963 
          iprot.readMapEnd()
13964 
        else:
13965 
          iprot.skip(ftype)
13966 
      else:
13967 
        iprot.skip(ftype)
13968 
      iprot.readFieldEnd()
13969 
    iprot.readStructEnd()
13970 
 
13971 
  def write(self, oprot):
13972 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13973 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13974 
      return
13975 
    oprot.writeStructBegin('markOrdersAsLocalConnected_args')
13976 
    if self.providerId is not None:
13977 
      oprot.writeFieldBegin('providerId', TType.I64, 1)
13978 
      oprot.writeI64(self.providerId)
13979 
      oprot.writeFieldEnd()
13980 
    if self.local_connected_orders is not None:
13981 
      oprot.writeFieldBegin('local_connected_orders', TType.MAP, 2)
13982 
      oprot.writeMapBegin(TType.STRING, TType.STRING, len(self.local_connected_orders))
5676 rajveer 13983 
      for kiter316,viter317 in self.local_connected_orders.items():
13984 
        oprot.writeString(kiter316)
13985 
        oprot.writeString(viter317)
4910 phani.kuma 13986 
      oprot.writeMapEnd()
13987 
      oprot.writeFieldEnd()
13988 
    oprot.writeFieldStop()
13989 
    oprot.writeStructEnd()
13990 
 
13991 
  def validate(self):
13992 
    return
13993 
 
13994 
 
13995 
  def __repr__(self):
13996 
    L = ['%s=%r' % (key, value)
13997 
      for key, value in self.__dict__.iteritems()]
13998 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13999 
 
14000 
  def __eq__(self, other):
14001 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14002 
 
14003 
  def __ne__(self, other):
14004 
    return not (self == other)
14005 
 
14006 
class markOrdersAsLocalConnected_result:
14007 
  """
14008 
  Attributes:
14009 
   - ex
14010 
  """
14011 
 
14012 
  thrift_spec = (
14013 
    None, # 0
14014 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
14015 
  )
14016 
 
14017 
  def __init__(self, ex=None,):
14018 
    self.ex = ex
14019 
 
14020 
  def read(self, iprot):
14021 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14022 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14023 
      return
14024 
    iprot.readStructBegin()
14025 
    while True:
14026 
      (fname, ftype, fid) = iprot.readFieldBegin()
14027 
      if ftype == TType.STOP:
14028 
        break
14029 
      if fid == 1:
3064 chandransh 14030 
        if ftype == TType.STRUCT:
14031 
          self.ex = TransactionServiceException()
14032 
          self.ex.read(iprot)
1627 ankur.sing 14033 
        else:
14034 
          iprot.skip(ftype)
14035 
      else:
14036 
        iprot.skip(ftype)
14037 
      iprot.readFieldEnd()
14038 
    iprot.readStructEnd()
14039 
 
14040 
  def write(self, oprot):
14041 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14042 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14043 
      return
4910 phani.kuma 14044 
    oprot.writeStructBegin('markOrdersAsLocalConnected_result')
14045 
    if self.ex is not None:
14046 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
14047 
      self.ex.write(oprot)
14048 
      oprot.writeFieldEnd()
14049 
    oprot.writeFieldStop()
14050 
    oprot.writeStructEnd()
14051 
 
14052 
  def validate(self):
14053 
    return
14054 
 
14055 
 
14056 
  def __repr__(self):
14057 
    L = ['%s=%r' % (key, value)
14058 
      for key, value in self.__dict__.iteritems()]
14059 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14060 
 
14061 
  def __eq__(self, other):
14062 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14063 
 
14064 
  def __ne__(self, other):
14065 
    return not (self == other)
14066 
 
14067 
class getOrdersNotLocalConnected_args:
14068 
  """
14069 
  Attributes:
14070 
   - providerId
14071 
  """
14072 
 
14073 
  thrift_spec = (
14074 
    None, # 0
14075 
    (1, TType.I64, 'providerId', None, None, ), # 1
14076 
  )
14077 
 
14078 
  def __init__(self, providerId=None,):
14079 
    self.providerId = providerId
14080 
 
14081 
  def read(self, iprot):
14082 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14083 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14084 
      return
14085 
    iprot.readStructBegin()
14086 
    while True:
14087 
      (fname, ftype, fid) = iprot.readFieldBegin()
14088 
      if ftype == TType.STOP:
14089 
        break
14090 
      if fid == 1:
14091 
        if ftype == TType.I64:
14092 
          self.providerId = iprot.readI64();
14093 
        else:
14094 
          iprot.skip(ftype)
14095 
      else:
14096 
        iprot.skip(ftype)
14097 
      iprot.readFieldEnd()
14098 
    iprot.readStructEnd()
14099 
 
14100 
  def write(self, oprot):
14101 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14102 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14103 
      return
14104 
    oprot.writeStructBegin('getOrdersNotLocalConnected_args')
14105 
    if self.providerId is not None:
14106 
      oprot.writeFieldBegin('providerId', TType.I64, 1)
14107 
      oprot.writeI64(self.providerId)
14108 
      oprot.writeFieldEnd()
14109 
    oprot.writeFieldStop()
14110 
    oprot.writeStructEnd()
14111 
 
14112 
  def validate(self):
14113 
    return
14114 
 
14115 
 
14116 
  def __repr__(self):
14117 
    L = ['%s=%r' % (key, value)
14118 
      for key, value in self.__dict__.iteritems()]
14119 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14120 
 
14121 
  def __eq__(self, other):
14122 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14123 
 
14124 
  def __ne__(self, other):
14125 
    return not (self == other)
14126 
 
14127 
class getOrdersNotLocalConnected_result:
14128 
  """
14129 
  Attributes:
14130 
   - success
14131 
  """
14132 
 
14133 
  thrift_spec = (
14134 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
14135 
  )
14136 
 
14137 
  def __init__(self, success=None,):
14138 
    self.success = success
14139 
 
14140 
  def read(self, iprot):
14141 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14142 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14143 
      return
14144 
    iprot.readStructBegin()
14145 
    while True:
14146 
      (fname, ftype, fid) = iprot.readFieldBegin()
14147 
      if ftype == TType.STOP:
14148 
        break
14149 
      if fid == 0:
14150 
        if ftype == TType.LIST:
14151 
          self.success = []
5676 rajveer 14152 
          (_etype321, _size318) = iprot.readListBegin()
14153 
          for _i322 in xrange(_size318):
14154 
            _elem323 = Order()
14155 
            _elem323.read(iprot)
14156 
            self.success.append(_elem323)
4910 phani.kuma 14157 
          iprot.readListEnd()
14158 
        else:
14159 
          iprot.skip(ftype)
14160 
      else:
14161 
        iprot.skip(ftype)
14162 
      iprot.readFieldEnd()
14163 
    iprot.readStructEnd()
14164 
 
14165 
  def write(self, oprot):
14166 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14167 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14168 
      return
14169 
    oprot.writeStructBegin('getOrdersNotLocalConnected_result')
4581 phani.kuma 14170 
    if self.success is not None:
14171 
      oprot.writeFieldBegin('success', TType.LIST, 0)
14172 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
5676 rajveer 14173 
      for iter324 in self.success:
14174 
        iter324.write(oprot)
4581 phani.kuma 14175 
      oprot.writeListEnd()
14176 
      oprot.writeFieldEnd()
4910 phani.kuma 14177 
    oprot.writeFieldStop()
14178 
    oprot.writeStructEnd()
14179 
 
14180 
  def validate(self):
14181 
    return
14182 
 
14183 
 
14184 
  def __repr__(self):
14185 
    L = ['%s=%r' % (key, value)
14186 
      for key, value in self.__dict__.iteritems()]
14187 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14188 
 
14189 
  def __eq__(self, other):
14190 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14191 
 
14192 
  def __ne__(self, other):
14193 
    return not (self == other)
14194 
 
14195 
class markOrdersAsDestinationCityReached_args:
14196 
  """
14197 
  Attributes:
14198 
   - providerId
14199 
   - destination_city_reached_orders
14200 
  """
14201 
 
14202 
  thrift_spec = (
14203 
    None, # 0
14204 
    (1, TType.I64, 'providerId', None, None, ), # 1
14205 
    (2, TType.MAP, 'destination_city_reached_orders', (TType.STRING,None,TType.STRING,None), None, ), # 2
14206 
  )
14207 
 
14208 
  def __init__(self, providerId=None, destination_city_reached_orders=None,):
14209 
    self.providerId = providerId
14210 
    self.destination_city_reached_orders = destination_city_reached_orders
14211 
 
14212 
  def read(self, iprot):
14213 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14214 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14215 
      return
14216 
    iprot.readStructBegin()
14217 
    while True:
14218 
      (fname, ftype, fid) = iprot.readFieldBegin()
14219 
      if ftype == TType.STOP:
14220 
        break
14221 
      if fid == 1:
14222 
        if ftype == TType.I64:
14223 
          self.providerId = iprot.readI64();
14224 
        else:
14225 
          iprot.skip(ftype)
14226 
      elif fid == 2:
14227 
        if ftype == TType.MAP:
14228 
          self.destination_city_reached_orders = {}
5676 rajveer 14229 
          (_ktype326, _vtype327, _size325 ) = iprot.readMapBegin()
14230 
          for _i329 in xrange(_size325):
14231 
            _key330 = iprot.readString();
14232 
            _val331 = iprot.readString();
14233 
            self.destination_city_reached_orders[_key330] = _val331
4910 phani.kuma 14234 
          iprot.readMapEnd()
14235 
        else:
14236 
          iprot.skip(ftype)
14237 
      else:
14238 
        iprot.skip(ftype)
14239 
      iprot.readFieldEnd()
14240 
    iprot.readStructEnd()
14241 
 
14242 
  def write(self, oprot):
14243 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14244 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14245 
      return
14246 
    oprot.writeStructBegin('markOrdersAsDestinationCityReached_args')
14247 
    if self.providerId is not None:
14248 
      oprot.writeFieldBegin('providerId', TType.I64, 1)
14249 
      oprot.writeI64(self.providerId)
14250 
      oprot.writeFieldEnd()
14251 
    if self.destination_city_reached_orders is not None:
14252 
      oprot.writeFieldBegin('destination_city_reached_orders', TType.MAP, 2)
14253 
      oprot.writeMapBegin(TType.STRING, TType.STRING, len(self.destination_city_reached_orders))
5676 rajveer 14254 
      for kiter332,viter333 in self.destination_city_reached_orders.items():
14255 
        oprot.writeString(kiter332)
14256 
        oprot.writeString(viter333)
4910 phani.kuma 14257 
      oprot.writeMapEnd()
14258 
      oprot.writeFieldEnd()
14259 
    oprot.writeFieldStop()
14260 
    oprot.writeStructEnd()
14261 
 
14262 
  def validate(self):
14263 
    return
14264 
 
14265 
 
14266 
  def __repr__(self):
14267 
    L = ['%s=%r' % (key, value)
14268 
      for key, value in self.__dict__.iteritems()]
14269 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14270 
 
14271 
  def __eq__(self, other):
14272 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14273 
 
14274 
  def __ne__(self, other):
14275 
    return not (self == other)
14276 
 
14277 
class markOrdersAsDestinationCityReached_result:
14278 
  """
14279 
  Attributes:
14280 
   - ex
14281 
  """
14282 
 
14283 
  thrift_spec = (
14284 
    None, # 0
14285 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
14286 
  )
14287 
 
14288 
  def __init__(self, ex=None,):
14289 
    self.ex = ex
14290 
 
14291 
  def read(self, iprot):
14292 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14293 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14294 
      return
14295 
    iprot.readStructBegin()
14296 
    while True:
14297 
      (fname, ftype, fid) = iprot.readFieldBegin()
14298 
      if ftype == TType.STOP:
14299 
        break
14300 
      if fid == 1:
14301 
        if ftype == TType.STRUCT:
14302 
          self.ex = TransactionServiceException()
14303 
          self.ex.read(iprot)
14304 
        else:
14305 
          iprot.skip(ftype)
14306 
      else:
14307 
        iprot.skip(ftype)
14308 
      iprot.readFieldEnd()
14309 
    iprot.readStructEnd()
14310 
 
14311 
  def write(self, oprot):
14312 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14313 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14314 
      return
14315 
    oprot.writeStructBegin('markOrdersAsDestinationCityReached_result')
3431 rajveer 14316 
    if self.ex is not None:
3064 chandransh 14317 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
14318 
      self.ex.write(oprot)
1627 ankur.sing 14319 
      oprot.writeFieldEnd()
14320 
    oprot.writeFieldStop()
14321 
    oprot.writeStructEnd()
14322 
 
3431 rajveer 14323 
  def validate(self):
14324 
    return
14325 
 
14326 
 
1627 ankur.sing 14327 
  def __repr__(self):
14328 
    L = ['%s=%r' % (key, value)
14329 
      for key, value in self.__dict__.iteritems()]
14330 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14331 
 
14332 
  def __eq__(self, other):
14333 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14334 
 
14335 
  def __ne__(self, other):
14336 
    return not (self == other)
14337 
 
4910 phani.kuma 14338 
class markOrdersAsFirstDeliveryAttempted_args:
14339 
  """
14340 
  Attributes:
14341 
   - providerId
14342 
   - first_atdl_orders
14343 
  """
14344 
 
14345 
  thrift_spec = (
14346 
    None, # 0
14347 
    (1, TType.I64, 'providerId', None, None, ), # 1
14348 
    (2, TType.MAP, 'first_atdl_orders', (TType.STRING,None,TType.STRING,None), None, ), # 2
14349 
  )
14350 
 
14351 
  def __init__(self, providerId=None, first_atdl_orders=None,):
14352 
    self.providerId = providerId
14353 
    self.first_atdl_orders = first_atdl_orders
14354 
 
14355 
  def read(self, iprot):
14356 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14357 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14358 
      return
14359 
    iprot.readStructBegin()
14360 
    while True:
14361 
      (fname, ftype, fid) = iprot.readFieldBegin()
14362 
      if ftype == TType.STOP:
14363 
        break
14364 
      if fid == 1:
14365 
        if ftype == TType.I64:
14366 
          self.providerId = iprot.readI64();
14367 
        else:
14368 
          iprot.skip(ftype)
14369 
      elif fid == 2:
14370 
        if ftype == TType.MAP:
14371 
          self.first_atdl_orders = {}
5676 rajveer 14372 
          (_ktype335, _vtype336, _size334 ) = iprot.readMapBegin()
14373 
          for _i338 in xrange(_size334):
14374 
            _key339 = iprot.readString();
14375 
            _val340 = iprot.readString();
14376 
            self.first_atdl_orders[_key339] = _val340
4910 phani.kuma 14377 
          iprot.readMapEnd()
14378 
        else:
14379 
          iprot.skip(ftype)
14380 
      else:
14381 
        iprot.skip(ftype)
14382 
      iprot.readFieldEnd()
14383 
    iprot.readStructEnd()
14384 
 
14385 
  def write(self, oprot):
14386 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14387 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14388 
      return
14389 
    oprot.writeStructBegin('markOrdersAsFirstDeliveryAttempted_args')
14390 
    if self.providerId is not None:
14391 
      oprot.writeFieldBegin('providerId', TType.I64, 1)
14392 
      oprot.writeI64(self.providerId)
14393 
      oprot.writeFieldEnd()
14394 
    if self.first_atdl_orders is not None:
14395 
      oprot.writeFieldBegin('first_atdl_orders', TType.MAP, 2)
14396 
      oprot.writeMapBegin(TType.STRING, TType.STRING, len(self.first_atdl_orders))
5676 rajveer 14397 
      for kiter341,viter342 in self.first_atdl_orders.items():
14398 
        oprot.writeString(kiter341)
14399 
        oprot.writeString(viter342)
4910 phani.kuma 14400 
      oprot.writeMapEnd()
14401 
      oprot.writeFieldEnd()
14402 
    oprot.writeFieldStop()
14403 
    oprot.writeStructEnd()
14404 
 
14405 
  def validate(self):
14406 
    return
14407 
 
14408 
 
14409 
  def __repr__(self):
14410 
    L = ['%s=%r' % (key, value)
14411 
      for key, value in self.__dict__.iteritems()]
14412 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14413 
 
14414 
  def __eq__(self, other):
14415 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14416 
 
14417 
  def __ne__(self, other):
14418 
    return not (self == other)
14419 
 
14420 
class markOrdersAsFirstDeliveryAttempted_result:
14421 
  """
14422 
  Attributes:
14423 
   - ex
14424 
  """
14425 
 
14426 
  thrift_spec = (
14427 
    None, # 0
14428 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
14429 
  )
14430 
 
14431 
  def __init__(self, ex=None,):
14432 
    self.ex = ex
14433 
 
14434 
  def read(self, iprot):
14435 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14436 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14437 
      return
14438 
    iprot.readStructBegin()
14439 
    while True:
14440 
      (fname, ftype, fid) = iprot.readFieldBegin()
14441 
      if ftype == TType.STOP:
14442 
        break
14443 
      if fid == 1:
14444 
        if ftype == TType.STRUCT:
14445 
          self.ex = TransactionServiceException()
14446 
          self.ex.read(iprot)
14447 
        else:
14448 
          iprot.skip(ftype)
14449 
      else:
14450 
        iprot.skip(ftype)
14451 
      iprot.readFieldEnd()
14452 
    iprot.readStructEnd()
14453 
 
14454 
  def write(self, oprot):
14455 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14456 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14457 
      return
14458 
    oprot.writeStructBegin('markOrdersAsFirstDeliveryAttempted_result')
14459 
    if self.ex is not None:
14460 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
14461 
      self.ex.write(oprot)
14462 
      oprot.writeFieldEnd()
14463 
    oprot.writeFieldStop()
14464 
    oprot.writeStructEnd()
14465 
 
14466 
  def validate(self):
14467 
    return
14468 
 
14469 
 
14470 
  def __repr__(self):
14471 
    L = ['%s=%r' % (key, value)
14472 
      for key, value in self.__dict__.iteritems()]
14473 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14474 
 
14475 
  def __eq__(self, other):
14476 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14477 
 
14478 
  def __ne__(self, other):
14479 
    return not (self == other)
14480 
 
3064 chandransh 14481 
class getUndeliveredOrders_args:
1886 ankur.sing 14482 
  """
14483 
  Attributes:
3064 chandransh 14484 
   - providerId
14485 
   - warehouseId
1886 ankur.sing 14486 
  """
1627 ankur.sing 14487 
 
1886 ankur.sing 14488 
  thrift_spec = (
14489 
    None, # 0
3064 chandransh 14490 
    (1, TType.I64, 'providerId', None, None, ), # 1
14491 
    (2, TType.I64, 'warehouseId', None, None, ), # 2
1886 ankur.sing 14492 
  )
14493 
 
3064 chandransh 14494 
  def __init__(self, providerId=None, warehouseId=None,):
14495 
    self.providerId = providerId
14496 
    self.warehouseId = warehouseId
1886 ankur.sing 14497 
 
14498 
  def read(self, iprot):
14499 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14500 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14501 
      return
14502 
    iprot.readStructBegin()
14503 
    while True:
14504 
      (fname, ftype, fid) = iprot.readFieldBegin()
14505 
      if ftype == TType.STOP:
14506 
        break
14507 
      if fid == 1:
14508 
        if ftype == TType.I64:
3064 chandransh 14509 
          self.providerId = iprot.readI64();
1886 ankur.sing 14510 
        else:
14511 
          iprot.skip(ftype)
3064 chandransh 14512 
      elif fid == 2:
14513 
        if ftype == TType.I64:
14514 
          self.warehouseId = iprot.readI64();
14515 
        else:
14516 
          iprot.skip(ftype)
1886 ankur.sing 14517 
      else:
14518 
        iprot.skip(ftype)
14519 
      iprot.readFieldEnd()
14520 
    iprot.readStructEnd()
14521 
 
14522 
  def write(self, oprot):
14523 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14524 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14525 
      return
3064 chandransh 14526 
    oprot.writeStructBegin('getUndeliveredOrders_args')
3431 rajveer 14527 
    if self.providerId is not None:
3064 chandransh 14528 
      oprot.writeFieldBegin('providerId', TType.I64, 1)
14529 
      oprot.writeI64(self.providerId)
1886 ankur.sing 14530 
      oprot.writeFieldEnd()
3431 rajveer 14531 
    if self.warehouseId is not None:
3064 chandransh 14532 
      oprot.writeFieldBegin('warehouseId', TType.I64, 2)
14533 
      oprot.writeI64(self.warehouseId)
14534 
      oprot.writeFieldEnd()
1886 ankur.sing 14535 
    oprot.writeFieldStop()
14536 
    oprot.writeStructEnd()
14537 
 
3431 rajveer 14538 
  def validate(self):
14539 
    return
14540 
 
14541 
 
1886 ankur.sing 14542 
  def __repr__(self):
14543 
    L = ['%s=%r' % (key, value)
14544 
      for key, value in self.__dict__.iteritems()]
14545 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14546 
 
14547 
  def __eq__(self, other):
14548 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14549 
 
14550 
  def __ne__(self, other):
14551 
    return not (self == other)
14552 
 
3064 chandransh 14553 
class getUndeliveredOrders_result:
1886 ankur.sing 14554 
  """
14555 
  Attributes:
14556 
   - success
14557 
  """
14558 
 
14559 
  thrift_spec = (
14560 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
14561 
  )
14562 
 
14563 
  def __init__(self, success=None,):
14564 
    self.success = success
14565 
 
14566 
  def read(self, iprot):
14567 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14568 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14569 
      return
14570 
    iprot.readStructBegin()
14571 
    while True:
14572 
      (fname, ftype, fid) = iprot.readFieldBegin()
14573 
      if ftype == TType.STOP:
14574 
        break
14575 
      if fid == 0:
14576 
        if ftype == TType.LIST:
14577 
          self.success = []
5676 rajveer 14578 
          (_etype346, _size343) = iprot.readListBegin()
14579 
          for _i347 in xrange(_size343):
14580 
            _elem348 = Order()
14581 
            _elem348.read(iprot)
14582 
            self.success.append(_elem348)
1886 ankur.sing 14583 
          iprot.readListEnd()
14584 
        else:
14585 
          iprot.skip(ftype)
14586 
      else:
14587 
        iprot.skip(ftype)
14588 
      iprot.readFieldEnd()
14589 
    iprot.readStructEnd()
14590 
 
14591 
  def write(self, oprot):
14592 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14593 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14594 
      return
3064 chandransh 14595 
    oprot.writeStructBegin('getUndeliveredOrders_result')
3431 rajveer 14596 
    if self.success is not None:
1886 ankur.sing 14597 
      oprot.writeFieldBegin('success', TType.LIST, 0)
14598 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
5676 rajveer 14599 
      for iter349 in self.success:
14600 
        iter349.write(oprot)
1886 ankur.sing 14601 
      oprot.writeListEnd()
14602 
      oprot.writeFieldEnd()
14603 
    oprot.writeFieldStop()
14604 
    oprot.writeStructEnd()
14605 
 
3431 rajveer 14606 
  def validate(self):
14607 
    return
14608 
 
14609 
 
1886 ankur.sing 14610 
  def __repr__(self):
14611 
    L = ['%s=%r' % (key, value)
14612 
      for key, value in self.__dict__.iteritems()]
14613 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14614 
 
14615 
  def __eq__(self, other):
14616 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14617 
 
14618 
  def __ne__(self, other):
14619 
    return not (self == other)
14620 
 
4783 phani.kuma 14621 
class getUndeliveredOrdersExpectedDeliveryDateNotMet_args:
14622 
 
14623 
  thrift_spec = (
14624 
  )
14625 
 
14626 
  def read(self, iprot):
14627 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14628 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14629 
      return
14630 
    iprot.readStructBegin()
14631 
    while True:
14632 
      (fname, ftype, fid) = iprot.readFieldBegin()
14633 
      if ftype == TType.STOP:
14634 
        break
14635 
      else:
14636 
        iprot.skip(ftype)
14637 
      iprot.readFieldEnd()
14638 
    iprot.readStructEnd()
14639 
 
14640 
  def write(self, oprot):
14641 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14642 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14643 
      return
14644 
    oprot.writeStructBegin('getUndeliveredOrdersExpectedDeliveryDateNotMet_args')
14645 
    oprot.writeFieldStop()
14646 
    oprot.writeStructEnd()
14647 
 
14648 
  def validate(self):
14649 
    return
14650 
 
14651 
 
14652 
  def __repr__(self):
14653 
    L = ['%s=%r' % (key, value)
14654 
      for key, value in self.__dict__.iteritems()]
14655 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14656 
 
14657 
  def __eq__(self, other):
14658 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14659 
 
14660 
  def __ne__(self, other):
14661 
    return not (self == other)
14662 
 
14663 
class getUndeliveredOrdersExpectedDeliveryDateNotMet_result:
14664 
  """
14665 
  Attributes:
14666 
   - success
14667 
  """
14668 
 
14669 
  thrift_spec = (
14670 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
14671 
  )
14672 
 
14673 
  def __init__(self, success=None,):
14674 
    self.success = success
14675 
 
14676 
  def read(self, iprot):
14677 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14678 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14679 
      return
14680 
    iprot.readStructBegin()
14681 
    while True:
14682 
      (fname, ftype, fid) = iprot.readFieldBegin()
14683 
      if ftype == TType.STOP:
14684 
        break
14685 
      if fid == 0:
14686 
        if ftype == TType.LIST:
14687 
          self.success = []
5676 rajveer 14688 
          (_etype353, _size350) = iprot.readListBegin()
14689 
          for _i354 in xrange(_size350):
14690 
            _elem355 = Order()
14691 
            _elem355.read(iprot)
14692 
            self.success.append(_elem355)
4783 phani.kuma 14693 
          iprot.readListEnd()
14694 
        else:
14695 
          iprot.skip(ftype)
14696 
      else:
14697 
        iprot.skip(ftype)
14698 
      iprot.readFieldEnd()
14699 
    iprot.readStructEnd()
14700 
 
14701 
  def write(self, oprot):
14702 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14703 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14704 
      return
14705 
    oprot.writeStructBegin('getUndeliveredOrdersExpectedDeliveryDateNotMet_result')
14706 
    if self.success is not None:
14707 
      oprot.writeFieldBegin('success', TType.LIST, 0)
14708 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
5676 rajveer 14709 
      for iter356 in self.success:
14710 
        iter356.write(oprot)
4783 phani.kuma 14711 
      oprot.writeListEnd()
14712 
      oprot.writeFieldEnd()
14713 
    oprot.writeFieldStop()
14714 
    oprot.writeStructEnd()
14715 
 
14716 
  def validate(self):
14717 
    return
14718 
 
14719 
 
14720 
  def __repr__(self):
14721 
    L = ['%s=%r' % (key, value)
14722 
      for key, value in self.__dict__.iteritems()]
14723 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14724 
 
14725 
  def __eq__(self, other):
14726 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14727 
 
14728 
  def __ne__(self, other):
14729 
    return not (self == other)
14730 
 
2536 chandransh 14731 
class toggleDOAFlag_args:
14732 
  """
14733 
  Attributes:
14734 
   - orderId
14735 
  """
1886 ankur.sing 14736 
 
2536 chandransh 14737 
  thrift_spec = (
14738 
    None, # 0
14739 
    (1, TType.I64, 'orderId', None, None, ), # 1
14740 
  )
14741 
 
14742 
  def __init__(self, orderId=None,):
14743 
    self.orderId = orderId
14744 
 
14745 
  def read(self, iprot):
14746 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14747 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14748 
      return
14749 
    iprot.readStructBegin()
14750 
    while True:
14751 
      (fname, ftype, fid) = iprot.readFieldBegin()
14752 
      if ftype == TType.STOP:
14753 
        break
14754 
      if fid == 1:
14755 
        if ftype == TType.I64:
14756 
          self.orderId = iprot.readI64();
14757 
        else:
14758 
          iprot.skip(ftype)
14759 
      else:
14760 
        iprot.skip(ftype)
14761 
      iprot.readFieldEnd()
14762 
    iprot.readStructEnd()
14763 
 
14764 
  def write(self, oprot):
14765 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14766 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14767 
      return
14768 
    oprot.writeStructBegin('toggleDOAFlag_args')
3431 rajveer 14769 
    if self.orderId is not None:
2536 chandransh 14770 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
14771 
      oprot.writeI64(self.orderId)
14772 
      oprot.writeFieldEnd()
14773 
    oprot.writeFieldStop()
14774 
    oprot.writeStructEnd()
14775 
 
3431 rajveer 14776 
  def validate(self):
14777 
    return
14778 
 
14779 
 
2536 chandransh 14780 
  def __repr__(self):
14781 
    L = ['%s=%r' % (key, value)
14782 
      for key, value in self.__dict__.iteritems()]
14783 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14784 
 
14785 
  def __eq__(self, other):
14786 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14787 
 
14788 
  def __ne__(self, other):
14789 
    return not (self == other)
14790 
 
14791 
class toggleDOAFlag_result:
14792 
  """
14793 
  Attributes:
14794 
   - success
14795 
   - ex
14796 
  """
14797 
 
14798 
  thrift_spec = (
14799 
    (0, TType.BOOL, 'success', None, None, ), # 0
14800 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
14801 
  )
14802 
 
14803 
  def __init__(self, success=None, ex=None,):
14804 
    self.success = success
14805 
    self.ex = ex
14806 
 
14807 
  def read(self, iprot):
14808 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14809 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14810 
      return
14811 
    iprot.readStructBegin()
14812 
    while True:
14813 
      (fname, ftype, fid) = iprot.readFieldBegin()
14814 
      if ftype == TType.STOP:
14815 
        break
14816 
      if fid == 0:
14817 
        if ftype == TType.BOOL:
14818 
          self.success = iprot.readBool();
14819 
        else:
14820 
          iprot.skip(ftype)
14821 
      elif fid == 1:
14822 
        if ftype == TType.STRUCT:
14823 
          self.ex = TransactionServiceException()
14824 
          self.ex.read(iprot)
14825 
        else:
14826 
          iprot.skip(ftype)
14827 
      else:
14828 
        iprot.skip(ftype)
14829 
      iprot.readFieldEnd()
14830 
    iprot.readStructEnd()
14831 
 
14832 
  def write(self, oprot):
14833 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14834 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14835 
      return
14836 
    oprot.writeStructBegin('toggleDOAFlag_result')
3431 rajveer 14837 
    if self.success is not None:
2536 chandransh 14838 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
14839 
      oprot.writeBool(self.success)
14840 
      oprot.writeFieldEnd()
3431 rajveer 14841 
    if self.ex is not None:
2536 chandransh 14842 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
14843 
      self.ex.write(oprot)
14844 
      oprot.writeFieldEnd()
14845 
    oprot.writeFieldStop()
14846 
    oprot.writeStructEnd()
14847 
 
3431 rajveer 14848 
  def validate(self):
14849 
    return
14850 
 
14851 
 
2536 chandransh 14852 
  def __repr__(self):
14853 
    L = ['%s=%r' % (key, value)
14854 
      for key, value in self.__dict__.iteritems()]
14855 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14856 
 
14857 
  def __eq__(self, other):
14858 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14859 
 
14860 
  def __ne__(self, other):
14861 
    return not (self == other)
14862 
 
4712 rajveer 14863 
class markOrderAsDelivered_args:
14864 
  """
14865 
  Attributes:
14866 
   - orderId
14867 
   - deliveryTimestamp
14868 
   - receiver
14869 
  """
14870 
 
14871 
  thrift_spec = None
14872 
  def __init__(self, orderId=None, deliveryTimestamp=None, receiver=None,):
14873 
    self.orderId = orderId
14874 
    self.deliveryTimestamp = deliveryTimestamp
14875 
    self.receiver = receiver
14876 
 
14877 
  def read(self, iprot):
14878 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14879 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14880 
      return
14881 
    iprot.readStructBegin()
14882 
    while True:
14883 
      (fname, ftype, fid) = iprot.readFieldBegin()
14884 
      if ftype == TType.STOP:
14885 
        break
14886 
      if fid == 1:
14887 
        if ftype == TType.I64:
14888 
          self.orderId = iprot.readI64();
14889 
        else:
14890 
          iprot.skip(ftype)
14891 
      elif fid == 2:
14892 
        if ftype == TType.I64:
14893 
          self.deliveryTimestamp = iprot.readI64();
14894 
        else:
14895 
          iprot.skip(ftype)
14896 
      elif fid == -1:
14897 
        if ftype == TType.STRING:
14898 
          self.receiver = iprot.readString();
14899 
        else:
14900 
          iprot.skip(ftype)
14901 
      else:
14902 
        iprot.skip(ftype)
14903 
      iprot.readFieldEnd()
14904 
    iprot.readStructEnd()
14905 
 
14906 
  def write(self, oprot):
14907 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14908 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14909 
      return
14910 
    oprot.writeStructBegin('markOrderAsDelivered_args')
14911 
    if self.receiver is not None:
14912 
      oprot.writeFieldBegin('receiver', TType.STRING, -1)
14913 
      oprot.writeString(self.receiver)
14914 
      oprot.writeFieldEnd()
14915 
    if self.orderId is not None:
14916 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
14917 
      oprot.writeI64(self.orderId)
14918 
      oprot.writeFieldEnd()
14919 
    if self.deliveryTimestamp is not None:
14920 
      oprot.writeFieldBegin('deliveryTimestamp', TType.I64, 2)
14921 
      oprot.writeI64(self.deliveryTimestamp)
14922 
      oprot.writeFieldEnd()
14923 
    oprot.writeFieldStop()
14924 
    oprot.writeStructEnd()
14925 
 
14926 
  def validate(self):
14927 
    return
14928 
 
14929 
 
14930 
  def __repr__(self):
14931 
    L = ['%s=%r' % (key, value)
14932 
      for key, value in self.__dict__.iteritems()]
14933 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14934 
 
14935 
  def __eq__(self, other):
14936 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14937 
 
14938 
  def __ne__(self, other):
14939 
    return not (self == other)
14940 
 
14941 
class markOrderAsDelivered_result:
14942 
  """
14943 
  Attributes:
14944 
   - ex
14945 
  """
14946 
 
14947 
  thrift_spec = (
14948 
    None, # 0
14949 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
14950 
  )
14951 
 
14952 
  def __init__(self, ex=None,):
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 == 1:
14965 
        if ftype == TType.STRUCT:
14966 
          self.ex = TransactionServiceException()
14967 
          self.ex.read(iprot)
14968 
        else:
14969 
          iprot.skip(ftype)
14970 
      else:
14971 
        iprot.skip(ftype)
14972 
      iprot.readFieldEnd()
14973 
    iprot.readStructEnd()
14974 
 
14975 
  def write(self, oprot):
14976 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14977 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14978 
      return
14979 
    oprot.writeStructBegin('markOrderAsDelivered_result')
14980 
    if self.ex is not None:
14981 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
14982 
      self.ex.write(oprot)
14983 
      oprot.writeFieldEnd()
14984 
    oprot.writeFieldStop()
14985 
    oprot.writeStructEnd()
14986 
 
14987 
  def validate(self):
14988 
    return
14989 
 
14990 
 
14991 
  def __repr__(self):
14992 
    L = ['%s=%r' % (key, value)
14993 
      for key, value in self.__dict__.iteritems()]
14994 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14995 
 
14996 
  def __eq__(self, other):
14997 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14998 
 
14999 
  def __ne__(self, other):
15000 
    return not (self == other)
15001 
 
5553 rajveer 15002 
class markOrderAsReceivedAtStore_args:
15003 
  """
15004 
  Attributes:
15005 
   - orderId
15006 
   - deliveryTimestamp
15007 
  """
15008 
 
15009 
  thrift_spec = (
15010 
    None, # 0
15011 
    (1, TType.I64, 'orderId', None, None, ), # 1
15012 
    (2, TType.I64, 'deliveryTimestamp', None, None, ), # 2
15013 
  )
15014 
 
15015 
  def __init__(self, orderId=None, deliveryTimestamp=None,):
15016 
    self.orderId = orderId
15017 
    self.deliveryTimestamp = deliveryTimestamp
15018 
 
15019 
  def read(self, iprot):
15020 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15021 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15022 
      return
15023 
    iprot.readStructBegin()
15024 
    while True:
15025 
      (fname, ftype, fid) = iprot.readFieldBegin()
15026 
      if ftype == TType.STOP:
15027 
        break
15028 
      if fid == 1:
15029 
        if ftype == TType.I64:
15030 
          self.orderId = iprot.readI64();
15031 
        else:
15032 
          iprot.skip(ftype)
15033 
      elif fid == 2:
15034 
        if ftype == TType.I64:
15035 
          self.deliveryTimestamp = iprot.readI64();
15036 
        else:
15037 
          iprot.skip(ftype)
15038 
      else:
15039 
        iprot.skip(ftype)
15040 
      iprot.readFieldEnd()
15041 
    iprot.readStructEnd()
15042 
 
15043 
  def write(self, oprot):
15044 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15045 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15046 
      return
15047 
    oprot.writeStructBegin('markOrderAsReceivedAtStore_args')
15048 
    if self.orderId is not None:
15049 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
15050 
      oprot.writeI64(self.orderId)
15051 
      oprot.writeFieldEnd()
15052 
    if self.deliveryTimestamp is not None:
15053 
      oprot.writeFieldBegin('deliveryTimestamp', TType.I64, 2)
15054 
      oprot.writeI64(self.deliveryTimestamp)
15055 
      oprot.writeFieldEnd()
15056 
    oprot.writeFieldStop()
15057 
    oprot.writeStructEnd()
15058 
 
15059 
  def validate(self):
15060 
    return
15061 
 
15062 
 
15063 
  def __repr__(self):
15064 
    L = ['%s=%r' % (key, value)
15065 
      for key, value in self.__dict__.iteritems()]
15066 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15067 
 
15068 
  def __eq__(self, other):
15069 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15070 
 
15071 
  def __ne__(self, other):
15072 
    return not (self == other)
15073 
 
15074 
class markOrderAsReceivedAtStore_result:
15075 
  """
15076 
  Attributes:
15077 
   - ex
15078 
  """
15079 
 
15080 
  thrift_spec = (
15081 
    None, # 0
15082 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
15083 
  )
15084 
 
15085 
  def __init__(self, ex=None,):
15086 
    self.ex = ex
15087 
 
15088 
  def read(self, iprot):
15089 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15090 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15091 
      return
15092 
    iprot.readStructBegin()
15093 
    while True:
15094 
      (fname, ftype, fid) = iprot.readFieldBegin()
15095 
      if ftype == TType.STOP:
15096 
        break
15097 
      if fid == 1:
15098 
        if ftype == TType.STRUCT:
15099 
          self.ex = TransactionServiceException()
15100 
          self.ex.read(iprot)
15101 
        else:
15102 
          iprot.skip(ftype)
15103 
      else:
15104 
        iprot.skip(ftype)
15105 
      iprot.readFieldEnd()
15106 
    iprot.readStructEnd()
15107 
 
15108 
  def write(self, oprot):
15109 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15110 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15111 
      return
15112 
    oprot.writeStructBegin('markOrderAsReceivedAtStore_result')
15113 
    if self.ex is not None:
15114 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
15115 
      self.ex.write(oprot)
15116 
      oprot.writeFieldEnd()
15117 
    oprot.writeFieldStop()
15118 
    oprot.writeStructEnd()
15119 
 
15120 
  def validate(self):
15121 
    return
15122 
 
15123 
 
15124 
  def __repr__(self):
15125 
    L = ['%s=%r' % (key, value)
15126 
      for key, value in self.__dict__.iteritems()]
15127 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15128 
 
15129 
  def __eq__(self, other):
15130 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15131 
 
15132 
  def __ne__(self, other):
15133 
    return not (self == other)
15134 
 
4454 rajveer 15135 
class markOrderDoaRequestReceived_args:
15136 
  """
15137 
  Attributes:
15138 
   - orderId
15139 
  """
15140 
 
15141 
  thrift_spec = (
15142 
    None, # 0
15143 
    (1, TType.I64, 'orderId', None, None, ), # 1
15144 
  )
15145 
 
15146 
  def __init__(self, orderId=None,):
15147 
    self.orderId = orderId
15148 
 
15149 
  def read(self, iprot):
15150 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15151 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15152 
      return
15153 
    iprot.readStructBegin()
15154 
    while True:
15155 
      (fname, ftype, fid) = iprot.readFieldBegin()
15156 
      if ftype == TType.STOP:
15157 
        break
15158 
      if fid == 1:
15159 
        if ftype == TType.I64:
15160 
          self.orderId = iprot.readI64();
15161 
        else:
15162 
          iprot.skip(ftype)
15163 
      else:
15164 
        iprot.skip(ftype)
15165 
      iprot.readFieldEnd()
15166 
    iprot.readStructEnd()
15167 
 
15168 
  def write(self, oprot):
15169 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15170 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15171 
      return
15172 
    oprot.writeStructBegin('markOrderDoaRequestReceived_args')
15173 
    if self.orderId is not None:
15174 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
15175 
      oprot.writeI64(self.orderId)
15176 
      oprot.writeFieldEnd()
15177 
    oprot.writeFieldStop()
15178 
    oprot.writeStructEnd()
15179 
 
15180 
  def validate(self):
15181 
    return
15182 
 
15183 
 
15184 
  def __repr__(self):
15185 
    L = ['%s=%r' % (key, value)
15186 
      for key, value in self.__dict__.iteritems()]
15187 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15188 
 
15189 
  def __eq__(self, other):
15190 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15191 
 
15192 
  def __ne__(self, other):
15193 
    return not (self == other)
15194 
 
15195 
class markOrderDoaRequestReceived_result:
15196 
  """
15197 
  Attributes:
15198 
   - success
15199 
   - ex
15200 
  """
15201 
 
15202 
  thrift_spec = (
15203 
    (0, TType.BOOL, 'success', None, None, ), # 0
15204 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
15205 
  )
15206 
 
15207 
  def __init__(self, success=None, ex=None,):
15208 
    self.success = success
15209 
    self.ex = ex
15210 
 
15211 
  def read(self, iprot):
15212 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15213 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15214 
      return
15215 
    iprot.readStructBegin()
15216 
    while True:
15217 
      (fname, ftype, fid) = iprot.readFieldBegin()
15218 
      if ftype == TType.STOP:
15219 
        break
15220 
      if fid == 0:
15221 
        if ftype == TType.BOOL:
15222 
          self.success = iprot.readBool();
15223 
        else:
15224 
          iprot.skip(ftype)
15225 
      elif fid == 1:
15226 
        if ftype == TType.STRUCT:
15227 
          self.ex = TransactionServiceException()
15228 
          self.ex.read(iprot)
15229 
        else:
15230 
          iprot.skip(ftype)
15231 
      else:
15232 
        iprot.skip(ftype)
15233 
      iprot.readFieldEnd()
15234 
    iprot.readStructEnd()
15235 
 
15236 
  def write(self, oprot):
15237 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15238 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15239 
      return
15240 
    oprot.writeStructBegin('markOrderDoaRequestReceived_result')
15241 
    if self.success is not None:
15242 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
15243 
      oprot.writeBool(self.success)
15244 
      oprot.writeFieldEnd()
15245 
    if self.ex is not None:
15246 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
15247 
      self.ex.write(oprot)
15248 
      oprot.writeFieldEnd()
15249 
    oprot.writeFieldStop()
15250 
    oprot.writeStructEnd()
15251 
 
15252 
  def validate(self):
15253 
    return
15254 
 
15255 
 
15256 
  def __repr__(self):
15257 
    L = ['%s=%r' % (key, value)
15258 
      for key, value in self.__dict__.iteritems()]
15259 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15260 
 
15261 
  def __eq__(self, other):
15262 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15263 
 
15264 
  def __ne__(self, other):
15265 
    return not (self == other)
15266 
 
15267 
class markOrderDoaRequestAuthorized_args:
15268 
  """
15269 
  Attributes:
15270 
   - orderId
15271 
   - isAuthorized
15272 
  """
15273 
 
15274 
  thrift_spec = (
15275 
    None, # 0
15276 
    (1, TType.I64, 'orderId', None, None, ), # 1
15277 
    (2, TType.BOOL, 'isAuthorized', None, None, ), # 2
15278 
  )
15279 
 
15280 
  def __init__(self, orderId=None, isAuthorized=None,):
15281 
    self.orderId = orderId
15282 
    self.isAuthorized = isAuthorized
15283 
 
15284 
  def read(self, iprot):
15285 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15286 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15287 
      return
15288 
    iprot.readStructBegin()
15289 
    while True:
15290 
      (fname, ftype, fid) = iprot.readFieldBegin()
15291 
      if ftype == TType.STOP:
15292 
        break
15293 
      if fid == 1:
15294 
        if ftype == TType.I64:
15295 
          self.orderId = iprot.readI64();
15296 
        else:
15297 
          iprot.skip(ftype)
15298 
      elif fid == 2:
15299 
        if ftype == TType.BOOL:
15300 
          self.isAuthorized = iprot.readBool();
15301 
        else:
15302 
          iprot.skip(ftype)
15303 
      else:
15304 
        iprot.skip(ftype)
15305 
      iprot.readFieldEnd()
15306 
    iprot.readStructEnd()
15307 
 
15308 
  def write(self, oprot):
15309 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15310 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15311 
      return
15312 
    oprot.writeStructBegin('markOrderDoaRequestAuthorized_args')
15313 
    if self.orderId is not None:
15314 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
15315 
      oprot.writeI64(self.orderId)
15316 
      oprot.writeFieldEnd()
15317 
    if self.isAuthorized is not None:
15318 
      oprot.writeFieldBegin('isAuthorized', TType.BOOL, 2)
15319 
      oprot.writeBool(self.isAuthorized)
15320 
      oprot.writeFieldEnd()
15321 
    oprot.writeFieldStop()
15322 
    oprot.writeStructEnd()
15323 
 
15324 
  def validate(self):
15325 
    return
15326 
 
15327 
 
15328 
  def __repr__(self):
15329 
    L = ['%s=%r' % (key, value)
15330 
      for key, value in self.__dict__.iteritems()]
15331 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15332 
 
15333 
  def __eq__(self, other):
15334 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15335 
 
15336 
  def __ne__(self, other):
15337 
    return not (self == other)
15338 
 
15339 
class markOrderDoaRequestAuthorized_result:
15340 
  """
15341 
  Attributes:
15342 
   - success
15343 
   - ex
15344 
  """
15345 
 
15346 
  thrift_spec = (
15347 
    (0, TType.BOOL, 'success', None, None, ), # 0
15348 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
15349 
  )
15350 
 
15351 
  def __init__(self, success=None, ex=None,):
15352 
    self.success = success
15353 
    self.ex = ex
15354 
 
15355 
  def read(self, iprot):
15356 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15357 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15358 
      return
15359 
    iprot.readStructBegin()
15360 
    while True:
15361 
      (fname, ftype, fid) = iprot.readFieldBegin()
15362 
      if ftype == TType.STOP:
15363 
        break
15364 
      if fid == 0:
15365 
        if ftype == TType.BOOL:
15366 
          self.success = iprot.readBool();
15367 
        else:
15368 
          iprot.skip(ftype)
15369 
      elif fid == 1:
15370 
        if ftype == TType.STRUCT:
15371 
          self.ex = TransactionServiceException()
15372 
          self.ex.read(iprot)
15373 
        else:
15374 
          iprot.skip(ftype)
15375 
      else:
15376 
        iprot.skip(ftype)
15377 
      iprot.readFieldEnd()
15378 
    iprot.readStructEnd()
15379 
 
15380 
  def write(self, oprot):
15381 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15382 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15383 
      return
15384 
    oprot.writeStructBegin('markOrderDoaRequestAuthorized_result')
15385 
    if self.success is not None:
15386 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
15387 
      oprot.writeBool(self.success)
15388 
      oprot.writeFieldEnd()
15389 
    if self.ex is not None:
15390 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
15391 
      self.ex.write(oprot)
15392 
      oprot.writeFieldEnd()
15393 
    oprot.writeFieldStop()
15394 
    oprot.writeStructEnd()
15395 
 
15396 
  def validate(self):
15397 
    return
15398 
 
15399 
 
15400 
  def __repr__(self):
15401 
    L = ['%s=%r' % (key, value)
15402 
      for key, value in self.__dict__.iteritems()]
15403 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15404 
 
15405 
  def __eq__(self, other):
15406 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15407 
 
15408 
  def __ne__(self, other):
15409 
    return not (self == other)
15410 
 
4488 rajveer 15411 
class markOrderReturnRequestReceived_args:
15412 
  """
15413 
  Attributes:
15414 
   - orderId
15415 
  """
15416 
 
15417 
  thrift_spec = (
15418 
    None, # 0
15419 
    (1, TType.I64, 'orderId', None, None, ), # 1
15420 
  )
15421 
 
15422 
  def __init__(self, orderId=None,):
15423 
    self.orderId = orderId
15424 
 
15425 
  def read(self, iprot):
15426 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15427 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15428 
      return
15429 
    iprot.readStructBegin()
15430 
    while True:
15431 
      (fname, ftype, fid) = iprot.readFieldBegin()
15432 
      if ftype == TType.STOP:
15433 
        break
15434 
      if fid == 1:
15435 
        if ftype == TType.I64:
15436 
          self.orderId = iprot.readI64();
15437 
        else:
15438 
          iprot.skip(ftype)
15439 
      else:
15440 
        iprot.skip(ftype)
15441 
      iprot.readFieldEnd()
15442 
    iprot.readStructEnd()
15443 
 
15444 
  def write(self, oprot):
15445 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15446 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15447 
      return
15448 
    oprot.writeStructBegin('markOrderReturnRequestReceived_args')
15449 
    if self.orderId is not None:
15450 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
15451 
      oprot.writeI64(self.orderId)
15452 
      oprot.writeFieldEnd()
15453 
    oprot.writeFieldStop()
15454 
    oprot.writeStructEnd()
15455 
 
15456 
  def validate(self):
15457 
    return
15458 
 
15459 
 
15460 
  def __repr__(self):
15461 
    L = ['%s=%r' % (key, value)
15462 
      for key, value in self.__dict__.iteritems()]
15463 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15464 
 
15465 
  def __eq__(self, other):
15466 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15467 
 
15468 
  def __ne__(self, other):
15469 
    return not (self == other)
15470 
 
15471 
class markOrderReturnRequestReceived_result:
15472 
  """
15473 
  Attributes:
15474 
   - success
15475 
   - ex
15476 
  """
15477 
 
15478 
  thrift_spec = (
15479 
    (0, TType.BOOL, 'success', None, None, ), # 0
15480 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
15481 
  )
15482 
 
15483 
  def __init__(self, success=None, ex=None,):
15484 
    self.success = success
15485 
    self.ex = ex
15486 
 
15487 
  def read(self, iprot):
15488 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15489 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15490 
      return
15491 
    iprot.readStructBegin()
15492 
    while True:
15493 
      (fname, ftype, fid) = iprot.readFieldBegin()
15494 
      if ftype == TType.STOP:
15495 
        break
15496 
      if fid == 0:
15497 
        if ftype == TType.BOOL:
15498 
          self.success = iprot.readBool();
15499 
        else:
15500 
          iprot.skip(ftype)
15501 
      elif fid == 1:
15502 
        if ftype == TType.STRUCT:
15503 
          self.ex = TransactionServiceException()
15504 
          self.ex.read(iprot)
15505 
        else:
15506 
          iprot.skip(ftype)
15507 
      else:
15508 
        iprot.skip(ftype)
15509 
      iprot.readFieldEnd()
15510 
    iprot.readStructEnd()
15511 
 
15512 
  def write(self, oprot):
15513 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15514 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15515 
      return
15516 
    oprot.writeStructBegin('markOrderReturnRequestReceived_result')
15517 
    if self.success is not None:
15518 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
15519 
      oprot.writeBool(self.success)
15520 
      oprot.writeFieldEnd()
15521 
    if self.ex is not None:
15522 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
15523 
      self.ex.write(oprot)
15524 
      oprot.writeFieldEnd()
15525 
    oprot.writeFieldStop()
15526 
    oprot.writeStructEnd()
15527 
 
15528 
  def validate(self):
15529 
    return
15530 
 
15531 
 
15532 
  def __repr__(self):
15533 
    L = ['%s=%r' % (key, value)
15534 
      for key, value in self.__dict__.iteritems()]
15535 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15536 
 
15537 
  def __eq__(self, other):
15538 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15539 
 
15540 
  def __ne__(self, other):
15541 
    return not (self == other)
15542 
 
15543 
class markOrderReturnRequestAuthorized_args:
15544 
  """
15545 
  Attributes:
15546 
   - orderId
15547 
   - isAuthorized
15548 
  """
15549 
 
15550 
  thrift_spec = (
15551 
    None, # 0
15552 
    (1, TType.I64, 'orderId', None, None, ), # 1
15553 
    (2, TType.BOOL, 'isAuthorized', None, None, ), # 2
15554 
  )
15555 
 
15556 
  def __init__(self, orderId=None, isAuthorized=None,):
15557 
    self.orderId = orderId
15558 
    self.isAuthorized = isAuthorized
15559 
 
15560 
  def read(self, iprot):
15561 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15562 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15563 
      return
15564 
    iprot.readStructBegin()
15565 
    while True:
15566 
      (fname, ftype, fid) = iprot.readFieldBegin()
15567 
      if ftype == TType.STOP:
15568 
        break
15569 
      if fid == 1:
15570 
        if ftype == TType.I64:
15571 
          self.orderId = iprot.readI64();
15572 
        else:
15573 
          iprot.skip(ftype)
15574 
      elif fid == 2:
15575 
        if ftype == TType.BOOL:
15576 
          self.isAuthorized = iprot.readBool();
15577 
        else:
15578 
          iprot.skip(ftype)
15579 
      else:
15580 
        iprot.skip(ftype)
15581 
      iprot.readFieldEnd()
15582 
    iprot.readStructEnd()
15583 
 
15584 
  def write(self, oprot):
15585 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15586 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15587 
      return
15588 
    oprot.writeStructBegin('markOrderReturnRequestAuthorized_args')
15589 
    if self.orderId is not None:
15590 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
15591 
      oprot.writeI64(self.orderId)
15592 
      oprot.writeFieldEnd()
15593 
    if self.isAuthorized is not None:
15594 
      oprot.writeFieldBegin('isAuthorized', TType.BOOL, 2)
15595 
      oprot.writeBool(self.isAuthorized)
15596 
      oprot.writeFieldEnd()
15597 
    oprot.writeFieldStop()
15598 
    oprot.writeStructEnd()
15599 
 
15600 
  def validate(self):
15601 
    return
15602 
 
15603 
 
15604 
  def __repr__(self):
15605 
    L = ['%s=%r' % (key, value)
15606 
      for key, value in self.__dict__.iteritems()]
15607 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15608 
 
15609 
  def __eq__(self, other):
15610 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15611 
 
15612 
  def __ne__(self, other):
15613 
    return not (self == other)
15614 
 
15615 
class markOrderReturnRequestAuthorized_result:
15616 
  """
15617 
  Attributes:
15618 
   - success
15619 
   - ex
15620 
  """
15621 
 
15622 
  thrift_spec = (
15623 
    (0, TType.BOOL, 'success', None, None, ), # 0
15624 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
15625 
  )
15626 
 
15627 
  def __init__(self, success=None, ex=None,):
15628 
    self.success = success
15629 
    self.ex = ex
15630 
 
15631 
  def read(self, iprot):
15632 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15633 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15634 
      return
15635 
    iprot.readStructBegin()
15636 
    while True:
15637 
      (fname, ftype, fid) = iprot.readFieldBegin()
15638 
      if ftype == TType.STOP:
15639 
        break
15640 
      if fid == 0:
15641 
        if ftype == TType.BOOL:
15642 
          self.success = iprot.readBool();
15643 
        else:
15644 
          iprot.skip(ftype)
15645 
      elif fid == 1:
15646 
        if ftype == TType.STRUCT:
15647 
          self.ex = TransactionServiceException()
15648 
          self.ex.read(iprot)
15649 
        else:
15650 
          iprot.skip(ftype)
15651 
      else:
15652 
        iprot.skip(ftype)
15653 
      iprot.readFieldEnd()
15654 
    iprot.readStructEnd()
15655 
 
15656 
  def write(self, oprot):
15657 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15658 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15659 
      return
15660 
    oprot.writeStructBegin('markOrderReturnRequestAuthorized_result')
15661 
    if self.success is not None:
15662 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
15663 
      oprot.writeBool(self.success)
15664 
      oprot.writeFieldEnd()
15665 
    if self.ex is not None:
15666 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
15667 
      self.ex.write(oprot)
15668 
      oprot.writeFieldEnd()
15669 
    oprot.writeFieldStop()
15670 
    oprot.writeStructEnd()
15671 
 
15672 
  def validate(self):
15673 
    return
15674 
 
15675 
 
15676 
  def __repr__(self):
15677 
    L = ['%s=%r' % (key, value)
15678 
      for key, value in self.__dict__.iteritems()]
15679 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15680 
 
15681 
  def __eq__(self, other):
15682 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15683 
 
15684 
  def __ne__(self, other):
15685 
    return not (self == other)
15686 
 
2536 chandransh 15687 
class requestPickupNumber_args:
15688 
  """
15689 
  Attributes:
15690 
   - orderId
4579 rajveer 15691 
   - providerId
2536 chandransh 15692 
  """
15693 
 
15694 
  thrift_spec = (
15695 
    None, # 0
15696 
    (1, TType.I64, 'orderId', None, None, ), # 1
4579 rajveer 15697 
    (2, TType.I64, 'providerId', None, None, ), # 2
2536 chandransh 15698 
  )
15699 
 
4579 rajveer 15700 
  def __init__(self, orderId=None, providerId=None,):
2536 chandransh 15701 
    self.orderId = orderId
4579 rajveer 15702 
    self.providerId = providerId
2536 chandransh 15703 
 
15704 
  def read(self, iprot):
15705 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15706 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15707 
      return
15708 
    iprot.readStructBegin()
15709 
    while True:
15710 
      (fname, ftype, fid) = iprot.readFieldBegin()
15711 
      if ftype == TType.STOP:
15712 
        break
15713 
      if fid == 1:
15714 
        if ftype == TType.I64:
15715 
          self.orderId = iprot.readI64();
15716 
        else:
15717 
          iprot.skip(ftype)
4579 rajveer 15718 
      elif fid == 2:
15719 
        if ftype == TType.I64:
15720 
          self.providerId = iprot.readI64();
15721 
        else:
15722 
          iprot.skip(ftype)
2536 chandransh 15723 
      else:
15724 
        iprot.skip(ftype)
15725 
      iprot.readFieldEnd()
15726 
    iprot.readStructEnd()
15727 
 
15728 
  def write(self, oprot):
15729 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15730 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15731 
      return
15732 
    oprot.writeStructBegin('requestPickupNumber_args')
3431 rajveer 15733 
    if self.orderId is not None:
2536 chandransh 15734 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
15735 
      oprot.writeI64(self.orderId)
15736 
      oprot.writeFieldEnd()
4579 rajveer 15737 
    if self.providerId is not None:
15738 
      oprot.writeFieldBegin('providerId', TType.I64, 2)
15739 
      oprot.writeI64(self.providerId)
15740 
      oprot.writeFieldEnd()
2536 chandransh 15741 
    oprot.writeFieldStop()
15742 
    oprot.writeStructEnd()
15743 
 
3431 rajveer 15744 
  def validate(self):
15745 
    return
15746 
 
15747 
 
2536 chandransh 15748 
  def __repr__(self):
15749 
    L = ['%s=%r' % (key, value)
15750 
      for key, value in self.__dict__.iteritems()]
15751 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15752 
 
15753 
  def __eq__(self, other):
15754 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15755 
 
15756 
  def __ne__(self, other):
15757 
    return not (self == other)
15758 
 
15759 
class requestPickupNumber_result:
15760 
  """
15761 
  Attributes:
15762 
   - success
15763 
   - ex
15764 
  """
15765 
 
15766 
  thrift_spec = (
15767 
    (0, TType.BOOL, 'success', None, None, ), # 0
15768 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
15769 
  )
15770 
 
15771 
  def __init__(self, success=None, ex=None,):
15772 
    self.success = success
15773 
    self.ex = ex
15774 
 
15775 
  def read(self, iprot):
15776 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15777 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15778 
      return
15779 
    iprot.readStructBegin()
15780 
    while True:
15781 
      (fname, ftype, fid) = iprot.readFieldBegin()
15782 
      if ftype == TType.STOP:
15783 
        break
15784 
      if fid == 0:
15785 
        if ftype == TType.BOOL:
15786 
          self.success = iprot.readBool();
15787 
        else:
15788 
          iprot.skip(ftype)
15789 
      elif fid == 1:
15790 
        if ftype == TType.STRUCT:
15791 
          self.ex = TransactionServiceException()
15792 
          self.ex.read(iprot)
15793 
        else:
15794 
          iprot.skip(ftype)
15795 
      else:
15796 
        iprot.skip(ftype)
15797 
      iprot.readFieldEnd()
15798 
    iprot.readStructEnd()
15799 
 
15800 
  def write(self, oprot):
15801 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15802 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15803 
      return
15804 
    oprot.writeStructBegin('requestPickupNumber_result')
3431 rajveer 15805 
    if self.success is not None:
2536 chandransh 15806 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
15807 
      oprot.writeBool(self.success)
15808 
      oprot.writeFieldEnd()
3431 rajveer 15809 
    if self.ex is not None:
2536 chandransh 15810 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
15811 
      self.ex.write(oprot)
15812 
      oprot.writeFieldEnd()
15813 
    oprot.writeFieldStop()
15814 
    oprot.writeStructEnd()
15815 
 
3431 rajveer 15816 
  def validate(self):
15817 
    return
15818 
 
15819 
 
2536 chandransh 15820 
  def __repr__(self):
15821 
    L = ['%s=%r' % (key, value)
15822 
      for key, value in self.__dict__.iteritems()]
15823 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15824 
 
15825 
  def __eq__(self, other):
15826 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15827 
 
15828 
  def __ne__(self, other):
15829 
    return not (self == other)
15830 
 
15831 
class authorizePickup_args:
15832 
  """
15833 
  Attributes:
15834 
   - orderId
15835 
   - pickupNumber
4602 rajveer 15836 
   - providerId
2536 chandransh 15837 
  """
15838 
 
15839 
  thrift_spec = (
15840 
    None, # 0
15841 
    (1, TType.I64, 'orderId', None, None, ), # 1
15842 
    (2, TType.STRING, 'pickupNumber', None, None, ), # 2
4602 rajveer 15843 
    (3, TType.I64, 'providerId', None, None, ), # 3
2536 chandransh 15844 
  )
15845 
 
4602 rajveer 15846 
  def __init__(self, orderId=None, pickupNumber=None, providerId=None,):
2536 chandransh 15847 
    self.orderId = orderId
15848 
    self.pickupNumber = pickupNumber
4602 rajveer 15849 
    self.providerId = providerId
2536 chandransh 15850 
 
15851 
  def read(self, iprot):
15852 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15853 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15854 
      return
15855 
    iprot.readStructBegin()
15856 
    while True:
15857 
      (fname, ftype, fid) = iprot.readFieldBegin()
15858 
      if ftype == TType.STOP:
15859 
        break
15860 
      if fid == 1:
15861 
        if ftype == TType.I64:
15862 
          self.orderId = iprot.readI64();
15863 
        else:
15864 
          iprot.skip(ftype)
15865 
      elif fid == 2:
15866 
        if ftype == TType.STRING:
15867 
          self.pickupNumber = iprot.readString();
15868 
        else:
15869 
          iprot.skip(ftype)
4602 rajveer 15870 
      elif fid == 3:
15871 
        if ftype == TType.I64:
15872 
          self.providerId = iprot.readI64();
15873 
        else:
15874 
          iprot.skip(ftype)
2536 chandransh 15875 
      else:
15876 
        iprot.skip(ftype)
15877 
      iprot.readFieldEnd()
15878 
    iprot.readStructEnd()
15879 
 
15880 
  def write(self, oprot):
15881 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15882 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15883 
      return
15884 
    oprot.writeStructBegin('authorizePickup_args')
3431 rajveer 15885 
    if self.orderId is not None:
2536 chandransh 15886 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
15887 
      oprot.writeI64(self.orderId)
15888 
      oprot.writeFieldEnd()
3431 rajveer 15889 
    if self.pickupNumber is not None:
2536 chandransh 15890 
      oprot.writeFieldBegin('pickupNumber', TType.STRING, 2)
15891 
      oprot.writeString(self.pickupNumber)
15892 
      oprot.writeFieldEnd()
4602 rajveer 15893 
    if self.providerId is not None:
15894 
      oprot.writeFieldBegin('providerId', TType.I64, 3)
15895 
      oprot.writeI64(self.providerId)
15896 
      oprot.writeFieldEnd()
2536 chandransh 15897 
    oprot.writeFieldStop()
15898 
    oprot.writeStructEnd()
15899 
 
3431 rajveer 15900 
  def validate(self):
15901 
    return
15902 
 
15903 
 
2536 chandransh 15904 
  def __repr__(self):
15905 
    L = ['%s=%r' % (key, value)
15906 
      for key, value in self.__dict__.iteritems()]
15907 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15908 
 
15909 
  def __eq__(self, other):
15910 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15911 
 
15912 
  def __ne__(self, other):
15913 
    return not (self == other)
15914 
 
15915 
class authorizePickup_result:
15916 
  """
15917 
  Attributes:
15918 
   - success
15919 
   - ex
15920 
  """
15921 
 
15922 
  thrift_spec = (
15923 
    (0, TType.BOOL, 'success', None, None, ), # 0
15924 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
15925 
  )
15926 
 
15927 
  def __init__(self, success=None, ex=None,):
15928 
    self.success = success
15929 
    self.ex = ex
15930 
 
15931 
  def read(self, iprot):
15932 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15933 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15934 
      return
15935 
    iprot.readStructBegin()
15936 
    while True:
15937 
      (fname, ftype, fid) = iprot.readFieldBegin()
15938 
      if ftype == TType.STOP:
15939 
        break
15940 
      if fid == 0:
15941 
        if ftype == TType.BOOL:
15942 
          self.success = iprot.readBool();
15943 
        else:
15944 
          iprot.skip(ftype)
15945 
      elif fid == 1:
15946 
        if ftype == TType.STRUCT:
15947 
          self.ex = TransactionServiceException()
15948 
          self.ex.read(iprot)
15949 
        else:
15950 
          iprot.skip(ftype)
15951 
      else:
15952 
        iprot.skip(ftype)
15953 
      iprot.readFieldEnd()
15954 
    iprot.readStructEnd()
15955 
 
15956 
  def write(self, oprot):
15957 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15958 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15959 
      return
15960 
    oprot.writeStructBegin('authorizePickup_result')
3431 rajveer 15961 
    if self.success is not None:
2536 chandransh 15962 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
15963 
      oprot.writeBool(self.success)
15964 
      oprot.writeFieldEnd()
3431 rajveer 15965 
    if self.ex is not None:
2536 chandransh 15966 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
15967 
      self.ex.write(oprot)
15968 
      oprot.writeFieldEnd()
15969 
    oprot.writeFieldStop()
15970 
    oprot.writeStructEnd()
15971 
 
3431 rajveer 15972 
  def validate(self):
15973 
    return
15974 
 
15975 
 
2536 chandransh 15976 
  def __repr__(self):
15977 
    L = ['%s=%r' % (key, value)
15978 
      for key, value in self.__dict__.iteritems()]
15979 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15980 
 
15981 
  def __eq__(self, other):
15982 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15983 
 
15984 
  def __ne__(self, other):
15985 
    return not (self == other)
15986 
 
2764 chandransh 15987 
class markDoasAsPickedUp_args:
15988 
  """
15989 
  Attributes:
15990 
   - providerId
15991 
   - pickupDetails
15992 
  """
15993 
 
15994 
  thrift_spec = (
15995 
    None, # 0
15996 
    (1, TType.I64, 'providerId', None, None, ), # 1
15997 
    (2, TType.MAP, 'pickupDetails', (TType.STRING,None,TType.STRING,None), None, ), # 2
15998 
  )
15999 
 
16000 
  def __init__(self, providerId=None, pickupDetails=None,):
16001 
    self.providerId = providerId
16002 
    self.pickupDetails = pickupDetails
16003 
 
16004 
  def read(self, iprot):
16005 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16006 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16007 
      return
16008 
    iprot.readStructBegin()
16009 
    while True:
16010 
      (fname, ftype, fid) = iprot.readFieldBegin()
16011 
      if ftype == TType.STOP:
16012 
        break
16013 
      if fid == 1:
16014 
        if ftype == TType.I64:
16015 
          self.providerId = iprot.readI64();
16016 
        else:
16017 
          iprot.skip(ftype)
16018 
      elif fid == 2:
16019 
        if ftype == TType.MAP:
16020 
          self.pickupDetails = {}
5676 rajveer 16021 
          (_ktype358, _vtype359, _size357 ) = iprot.readMapBegin()
16022 
          for _i361 in xrange(_size357):
16023 
            _key362 = iprot.readString();
16024 
            _val363 = iprot.readString();
16025 
            self.pickupDetails[_key362] = _val363
2764 chandransh 16026 
          iprot.readMapEnd()
16027 
        else:
16028 
          iprot.skip(ftype)
16029 
      else:
16030 
        iprot.skip(ftype)
16031 
      iprot.readFieldEnd()
16032 
    iprot.readStructEnd()
16033 
 
16034 
  def write(self, oprot):
16035 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16036 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16037 
      return
16038 
    oprot.writeStructBegin('markDoasAsPickedUp_args')
3431 rajveer 16039 
    if self.providerId is not None:
2764 chandransh 16040 
      oprot.writeFieldBegin('providerId', TType.I64, 1)
16041 
      oprot.writeI64(self.providerId)
16042 
      oprot.writeFieldEnd()
3431 rajveer 16043 
    if self.pickupDetails is not None:
2764 chandransh 16044 
      oprot.writeFieldBegin('pickupDetails', TType.MAP, 2)
16045 
      oprot.writeMapBegin(TType.STRING, TType.STRING, len(self.pickupDetails))
5676 rajveer 16046 
      for kiter364,viter365 in self.pickupDetails.items():
16047 
        oprot.writeString(kiter364)
16048 
        oprot.writeString(viter365)
2764 chandransh 16049 
      oprot.writeMapEnd()
16050 
      oprot.writeFieldEnd()
16051 
    oprot.writeFieldStop()
16052 
    oprot.writeStructEnd()
16053 
 
3431 rajveer 16054 
  def validate(self):
16055 
    return
16056 
 
16057 
 
2764 chandransh 16058 
  def __repr__(self):
16059 
    L = ['%s=%r' % (key, value)
16060 
      for key, value in self.__dict__.iteritems()]
16061 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16062 
 
16063 
  def __eq__(self, other):
16064 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16065 
 
16066 
  def __ne__(self, other):
16067 
    return not (self == other)
16068 
 
16069 
class markDoasAsPickedUp_result:
4910 phani.kuma 16070 
 
16071 
  thrift_spec = (
16072 
  )
16073 
 
16074 
  def read(self, iprot):
16075 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16076 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16077 
      return
16078 
    iprot.readStructBegin()
16079 
    while True:
16080 
      (fname, ftype, fid) = iprot.readFieldBegin()
16081 
      if ftype == TType.STOP:
16082 
        break
16083 
      else:
16084 
        iprot.skip(ftype)
16085 
      iprot.readFieldEnd()
16086 
    iprot.readStructEnd()
16087 
 
16088 
  def write(self, oprot):
16089 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16090 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16091 
      return
16092 
    oprot.writeStructBegin('markDoasAsPickedUp_result')
16093 
    oprot.writeFieldStop()
16094 
    oprot.writeStructEnd()
16095 
 
16096 
  def validate(self):
16097 
    return
16098 
 
16099 
 
16100 
  def __repr__(self):
16101 
    L = ['%s=%r' % (key, value)
16102 
      for key, value in self.__dict__.iteritems()]
16103 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16104 
 
16105 
  def __eq__(self, other):
16106 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16107 
 
16108 
  def __ne__(self, other):
16109 
    return not (self == other)
16110 
 
16111 
class getDoasNotPickedUp_args:
2764 chandransh 16112 
  """
16113 
  Attributes:
4910 phani.kuma 16114 
   - providerId
16115 
  """
16116 
 
16117 
  thrift_spec = (
16118 
    None, # 0
16119 
    (1, TType.I64, 'providerId', None, None, ), # 1
16120 
  )
16121 
 
16122 
  def __init__(self, providerId=None,):
16123 
    self.providerId = providerId
16124 
 
16125 
  def read(self, iprot):
16126 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16127 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16128 
      return
16129 
    iprot.readStructBegin()
16130 
    while True:
16131 
      (fname, ftype, fid) = iprot.readFieldBegin()
16132 
      if ftype == TType.STOP:
16133 
        break
16134 
      if fid == 1:
16135 
        if ftype == TType.I64:
16136 
          self.providerId = iprot.readI64();
16137 
        else:
16138 
          iprot.skip(ftype)
16139 
      else:
16140 
        iprot.skip(ftype)
16141 
      iprot.readFieldEnd()
16142 
    iprot.readStructEnd()
16143 
 
16144 
  def write(self, oprot):
16145 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16146 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16147 
      return
16148 
    oprot.writeStructBegin('getDoasNotPickedUp_args')
16149 
    if self.providerId is not None:
16150 
      oprot.writeFieldBegin('providerId', TType.I64, 1)
16151 
      oprot.writeI64(self.providerId)
16152 
      oprot.writeFieldEnd()
16153 
    oprot.writeFieldStop()
16154 
    oprot.writeStructEnd()
16155 
 
16156 
  def validate(self):
16157 
    return
16158 
 
16159 
 
16160 
  def __repr__(self):
16161 
    L = ['%s=%r' % (key, value)
16162 
      for key, value in self.__dict__.iteritems()]
16163 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16164 
 
16165 
  def __eq__(self, other):
16166 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16167 
 
16168 
  def __ne__(self, other):
16169 
    return not (self == other)
16170 
 
16171 
class getDoasNotPickedUp_result:
16172 
  """
16173 
  Attributes:
2764 chandransh 16174 
   - success
16175 
  """
16176 
 
16177 
  thrift_spec = (
16178 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
16179 
  )
16180 
 
16181 
  def __init__(self, success=None,):
16182 
    self.success = success
16183 
 
16184 
  def read(self, iprot):
16185 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16186 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16187 
      return
16188 
    iprot.readStructBegin()
16189 
    while True:
16190 
      (fname, ftype, fid) = iprot.readFieldBegin()
16191 
      if ftype == TType.STOP:
16192 
        break
16193 
      if fid == 0:
16194 
        if ftype == TType.LIST:
16195 
          self.success = []
5676 rajveer 16196 
          (_etype369, _size366) = iprot.readListBegin()
16197 
          for _i370 in xrange(_size366):
16198 
            _elem371 = Order()
16199 
            _elem371.read(iprot)
16200 
            self.success.append(_elem371)
2764 chandransh 16201 
          iprot.readListEnd()
16202 
        else:
16203 
          iprot.skip(ftype)
16204 
      else:
16205 
        iprot.skip(ftype)
16206 
      iprot.readFieldEnd()
16207 
    iprot.readStructEnd()
16208 
 
16209 
  def write(self, oprot):
16210 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16211 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16212 
      return
4910 phani.kuma 16213 
    oprot.writeStructBegin('getDoasNotPickedUp_result')
3431 rajveer 16214 
    if self.success is not None:
2764 chandransh 16215 
      oprot.writeFieldBegin('success', TType.LIST, 0)
16216 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
5676 rajveer 16217 
      for iter372 in self.success:
16218 
        iter372.write(oprot)
2764 chandransh 16219 
      oprot.writeListEnd()
16220 
      oprot.writeFieldEnd()
16221 
    oprot.writeFieldStop()
16222 
    oprot.writeStructEnd()
16223 
 
3431 rajveer 16224 
  def validate(self):
16225 
    return
16226 
 
16227 
 
2764 chandransh 16228 
  def __repr__(self):
16229 
    L = ['%s=%r' % (key, value)
16230 
      for key, value in self.__dict__.iteritems()]
16231 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16232 
 
16233 
  def __eq__(self, other):
16234 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16235 
 
16236 
  def __ne__(self, other):
16237 
    return not (self == other)
16238 
 
4741 phani.kuma 16239 
class markReturnOrdersAsPickedUp_args:
16240 
  """
16241 
  Attributes:
16242 
   - providerId
16243 
   - pickupDetails
16244 
  """
16245 
 
16246 
  thrift_spec = (
16247 
    None, # 0
16248 
    (1, TType.I64, 'providerId', None, None, ), # 1
16249 
    (2, TType.MAP, 'pickupDetails', (TType.STRING,None,TType.STRING,None), None, ), # 2
16250 
  )
16251 
 
16252 
  def __init__(self, providerId=None, pickupDetails=None,):
16253 
    self.providerId = providerId
16254 
    self.pickupDetails = pickupDetails
16255 
 
16256 
  def read(self, iprot):
16257 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16258 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16259 
      return
16260 
    iprot.readStructBegin()
16261 
    while True:
16262 
      (fname, ftype, fid) = iprot.readFieldBegin()
16263 
      if ftype == TType.STOP:
16264 
        break
16265 
      if fid == 1:
16266 
        if ftype == TType.I64:
16267 
          self.providerId = iprot.readI64();
16268 
        else:
16269 
          iprot.skip(ftype)
16270 
      elif fid == 2:
16271 
        if ftype == TType.MAP:
16272 
          self.pickupDetails = {}
5676 rajveer 16273 
          (_ktype374, _vtype375, _size373 ) = iprot.readMapBegin()
16274 
          for _i377 in xrange(_size373):
16275 
            _key378 = iprot.readString();
16276 
            _val379 = iprot.readString();
16277 
            self.pickupDetails[_key378] = _val379
4741 phani.kuma 16278 
          iprot.readMapEnd()
16279 
        else:
16280 
          iprot.skip(ftype)
16281 
      else:
16282 
        iprot.skip(ftype)
16283 
      iprot.readFieldEnd()
16284 
    iprot.readStructEnd()
16285 
 
16286 
  def write(self, oprot):
16287 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16288 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16289 
      return
16290 
    oprot.writeStructBegin('markReturnOrdersAsPickedUp_args')
16291 
    if self.providerId is not None:
16292 
      oprot.writeFieldBegin('providerId', TType.I64, 1)
16293 
      oprot.writeI64(self.providerId)
16294 
      oprot.writeFieldEnd()
16295 
    if self.pickupDetails is not None:
16296 
      oprot.writeFieldBegin('pickupDetails', TType.MAP, 2)
16297 
      oprot.writeMapBegin(TType.STRING, TType.STRING, len(self.pickupDetails))
5676 rajveer 16298 
      for kiter380,viter381 in self.pickupDetails.items():
16299 
        oprot.writeString(kiter380)
16300 
        oprot.writeString(viter381)
4741 phani.kuma 16301 
      oprot.writeMapEnd()
16302 
      oprot.writeFieldEnd()
16303 
    oprot.writeFieldStop()
16304 
    oprot.writeStructEnd()
16305 
 
16306 
  def validate(self):
16307 
    return
16308 
 
16309 
 
16310 
  def __repr__(self):
16311 
    L = ['%s=%r' % (key, value)
16312 
      for key, value in self.__dict__.iteritems()]
16313 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16314 
 
16315 
  def __eq__(self, other):
16316 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16317 
 
16318 
  def __ne__(self, other):
16319 
    return not (self == other)
16320 
 
16321 
class markReturnOrdersAsPickedUp_result:
4910 phani.kuma 16322 
 
16323 
  thrift_spec = (
16324 
  )
16325 
 
16326 
  def read(self, iprot):
16327 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16328 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16329 
      return
16330 
    iprot.readStructBegin()
16331 
    while True:
16332 
      (fname, ftype, fid) = iprot.readFieldBegin()
16333 
      if ftype == TType.STOP:
16334 
        break
16335 
      else:
16336 
        iprot.skip(ftype)
16337 
      iprot.readFieldEnd()
16338 
    iprot.readStructEnd()
16339 
 
16340 
  def write(self, oprot):
16341 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16342 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16343 
      return
16344 
    oprot.writeStructBegin('markReturnOrdersAsPickedUp_result')
16345 
    oprot.writeFieldStop()
16346 
    oprot.writeStructEnd()
16347 
 
16348 
  def validate(self):
16349 
    return
16350 
 
16351 
 
16352 
  def __repr__(self):
16353 
    L = ['%s=%r' % (key, value)
16354 
      for key, value in self.__dict__.iteritems()]
16355 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16356 
 
16357 
  def __eq__(self, other):
16358 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16359 
 
16360 
  def __ne__(self, other):
16361 
    return not (self == other)
16362 
 
16363 
class getReturnOrdersNotPickedUp_args:
4741 phani.kuma 16364 
  """
16365 
  Attributes:
4910 phani.kuma 16366 
   - providerId
16367 
  """
16368 
 
16369 
  thrift_spec = (
16370 
    None, # 0
16371 
    (1, TType.I64, 'providerId', None, None, ), # 1
16372 
  )
16373 
 
16374 
  def __init__(self, providerId=None,):
16375 
    self.providerId = providerId
16376 
 
16377 
  def read(self, iprot):
16378 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16379 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16380 
      return
16381 
    iprot.readStructBegin()
16382 
    while True:
16383 
      (fname, ftype, fid) = iprot.readFieldBegin()
16384 
      if ftype == TType.STOP:
16385 
        break
16386 
      if fid == 1:
16387 
        if ftype == TType.I64:
16388 
          self.providerId = iprot.readI64();
16389 
        else:
16390 
          iprot.skip(ftype)
16391 
      else:
16392 
        iprot.skip(ftype)
16393 
      iprot.readFieldEnd()
16394 
    iprot.readStructEnd()
16395 
 
16396 
  def write(self, oprot):
16397 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16398 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16399 
      return
16400 
    oprot.writeStructBegin('getReturnOrdersNotPickedUp_args')
16401 
    if self.providerId is not None:
16402 
      oprot.writeFieldBegin('providerId', TType.I64, 1)
16403 
      oprot.writeI64(self.providerId)
16404 
      oprot.writeFieldEnd()
16405 
    oprot.writeFieldStop()
16406 
    oprot.writeStructEnd()
16407 
 
16408 
  def validate(self):
16409 
    return
16410 
 
16411 
 
16412 
  def __repr__(self):
16413 
    L = ['%s=%r' % (key, value)
16414 
      for key, value in self.__dict__.iteritems()]
16415 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16416 
 
16417 
  def __eq__(self, other):
16418 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16419 
 
16420 
  def __ne__(self, other):
16421 
    return not (self == other)
16422 
 
16423 
class getReturnOrdersNotPickedUp_result:
16424 
  """
16425 
  Attributes:
4741 phani.kuma 16426 
   - success
16427 
  """
16428 
 
16429 
  thrift_spec = (
16430 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
16431 
  )
16432 
 
16433 
  def __init__(self, success=None,):
16434 
    self.success = success
16435 
 
16436 
  def read(self, iprot):
16437 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16438 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16439 
      return
16440 
    iprot.readStructBegin()
16441 
    while True:
16442 
      (fname, ftype, fid) = iprot.readFieldBegin()
16443 
      if ftype == TType.STOP:
16444 
        break
16445 
      if fid == 0:
16446 
        if ftype == TType.LIST:
16447 
          self.success = []
5676 rajveer 16448 
          (_etype385, _size382) = iprot.readListBegin()
16449 
          for _i386 in xrange(_size382):
16450 
            _elem387 = Order()
16451 
            _elem387.read(iprot)
16452 
            self.success.append(_elem387)
4741 phani.kuma 16453 
          iprot.readListEnd()
16454 
        else:
16455 
          iprot.skip(ftype)
16456 
      else:
16457 
        iprot.skip(ftype)
16458 
      iprot.readFieldEnd()
16459 
    iprot.readStructEnd()
16460 
 
16461 
  def write(self, oprot):
16462 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16463 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16464 
      return
4910 phani.kuma 16465 
    oprot.writeStructBegin('getReturnOrdersNotPickedUp_result')
4741 phani.kuma 16466 
    if self.success is not None:
16467 
      oprot.writeFieldBegin('success', TType.LIST, 0)
16468 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
5676 rajveer 16469 
      for iter388 in self.success:
16470 
        iter388.write(oprot)
4741 phani.kuma 16471 
      oprot.writeListEnd()
16472 
      oprot.writeFieldEnd()
16473 
    oprot.writeFieldStop()
16474 
    oprot.writeStructEnd()
16475 
 
16476 
  def validate(self):
16477 
    return
16478 
 
16479 
 
16480 
  def __repr__(self):
16481 
    L = ['%s=%r' % (key, value)
16482 
      for key, value in self.__dict__.iteritems()]
16483 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16484 
 
16485 
  def __eq__(self, other):
16486 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16487 
 
16488 
  def __ne__(self, other):
16489 
    return not (self == other)
16490 
 
2616 chandransh 16491 
class receiveReturn_args:
2591 chandransh 16492 
  """
16493 
  Attributes:
16494 
   - orderId
4479 rajveer 16495 
   - receiveCondition
2591 chandransh 16496 
  """
2536 chandransh 16497 
 
2591 chandransh 16498 
  thrift_spec = (
16499 
    None, # 0
16500 
    (1, TType.I64, 'orderId', None, None, ), # 1
4479 rajveer 16501 
    (2, TType.I64, 'receiveCondition', None, None, ), # 2
2591 chandransh 16502 
  )
16503 
 
4479 rajveer 16504 
  def __init__(self, orderId=None, receiveCondition=None,):
2591 chandransh 16505 
    self.orderId = orderId
4479 rajveer 16506 
    self.receiveCondition = receiveCondition
2591 chandransh 16507 
 
16508 
  def read(self, iprot):
16509 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16510 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16511 
      return
16512 
    iprot.readStructBegin()
16513 
    while True:
16514 
      (fname, ftype, fid) = iprot.readFieldBegin()
16515 
      if ftype == TType.STOP:
16516 
        break
16517 
      if fid == 1:
16518 
        if ftype == TType.I64:
16519 
          self.orderId = iprot.readI64();
16520 
        else:
16521 
          iprot.skip(ftype)
4479 rajveer 16522 
      elif fid == 2:
16523 
        if ftype == TType.I64:
16524 
          self.receiveCondition = iprot.readI64();
16525 
        else:
16526 
          iprot.skip(ftype)
2591 chandransh 16527 
      else:
16528 
        iprot.skip(ftype)
16529 
      iprot.readFieldEnd()
16530 
    iprot.readStructEnd()
16531 
 
16532 
  def write(self, oprot):
16533 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16534 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16535 
      return
2616 chandransh 16536 
    oprot.writeStructBegin('receiveReturn_args')
3431 rajveer 16537 
    if self.orderId is not None:
2591 chandransh 16538 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
16539 
      oprot.writeI64(self.orderId)
16540 
      oprot.writeFieldEnd()
4479 rajveer 16541 
    if self.receiveCondition is not None:
16542 
      oprot.writeFieldBegin('receiveCondition', TType.I64, 2)
16543 
      oprot.writeI64(self.receiveCondition)
16544 
      oprot.writeFieldEnd()
2591 chandransh 16545 
    oprot.writeFieldStop()
16546 
    oprot.writeStructEnd()
16547 
 
3431 rajveer 16548 
  def validate(self):
16549 
    return
16550 
 
16551 
 
2591 chandransh 16552 
  def __repr__(self):
16553 
    L = ['%s=%r' % (key, value)
16554 
      for key, value in self.__dict__.iteritems()]
16555 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16556 
 
16557 
  def __eq__(self, other):
16558 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16559 
 
16560 
  def __ne__(self, other):
16561 
    return not (self == other)
16562 
 
2616 chandransh 16563 
class receiveReturn_result:
2591 chandransh 16564 
  """
16565 
  Attributes:
16566 
   - success
16567 
   - ex
16568 
  """
16569 
 
16570 
  thrift_spec = (
16571 
    (0, TType.BOOL, 'success', None, None, ), # 0
16572 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
16573 
  )
16574 
 
16575 
  def __init__(self, success=None, ex=None,):
16576 
    self.success = success
16577 
    self.ex = ex
16578 
 
16579 
  def read(self, iprot):
16580 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16581 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16582 
      return
16583 
    iprot.readStructBegin()
16584 
    while True:
16585 
      (fname, ftype, fid) = iprot.readFieldBegin()
16586 
      if ftype == TType.STOP:
16587 
        break
16588 
      if fid == 0:
16589 
        if ftype == TType.BOOL:
16590 
          self.success = iprot.readBool();
16591 
        else:
16592 
          iprot.skip(ftype)
16593 
      elif fid == 1:
16594 
        if ftype == TType.STRUCT:
16595 
          self.ex = TransactionServiceException()
16596 
          self.ex.read(iprot)
16597 
        else:
16598 
          iprot.skip(ftype)
16599 
      else:
16600 
        iprot.skip(ftype)
16601 
      iprot.readFieldEnd()
16602 
    iprot.readStructEnd()
16603 
 
16604 
  def write(self, oprot):
16605 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16606 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16607 
      return
2616 chandransh 16608 
    oprot.writeStructBegin('receiveReturn_result')
3431 rajveer 16609 
    if self.success is not None:
2591 chandransh 16610 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
16611 
      oprot.writeBool(self.success)
16612 
      oprot.writeFieldEnd()
3431 rajveer 16613 
    if self.ex is not None:
2591 chandransh 16614 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
16615 
      self.ex.write(oprot)
16616 
      oprot.writeFieldEnd()
16617 
    oprot.writeFieldStop()
16618 
    oprot.writeStructEnd()
16619 
 
3431 rajveer 16620 
  def validate(self):
16621 
    return
16622 
 
16623 
 
2591 chandransh 16624 
  def __repr__(self):
16625 
    L = ['%s=%r' % (key, value)
16626 
      for key, value in self.__dict__.iteritems()]
16627 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16628 
 
16629 
  def __eq__(self, other):
16630 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16631 
 
16632 
  def __ne__(self, other):
16633 
    return not (self == other)
16634 
 
16635 
class validateDoa_args:
16636 
  """
16637 
  Attributes:
16638 
   - orderId
16639 
   - isValid
16640 
  """
16641 
 
16642 
  thrift_spec = (
16643 
    None, # 0
16644 
    (1, TType.I64, 'orderId', None, None, ), # 1
16645 
    (2, TType.BOOL, 'isValid', None, None, ), # 2
16646 
  )
16647 
 
16648 
  def __init__(self, orderId=None, isValid=None,):
16649 
    self.orderId = orderId
16650 
    self.isValid = isValid
16651 
 
16652 
  def read(self, iprot):
16653 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16654 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16655 
      return
16656 
    iprot.readStructBegin()
16657 
    while True:
16658 
      (fname, ftype, fid) = iprot.readFieldBegin()
16659 
      if ftype == TType.STOP:
16660 
        break
16661 
      if fid == 1:
16662 
        if ftype == TType.I64:
16663 
          self.orderId = iprot.readI64();
16664 
        else:
16665 
          iprot.skip(ftype)
16666 
      elif fid == 2:
16667 
        if ftype == TType.BOOL:
16668 
          self.isValid = iprot.readBool();
16669 
        else:
16670 
          iprot.skip(ftype)
16671 
      else:
16672 
        iprot.skip(ftype)
16673 
      iprot.readFieldEnd()
16674 
    iprot.readStructEnd()
16675 
 
16676 
  def write(self, oprot):
16677 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16678 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16679 
      return
16680 
    oprot.writeStructBegin('validateDoa_args')
3431 rajveer 16681 
    if self.orderId is not None:
2591 chandransh 16682 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
16683 
      oprot.writeI64(self.orderId)
16684 
      oprot.writeFieldEnd()
3431 rajveer 16685 
    if self.isValid is not None:
2591 chandransh 16686 
      oprot.writeFieldBegin('isValid', TType.BOOL, 2)
16687 
      oprot.writeBool(self.isValid)
16688 
      oprot.writeFieldEnd()
16689 
    oprot.writeFieldStop()
16690 
    oprot.writeStructEnd()
16691 
 
3431 rajveer 16692 
  def validate(self):
16693 
    return
16694 
 
16695 
 
2591 chandransh 16696 
  def __repr__(self):
16697 
    L = ['%s=%r' % (key, value)
16698 
      for key, value in self.__dict__.iteritems()]
16699 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16700 
 
16701 
  def __eq__(self, other):
16702 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16703 
 
16704 
  def __ne__(self, other):
16705 
    return not (self == other)
16706 
 
16707 
class validateDoa_result:
16708 
  """
16709 
  Attributes:
16710 
   - success
16711 
   - ex
16712 
  """
16713 
 
16714 
  thrift_spec = (
16715 
    (0, TType.BOOL, 'success', None, None, ), # 0
16716 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
16717 
  )
16718 
 
16719 
  def __init__(self, success=None, ex=None,):
16720 
    self.success = success
16721 
    self.ex = ex
16722 
 
16723 
  def read(self, iprot):
16724 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16725 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16726 
      return
16727 
    iprot.readStructBegin()
16728 
    while True:
16729 
      (fname, ftype, fid) = iprot.readFieldBegin()
16730 
      if ftype == TType.STOP:
16731 
        break
16732 
      if fid == 0:
16733 
        if ftype == TType.BOOL:
16734 
          self.success = iprot.readBool();
16735 
        else:
16736 
          iprot.skip(ftype)
16737 
      elif fid == 1:
16738 
        if ftype == TType.STRUCT:
16739 
          self.ex = TransactionServiceException()
16740 
          self.ex.read(iprot)
16741 
        else:
16742 
          iprot.skip(ftype)
16743 
      else:
16744 
        iprot.skip(ftype)
16745 
      iprot.readFieldEnd()
16746 
    iprot.readStructEnd()
16747 
 
16748 
  def write(self, oprot):
16749 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16750 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16751 
      return
16752 
    oprot.writeStructBegin('validateDoa_result')
3431 rajveer 16753 
    if self.success is not None:
2591 chandransh 16754 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
16755 
      oprot.writeBool(self.success)
16756 
      oprot.writeFieldEnd()
3431 rajveer 16757 
    if self.ex is not None:
2591 chandransh 16758 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
16759 
      self.ex.write(oprot)
16760 
      oprot.writeFieldEnd()
16761 
    oprot.writeFieldStop()
16762 
    oprot.writeStructEnd()
16763 
 
3431 rajveer 16764 
  def validate(self):
16765 
    return
16766 
 
16767 
 
2591 chandransh 16768 
  def __repr__(self):
16769 
    L = ['%s=%r' % (key, value)
16770 
      for key, value in self.__dict__.iteritems()]
16771 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16772 
 
16773 
  def __eq__(self, other):
16774 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16775 
 
16776 
  def __ne__(self, other):
16777 
    return not (self == other)
16778 
 
4495 rajveer 16779 
class validateReturnProduct_args:
16780 
  """
16781 
  Attributes:
16782 
   - orderId
16783 
   - isUsable
16784 
  """
16785 
 
16786 
  thrift_spec = (
16787 
    None, # 0
16788 
    (1, TType.I64, 'orderId', None, None, ), # 1
16789 
    (2, TType.BOOL, 'isUsable', None, None, ), # 2
16790 
  )
16791 
 
16792 
  def __init__(self, orderId=None, isUsable=None,):
16793 
    self.orderId = orderId
16794 
    self.isUsable = isUsable
16795 
 
16796 
  def read(self, iprot):
16797 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16798 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16799 
      return
16800 
    iprot.readStructBegin()
16801 
    while True:
16802 
      (fname, ftype, fid) = iprot.readFieldBegin()
16803 
      if ftype == TType.STOP:
16804 
        break
16805 
      if fid == 1:
16806 
        if ftype == TType.I64:
16807 
          self.orderId = iprot.readI64();
16808 
        else:
16809 
          iprot.skip(ftype)
16810 
      elif fid == 2:
16811 
        if ftype == TType.BOOL:
16812 
          self.isUsable = iprot.readBool();
16813 
        else:
16814 
          iprot.skip(ftype)
16815 
      else:
16816 
        iprot.skip(ftype)
16817 
      iprot.readFieldEnd()
16818 
    iprot.readStructEnd()
16819 
 
16820 
  def write(self, oprot):
16821 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16822 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16823 
      return
16824 
    oprot.writeStructBegin('validateReturnProduct_args')
16825 
    if self.orderId is not None:
16826 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
16827 
      oprot.writeI64(self.orderId)
16828 
      oprot.writeFieldEnd()
16829 
    if self.isUsable is not None:
16830 
      oprot.writeFieldBegin('isUsable', TType.BOOL, 2)
16831 
      oprot.writeBool(self.isUsable)
16832 
      oprot.writeFieldEnd()
16833 
    oprot.writeFieldStop()
16834 
    oprot.writeStructEnd()
16835 
 
16836 
  def validate(self):
16837 
    return
16838 
 
16839 
 
16840 
  def __repr__(self):
16841 
    L = ['%s=%r' % (key, value)
16842 
      for key, value in self.__dict__.iteritems()]
16843 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16844 
 
16845 
  def __eq__(self, other):
16846 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16847 
 
16848 
  def __ne__(self, other):
16849 
    return not (self == other)
16850 
 
16851 
class validateReturnProduct_result:
16852 
  """
16853 
  Attributes:
16854 
   - success
16855 
   - ex
16856 
  """
16857 
 
16858 
  thrift_spec = (
16859 
    (0, TType.BOOL, 'success', None, None, ), # 0
16860 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
16861 
  )
16862 
 
16863 
  def __init__(self, success=None, ex=None,):
16864 
    self.success = success
16865 
    self.ex = ex
16866 
 
16867 
  def read(self, iprot):
16868 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16869 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16870 
      return
16871 
    iprot.readStructBegin()
16872 
    while True:
16873 
      (fname, ftype, fid) = iprot.readFieldBegin()
16874 
      if ftype == TType.STOP:
16875 
        break
16876 
      if fid == 0:
16877 
        if ftype == TType.BOOL:
16878 
          self.success = iprot.readBool();
16879 
        else:
16880 
          iprot.skip(ftype)
16881 
      elif fid == 1:
16882 
        if ftype == TType.STRUCT:
16883 
          self.ex = TransactionServiceException()
16884 
          self.ex.read(iprot)
16885 
        else:
16886 
          iprot.skip(ftype)
16887 
      else:
16888 
        iprot.skip(ftype)
16889 
      iprot.readFieldEnd()
16890 
    iprot.readStructEnd()
16891 
 
16892 
  def write(self, oprot):
16893 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16894 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16895 
      return
16896 
    oprot.writeStructBegin('validateReturnProduct_result')
16897 
    if self.success is not None:
16898 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
16899 
      oprot.writeBool(self.success)
16900 
      oprot.writeFieldEnd()
16901 
    if self.ex is not None:
16902 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
16903 
      self.ex.write(oprot)
16904 
      oprot.writeFieldEnd()
16905 
    oprot.writeFieldStop()
16906 
    oprot.writeStructEnd()
16907 
 
16908 
  def validate(self):
16909 
    return
16910 
 
16911 
 
16912 
  def __repr__(self):
16913 
    L = ['%s=%r' % (key, value)
16914 
      for key, value in self.__dict__.iteritems()]
16915 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16916 
 
16917 
  def __eq__(self, other):
16918 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16919 
 
16920 
  def __ne__(self, other):
16921 
    return not (self == other)
16922 
 
2616 chandransh 16923 
class reshipOrder_args:
16924 
  """
16925 
  Attributes:
16926 
   - orderId
16927 
  """
2591 chandransh 16928 
 
2616 chandransh 16929 
  thrift_spec = (
16930 
    None, # 0
16931 
    (1, TType.I64, 'orderId', None, None, ), # 1
16932 
  )
16933 
 
16934 
  def __init__(self, orderId=None,):
16935 
    self.orderId = orderId
16936 
 
16937 
  def read(self, iprot):
16938 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16939 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16940 
      return
16941 
    iprot.readStructBegin()
16942 
    while True:
16943 
      (fname, ftype, fid) = iprot.readFieldBegin()
16944 
      if ftype == TType.STOP:
16945 
        break
16946 
      if fid == 1:
16947 
        if ftype == TType.I64:
16948 
          self.orderId = iprot.readI64();
16949 
        else:
16950 
          iprot.skip(ftype)
16951 
      else:
16952 
        iprot.skip(ftype)
16953 
      iprot.readFieldEnd()
16954 
    iprot.readStructEnd()
16955 
 
16956 
  def write(self, oprot):
16957 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16958 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16959 
      return
16960 
    oprot.writeStructBegin('reshipOrder_args')
3431 rajveer 16961 
    if self.orderId is not None:
2616 chandransh 16962 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
16963 
      oprot.writeI64(self.orderId)
16964 
      oprot.writeFieldEnd()
16965 
    oprot.writeFieldStop()
16966 
    oprot.writeStructEnd()
16967 
 
3431 rajveer 16968 
  def validate(self):
16969 
    return
16970 
 
16971 
 
2616 chandransh 16972 
  def __repr__(self):
16973 
    L = ['%s=%r' % (key, value)
16974 
      for key, value in self.__dict__.iteritems()]
16975 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16976 
 
16977 
  def __eq__(self, other):
16978 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16979 
 
16980 
  def __ne__(self, other):
16981 
    return not (self == other)
16982 
 
16983 
class reshipOrder_result:
16984 
  """
16985 
  Attributes:
16986 
   - success
16987 
   - ex
16988 
  """
16989 
 
16990 
  thrift_spec = (
16991 
    (0, TType.I64, 'success', None, None, ), # 0
16992 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
16993 
  )
16994 
 
16995 
  def __init__(self, success=None, ex=None,):
16996 
    self.success = success
16997 
    self.ex = ex
16998 
 
16999 
  def read(self, iprot):
17000 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
17001 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
17002 
      return
17003 
    iprot.readStructBegin()
17004 
    while True:
17005 
      (fname, ftype, fid) = iprot.readFieldBegin()
17006 
      if ftype == TType.STOP:
17007 
        break
17008 
      if fid == 0:
17009 
        if ftype == TType.I64:
17010 
          self.success = iprot.readI64();
17011 
        else:
17012 
          iprot.skip(ftype)
17013 
      elif fid == 1:
17014 
        if ftype == TType.STRUCT:
17015 
          self.ex = TransactionServiceException()
17016 
          self.ex.read(iprot)
17017 
        else:
17018 
          iprot.skip(ftype)
17019 
      else:
17020 
        iprot.skip(ftype)
17021 
      iprot.readFieldEnd()
17022 
    iprot.readStructEnd()
17023 
 
17024 
  def write(self, oprot):
17025 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
17026 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
17027 
      return
17028 
    oprot.writeStructBegin('reshipOrder_result')
3431 rajveer 17029 
    if self.success is not None:
2616 chandransh 17030 
      oprot.writeFieldBegin('success', TType.I64, 0)
17031 
      oprot.writeI64(self.success)
17032 
      oprot.writeFieldEnd()
3431 rajveer 17033 
    if self.ex is not None:
2616 chandransh 17034 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
17035 
      self.ex.write(oprot)
17036 
      oprot.writeFieldEnd()
17037 
    oprot.writeFieldStop()
17038 
    oprot.writeStructEnd()
17039 
 
3431 rajveer 17040 
  def validate(self):
17041 
    return
17042 
 
17043 
 
2616 chandransh 17044 
  def __repr__(self):
17045 
    L = ['%s=%r' % (key, value)
17046 
      for key, value in self.__dict__.iteritems()]
17047 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
17048 
 
17049 
  def __eq__(self, other):
17050 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
17051 
 
17052 
  def __ne__(self, other):
17053 
    return not (self == other)
17054 
 
17055 
class refundOrder_args:
17056 
  """
17057 
  Attributes:
17058 
   - orderId
3226 chandransh 17059 
   - refundedBy
17060 
   - reason
2616 chandransh 17061 
  """
17062 
 
17063 
  thrift_spec = (
17064 
    None, # 0
17065 
    (1, TType.I64, 'orderId', None, None, ), # 1
3226 chandransh 17066 
    (2, TType.STRING, 'refundedBy', None, None, ), # 2
17067 
    (3, TType.STRING, 'reason', None, None, ), # 3
2616 chandransh 17068 
  )
17069 
 
3226 chandransh 17070 
  def __init__(self, orderId=None, refundedBy=None, reason=None,):
2616 chandransh 17071 
    self.orderId = orderId
3226 chandransh 17072 
    self.refundedBy = refundedBy
17073 
    self.reason = reason
2616 chandransh 17074 
 
17075 
  def read(self, iprot):
17076 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
17077 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
17078 
      return
17079 
    iprot.readStructBegin()
17080 
    while True:
17081 
      (fname, ftype, fid) = iprot.readFieldBegin()
17082 
      if ftype == TType.STOP:
17083 
        break
17084 
      if fid == 1:
17085 
        if ftype == TType.I64:
17086 
          self.orderId = iprot.readI64();
17087 
        else:
17088 
          iprot.skip(ftype)
3226 chandransh 17089 
      elif fid == 2:
17090 
        if ftype == TType.STRING:
17091 
          self.refundedBy = iprot.readString();
17092 
        else:
17093 
          iprot.skip(ftype)
17094 
      elif fid == 3:
17095 
        if ftype == TType.STRING:
17096 
          self.reason = iprot.readString();
17097 
        else:
17098 
          iprot.skip(ftype)
2616 chandransh 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('refundOrder_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()
3431 rajveer 17113 
    if self.refundedBy is not None:
3226 chandransh 17114 
      oprot.writeFieldBegin('refundedBy', TType.STRING, 2)
17115 
      oprot.writeString(self.refundedBy)
17116 
      oprot.writeFieldEnd()
3431 rajveer 17117 
    if self.reason is not None:
3226 chandransh 17118 
      oprot.writeFieldBegin('reason', TType.STRING, 3)
17119 
      oprot.writeString(self.reason)
17120 
      oprot.writeFieldEnd()
2616 chandransh 17121 
    oprot.writeFieldStop()
17122 
    oprot.writeStructEnd()
17123 
 
3431 rajveer 17124 
  def validate(self):
17125 
    return
17126 
 
17127 
 
2616 chandransh 17128 
  def __repr__(self):
17129 
    L = ['%s=%r' % (key, value)
17130 
      for key, value in self.__dict__.iteritems()]
17131 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
17132 
 
17133 
  def __eq__(self, other):
17134 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
17135 
 
17136 
  def __ne__(self, other):
17137 
    return not (self == other)
17138 
 
17139 
class refundOrder_result:
17140 
  """
17141 
  Attributes:
17142 
   - success
17143 
   - ex
17144 
  """
17145 
 
17146 
  thrift_spec = (
17147 
    (0, TType.BOOL, 'success', None, None, ), # 0
17148 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
17149 
  )
17150 
 
17151 
  def __init__(self, success=None, ex=None,):
17152 
    self.success = success
17153 
    self.ex = ex
17154 
 
17155 
  def read(self, iprot):
17156 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
17157 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
17158 
      return
17159 
    iprot.readStructBegin()
17160 
    while True:
17161 
      (fname, ftype, fid) = iprot.readFieldBegin()
17162 
      if ftype == TType.STOP:
17163 
        break
17164 
      if fid == 0:
17165 
        if ftype == TType.BOOL:
17166 
          self.success = iprot.readBool();
17167 
        else:
17168 
          iprot.skip(ftype)
17169 
      elif fid == 1:
17170 
        if ftype == TType.STRUCT:
17171 
          self.ex = TransactionServiceException()
17172 
          self.ex.read(iprot)
17173 
        else:
17174 
          iprot.skip(ftype)
17175 
      else:
17176 
        iprot.skip(ftype)
17177 
      iprot.readFieldEnd()
17178 
    iprot.readStructEnd()
17179 
 
17180 
  def write(self, oprot):
17181 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
17182 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
17183 
      return
17184 
    oprot.writeStructBegin('refundOrder_result')
3431 rajveer 17185 
    if self.success is not None:
2616 chandransh 17186 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
17187 
      oprot.writeBool(self.success)
17188 
      oprot.writeFieldEnd()
3431 rajveer 17189 
    if self.ex is not None:
2616 chandransh 17190 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
17191 
      self.ex.write(oprot)
17192 
      oprot.writeFieldEnd()
17193 
    oprot.writeFieldStop()
17194 
    oprot.writeStructEnd()
17195 
 
3431 rajveer 17196 
  def validate(self):
17197 
    return
17198 
 
17199 
 
2616 chandransh 17200 
  def __repr__(self):
17201 
    L = ['%s=%r' % (key, value)
17202 
      for key, value in self.__dict__.iteritems()]
17203 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
17204 
 
17205 
  def __eq__(self, other):
17206 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
17207 
 
17208 
  def __ne__(self, other):
17209 
    return not (self == other)
17210 
 
2690 chandransh 17211 
class getReturnOrders_args:
17212 
  """
17213 
  Attributes:
17214 
   - warehouseId
17215 
   - fromDate
17216 
   - toDate
17217 
  """
2616 chandransh 17218 
 
2690 chandransh 17219 
  thrift_spec = (
17220 
    None, # 0
17221 
    (1, TType.I64, 'warehouseId', None, None, ), # 1
17222 
    (2, TType.I64, 'fromDate', None, None, ), # 2
17223 
    (3, TType.I64, 'toDate', None, None, ), # 3
17224 
  )
17225 
 
17226 
  def __init__(self, warehouseId=None, fromDate=None, toDate=None,):
17227 
    self.warehouseId = warehouseId
17228 
    self.fromDate = fromDate
17229 
    self.toDate = toDate
17230 
 
17231 
  def read(self, iprot):
17232 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
17233 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
17234 
      return
17235 
    iprot.readStructBegin()
17236 
    while True:
17237 
      (fname, ftype, fid) = iprot.readFieldBegin()
17238 
      if ftype == TType.STOP:
17239 
        break
17240 
      if fid == 1:
17241 
        if ftype == TType.I64:
17242 
          self.warehouseId = iprot.readI64();
17243 
        else:
17244 
          iprot.skip(ftype)
17245 
      elif fid == 2:
17246 
        if ftype == TType.I64:
17247 
          self.fromDate = iprot.readI64();
17248 
        else:
17249 
          iprot.skip(ftype)
17250 
      elif fid == 3:
17251 
        if ftype == TType.I64:
17252 
          self.toDate = iprot.readI64();
17253 
        else:
17254 
          iprot.skip(ftype)
17255 
      else:
17256 
        iprot.skip(ftype)
17257 
      iprot.readFieldEnd()
17258 
    iprot.readStructEnd()
17259 
 
17260 
  def write(self, oprot):
17261 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
17262 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
17263 
      return
17264 
    oprot.writeStructBegin('getReturnOrders_args')
3431 rajveer 17265 
    if self.warehouseId is not None:
2690 chandransh 17266 
      oprot.writeFieldBegin('warehouseId', TType.I64, 1)
17267 
      oprot.writeI64(self.warehouseId)
17268 
      oprot.writeFieldEnd()
3431 rajveer 17269 
    if self.fromDate is not None:
2690 chandransh 17270 
      oprot.writeFieldBegin('fromDate', TType.I64, 2)
17271 
      oprot.writeI64(self.fromDate)
17272 
      oprot.writeFieldEnd()
3431 rajveer 17273 
    if self.toDate is not None:
2690 chandransh 17274 
      oprot.writeFieldBegin('toDate', TType.I64, 3)
17275 
      oprot.writeI64(self.toDate)
17276 
      oprot.writeFieldEnd()
17277 
    oprot.writeFieldStop()
17278 
    oprot.writeStructEnd()
17279 
 
3431 rajveer 17280 
  def validate(self):
17281 
    return
17282 
 
17283 
 
2690 chandransh 17284 
  def __repr__(self):
17285 
    L = ['%s=%r' % (key, value)
17286 
      for key, value in self.__dict__.iteritems()]
17287 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
17288 
 
17289 
  def __eq__(self, other):
17290 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
17291 
 
17292 
  def __ne__(self, other):
17293 
    return not (self == other)
17294 
 
17295 
class getReturnOrders_result:
17296 
  """
17297 
  Attributes:
17298 
   - success
17299 
  """
17300 
 
17301 
  thrift_spec = (
17302 
    (0, TType.LIST, 'success', (TType.STRUCT,(ReturnOrder, ReturnOrder.thrift_spec)), None, ), # 0
17303 
  )
17304 
 
17305 
  def __init__(self, success=None,):
17306 
    self.success = success
17307 
 
17308 
  def read(self, iprot):
17309 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
17310 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
17311 
      return
17312 
    iprot.readStructBegin()
17313 
    while True:
17314 
      (fname, ftype, fid) = iprot.readFieldBegin()
17315 
      if ftype == TType.STOP:
17316 
        break
17317 
      if fid == 0:
17318 
        if ftype == TType.LIST:
17319 
          self.success = []
5676 rajveer 17320 
          (_etype392, _size389) = iprot.readListBegin()
17321 
          for _i393 in xrange(_size389):
17322 
            _elem394 = ReturnOrder()
17323 
            _elem394.read(iprot)
17324 
            self.success.append(_elem394)
2690 chandransh 17325 
          iprot.readListEnd()
17326 
        else:
17327 
          iprot.skip(ftype)
17328 
      else:
17329 
        iprot.skip(ftype)
17330 
      iprot.readFieldEnd()
17331 
    iprot.readStructEnd()
17332 
 
17333 
  def write(self, oprot):
17334 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
17335 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
17336 
      return
17337 
    oprot.writeStructBegin('getReturnOrders_result')
3431 rajveer 17338 
    if self.success is not None:
2690 chandransh 17339 
      oprot.writeFieldBegin('success', TType.LIST, 0)
17340 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
5676 rajveer 17341 
      for iter395 in self.success:
17342 
        iter395.write(oprot)
2690 chandransh 17343 
      oprot.writeListEnd()
17344 
      oprot.writeFieldEnd()
17345 
    oprot.writeFieldStop()
17346 
    oprot.writeStructEnd()
17347 
 
3431 rajveer 17348 
  def validate(self):
17349 
    return
17350 
 
17351 
 
2690 chandransh 17352 
  def __repr__(self):
17353 
    L = ['%s=%r' % (key, value)
17354 
      for key, value in self.__dict__.iteritems()]
17355 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
17356 
 
17357 
  def __eq__(self, other):
17358 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
17359 
 
17360 
  def __ne__(self, other):
17361 
    return not (self == other)
17362 
 
5481 phani.kuma 17363 
class getAllReturnOrders_args:
17364 
  """
17365 
  Attributes:
17366 
   - onlyNotProcessed
17367 
   - fromDate
17368 
   - toDate
17369 
  """
17370 
 
17371 
  thrift_spec = (
17372 
    None, # 0
17373 
    (1, TType.BOOL, 'onlyNotProcessed', None, None, ), # 1
17374 
    (2, TType.I64, 'fromDate', None, None, ), # 2
17375 
    (3, TType.I64, 'toDate', None, None, ), # 3
17376 
  )
17377 
 
17378 
  def __init__(self, onlyNotProcessed=None, fromDate=None, toDate=None,):
17379 
    self.onlyNotProcessed = onlyNotProcessed
17380 
    self.fromDate = fromDate
17381 
    self.toDate = toDate
17382 
 
17383 
  def read(self, iprot):
17384 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
17385 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
17386 
      return
17387 
    iprot.readStructBegin()
17388 
    while True:
17389 
      (fname, ftype, fid) = iprot.readFieldBegin()
17390 
      if ftype == TType.STOP:
17391 
        break
17392 
      if fid == 1:
17393 
        if ftype == TType.BOOL:
17394 
          self.onlyNotProcessed = iprot.readBool();
17395 
        else:
17396 
          iprot.skip(ftype)
17397 
      elif fid == 2:
17398 
        if ftype == TType.I64:
17399 
          self.fromDate = iprot.readI64();
17400 
        else:
17401 
          iprot.skip(ftype)
17402 
      elif fid == 3:
17403 
        if ftype == TType.I64:
17404 
          self.toDate = iprot.readI64();
17405 
        else:
17406 
          iprot.skip(ftype)
17407 
      else:
17408 
        iprot.skip(ftype)
17409 
      iprot.readFieldEnd()
17410 
    iprot.readStructEnd()
17411 
 
17412 
  def write(self, oprot):
17413 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
17414 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
17415 
      return
17416 
    oprot.writeStructBegin('getAllReturnOrders_args')
17417 
    if self.onlyNotProcessed is not None:
17418 
      oprot.writeFieldBegin('onlyNotProcessed', TType.BOOL, 1)
17419 
      oprot.writeBool(self.onlyNotProcessed)
17420 
      oprot.writeFieldEnd()
17421 
    if self.fromDate is not None:
17422 
      oprot.writeFieldBegin('fromDate', TType.I64, 2)
17423 
      oprot.writeI64(self.fromDate)
17424 
      oprot.writeFieldEnd()
17425 
    if self.toDate is not None:
17426 
      oprot.writeFieldBegin('toDate', TType.I64, 3)
17427 
      oprot.writeI64(self.toDate)
17428 
      oprot.writeFieldEnd()
17429 
    oprot.writeFieldStop()
17430 
    oprot.writeStructEnd()
17431 
 
17432 
  def validate(self):
17433 
    return
17434 
 
17435 
 
17436 
  def __repr__(self):
17437 
    L = ['%s=%r' % (key, value)
17438 
      for key, value in self.__dict__.iteritems()]
17439 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
17440 
 
17441 
  def __eq__(self, other):
17442 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
17443 
 
17444 
  def __ne__(self, other):
17445 
    return not (self == other)
17446 
 
17447 
class getAllReturnOrders_result:
17448 
  """
17449 
  Attributes:
17450 
   - success
17451 
  """
17452 
 
17453 
  thrift_spec = (
17454 
    (0, TType.LIST, 'success', (TType.STRUCT,(ReturnOrder, ReturnOrder.thrift_spec)), None, ), # 0
17455 
  )
17456 
 
17457 
  def __init__(self, success=None,):
17458 
    self.success = success
17459 
 
17460 
  def read(self, iprot):
17461 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
17462 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
17463 
      return
17464 
    iprot.readStructBegin()
17465 
    while True:
17466 
      (fname, ftype, fid) = iprot.readFieldBegin()
17467 
      if ftype == TType.STOP:
17468 
        break
17469 
      if fid == 0:
17470 
        if ftype == TType.LIST:
17471 
          self.success = []
5676 rajveer 17472 
          (_etype399, _size396) = iprot.readListBegin()
17473 
          for _i400 in xrange(_size396):
17474 
            _elem401 = ReturnOrder()
17475 
            _elem401.read(iprot)
17476 
            self.success.append(_elem401)
5481 phani.kuma 17477 
          iprot.readListEnd()
17478 
        else:
17479 
          iprot.skip(ftype)
17480 
      else:
17481 
        iprot.skip(ftype)
17482 
      iprot.readFieldEnd()
17483 
    iprot.readStructEnd()
17484 
 
17485 
  def write(self, oprot):
17486 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
17487 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
17488 
      return
17489 
    oprot.writeStructBegin('getAllReturnOrders_result')
17490 
    if self.success is not None:
17491 
      oprot.writeFieldBegin('success', TType.LIST, 0)
17492 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
5676 rajveer 17493 
      for iter402 in self.success:
17494 
        iter402.write(oprot)
5481 phani.kuma 17495 
      oprot.writeListEnd()
17496 
      oprot.writeFieldEnd()
17497 
    oprot.writeFieldStop()
17498 
    oprot.writeStructEnd()
17499 
 
17500 
  def validate(self):
17501 
    return
17502 
 
17503 
 
17504 
  def __repr__(self):
17505 
    L = ['%s=%r' % (key, value)
17506 
      for key, value in self.__dict__.iteritems()]
17507 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
17508 
 
17509 
  def __eq__(self, other):
17510 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
17511 
 
17512 
  def __ne__(self, other):
17513 
    return not (self == other)
17514 
 
2700 chandransh 17515 
class getReturnOrder_args:
17516 
  """
17517 
  Attributes:
17518 
   - id
17519 
  """
17520 
 
17521 
  thrift_spec = (
17522 
    None, # 0
17523 
    (1, TType.I64, 'id', None, None, ), # 1
17524 
  )
17525 
 
17526 
  def __init__(self, id=None,):
17527 
    self.id = id
17528 
 
17529 
  def read(self, iprot):
17530 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
17531 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
17532 
      return
17533 
    iprot.readStructBegin()
17534 
    while True:
17535 
      (fname, ftype, fid) = iprot.readFieldBegin()
17536 
      if ftype == TType.STOP:
17537 
        break
17538 
      if fid == 1:
17539 
        if ftype == TType.I64:
17540 
          self.id = iprot.readI64();
17541 
        else:
17542 
          iprot.skip(ftype)
17543 
      else:
17544 
        iprot.skip(ftype)
17545 
      iprot.readFieldEnd()
17546 
    iprot.readStructEnd()
17547 
 
17548 
  def write(self, oprot):
17549 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
17550 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
17551 
      return
17552 
    oprot.writeStructBegin('getReturnOrder_args')
3431 rajveer 17553 
    if self.id is not None:
2700 chandransh 17554 
      oprot.writeFieldBegin('id', TType.I64, 1)
17555 
      oprot.writeI64(self.id)
17556 
      oprot.writeFieldEnd()
17557 
    oprot.writeFieldStop()
17558 
    oprot.writeStructEnd()
17559 
 
3431 rajveer 17560 
  def validate(self):
17561 
    return
17562 
 
17563 
 
2700 chandransh 17564 
  def __repr__(self):
17565 
    L = ['%s=%r' % (key, value)
17566 
      for key, value in self.__dict__.iteritems()]
17567 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
17568 
 
17569 
  def __eq__(self, other):
17570 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
17571 
 
17572 
  def __ne__(self, other):
17573 
    return not (self == other)
17574 
 
17575 
class getReturnOrder_result:
17576 
  """
17577 
  Attributes:
17578 
   - success
17579 
   - ex
17580 
  """
17581 
 
17582 
  thrift_spec = (
17583 
    (0, TType.STRUCT, 'success', (ReturnOrder, ReturnOrder.thrift_spec), None, ), # 0
17584 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
17585 
  )
17586 
 
17587 
  def __init__(self, success=None, ex=None,):
17588 
    self.success = success
17589 
    self.ex = ex
17590 
 
17591 
  def read(self, iprot):
17592 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
17593 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
17594 
      return
17595 
    iprot.readStructBegin()
17596 
    while True:
17597 
      (fname, ftype, fid) = iprot.readFieldBegin()
17598 
      if ftype == TType.STOP:
17599 
        break
17600 
      if fid == 0:
17601 
        if ftype == TType.STRUCT:
17602 
          self.success = ReturnOrder()
17603 
          self.success.read(iprot)
17604 
        else:
17605 
          iprot.skip(ftype)
17606 
      elif fid == 1:
17607 
        if ftype == TType.STRUCT:
17608 
          self.ex = TransactionServiceException()
17609 
          self.ex.read(iprot)
17610 
        else:
17611 
          iprot.skip(ftype)
17612 
      else:
17613 
        iprot.skip(ftype)
17614 
      iprot.readFieldEnd()
17615 
    iprot.readStructEnd()
17616 
 
17617 
  def write(self, oprot):
17618 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
17619 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
17620 
      return
17621 
    oprot.writeStructBegin('getReturnOrder_result')
3431 rajveer 17622 
    if self.success is not None:
2700 chandransh 17623 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
17624 
      self.success.write(oprot)
17625 
      oprot.writeFieldEnd()
3431 rajveer 17626 
    if self.ex is not None:
2700 chandransh 17627 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
17628 
      self.ex.write(oprot)
17629 
      oprot.writeFieldEnd()
17630 
    oprot.writeFieldStop()
17631 
    oprot.writeStructEnd()
17632 
 
3431 rajveer 17633 
  def validate(self):
17634 
    return
17635 
 
17636 
 
2700 chandransh 17637 
  def __repr__(self):
17638 
    L = ['%s=%r' % (key, value)
17639 
      for key, value in self.__dict__.iteritems()]
17640 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
17641 
 
17642 
  def __eq__(self, other):
17643 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
17644 
 
17645 
  def __ne__(self, other):
17646 
    return not (self == other)
17647 
 
2690 chandransh 17648 
class processReturn_args:
17649 
  """
17650 
  Attributes:
17651 
   - returnOrderId
17652 
  """
17653 
 
17654 
  thrift_spec = (
17655 
    None, # 0
17656 
    (1, TType.I64, 'returnOrderId', None, None, ), # 1
17657 
  )
17658 
 
17659 
  def __init__(self, returnOrderId=None,):
17660 
    self.returnOrderId = returnOrderId
17661 
 
17662 
  def read(self, iprot):
17663 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
17664 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
17665 
      return
17666 
    iprot.readStructBegin()
17667 
    while True:
17668 
      (fname, ftype, fid) = iprot.readFieldBegin()
17669 
      if ftype == TType.STOP:
17670 
        break
17671 
      if fid == 1:
17672 
        if ftype == TType.I64:
17673 
          self.returnOrderId = iprot.readI64();
17674 
        else:
17675 
          iprot.skip(ftype)
17676 
      else:
17677 
        iprot.skip(ftype)
17678 
      iprot.readFieldEnd()
17679 
    iprot.readStructEnd()
17680 
 
17681 
  def write(self, oprot):
17682 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
17683 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
17684 
      return
17685 
    oprot.writeStructBegin('processReturn_args')
3431 rajveer 17686 
    if self.returnOrderId is not None:
2690 chandransh 17687 
      oprot.writeFieldBegin('returnOrderId', TType.I64, 1)
17688 
      oprot.writeI64(self.returnOrderId)
17689 
      oprot.writeFieldEnd()
17690 
    oprot.writeFieldStop()
17691 
    oprot.writeStructEnd()
17692 
 
3431 rajveer 17693 
  def validate(self):
17694 
    return
17695 
 
17696 
 
2690 chandransh 17697 
  def __repr__(self):
17698 
    L = ['%s=%r' % (key, value)
17699 
      for key, value in self.__dict__.iteritems()]
17700 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
17701 
 
17702 
  def __eq__(self, other):
17703 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
17704 
 
17705 
  def __ne__(self, other):
17706 
    return not (self == other)
17707 
 
17708 
class processReturn_result:
17709 
  """
17710 
  Attributes:
17711 
   - ex
17712 
  """
17713 
 
17714 
  thrift_spec = (
17715 
    None, # 0
17716 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
17717 
  )
17718 
 
17719 
  def __init__(self, ex=None,):
17720 
    self.ex = ex
17721 
 
17722 
  def read(self, iprot):
17723 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
17724 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
17725 
      return
17726 
    iprot.readStructBegin()
17727 
    while True:
17728 
      (fname, ftype, fid) = iprot.readFieldBegin()
17729 
      if ftype == TType.STOP:
17730 
        break
17731 
      if fid == 1:
17732 
        if ftype == TType.STRUCT:
17733 
          self.ex = TransactionServiceException()
17734 
          self.ex.read(iprot)
17735 
        else:
17736 
          iprot.skip(ftype)
17737 
      else:
17738 
        iprot.skip(ftype)
17739 
      iprot.readFieldEnd()
17740 
    iprot.readStructEnd()
17741 
 
17742 
  def write(self, oprot):
17743 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
17744 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
17745 
      return
17746 
    oprot.writeStructBegin('processReturn_result')
3431 rajveer 17747 
    if self.ex is not None:
2690 chandransh 17748 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
17749 
      self.ex.write(oprot)
17750 
      oprot.writeFieldEnd()
17751 
    oprot.writeFieldStop()
17752 
    oprot.writeStructEnd()
17753 
 
3431 rajveer 17754 
  def validate(self):
17755 
    return
17756 
 
17757 
 
2690 chandransh 17758 
  def __repr__(self):
17759 
    L = ['%s=%r' % (key, value)
17760 
      for key, value in self.__dict__.iteritems()]
17761 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
17762 
 
17763 
  def __eq__(self, other):
17764 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
17765 
 
17766 
  def __ne__(self, other):
17767 
    return not (self == other)
17768 
 
3451 chandransh 17769 
class updateWeight_args:
17770 
  """
17771 
  Attributes:
17772 
   - orderId
17773 
   - weight
17774 
  """
17775 
 
17776 
  thrift_spec = (
17777 
    None, # 0
17778 
    (1, TType.I64, 'orderId', None, None, ), # 1
17779 
    (2, TType.DOUBLE, 'weight', None, None, ), # 2
17780 
  )
17781 
 
17782 
  def __init__(self, orderId=None, weight=None,):
17783 
    self.orderId = orderId
17784 
    self.weight = weight
17785 
 
17786 
  def read(self, iprot):
17787 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
17788 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
17789 
      return
17790 
    iprot.readStructBegin()
17791 
    while True:
17792 
      (fname, ftype, fid) = iprot.readFieldBegin()
17793 
      if ftype == TType.STOP:
17794 
        break
17795 
      if fid == 1:
17796 
        if ftype == TType.I64:
17797 
          self.orderId = iprot.readI64();
17798 
        else:
17799 
          iprot.skip(ftype)
17800 
      elif fid == 2:
17801 
        if ftype == TType.DOUBLE:
17802 
          self.weight = iprot.readDouble();
17803 
        else:
17804 
          iprot.skip(ftype)
17805 
      else:
17806 
        iprot.skip(ftype)
17807 
      iprot.readFieldEnd()
17808 
    iprot.readStructEnd()
17809 
 
17810 
  def write(self, oprot):
17811 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
17812 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
17813 
      return
17814 
    oprot.writeStructBegin('updateWeight_args')
17815 
    if self.orderId is not None:
17816 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
17817 
      oprot.writeI64(self.orderId)
17818 
      oprot.writeFieldEnd()
17819 
    if self.weight is not None:
17820 
      oprot.writeFieldBegin('weight', TType.DOUBLE, 2)
17821 
      oprot.writeDouble(self.weight)
17822 
      oprot.writeFieldEnd()
17823 
    oprot.writeFieldStop()
17824 
    oprot.writeStructEnd()
17825 
 
17826 
  def validate(self):
17827 
    return
17828 
 
17829 
 
17830 
  def __repr__(self):
17831 
    L = ['%s=%r' % (key, value)
17832 
      for key, value in self.__dict__.iteritems()]
17833 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
17834 
 
17835 
  def __eq__(self, other):
17836 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
17837 
 
17838 
  def __ne__(self, other):
17839 
    return not (self == other)
17840 
 
17841 
class updateWeight_result:
17842 
  """
17843 
  Attributes:
17844 
   - success
17845 
   - ex
17846 
  """
17847 
 
17848 
  thrift_spec = (
17849 
    (0, TType.STRUCT, 'success', (Order, Order.thrift_spec), None, ), # 0
17850 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
17851 
  )
17852 
 
17853 
  def __init__(self, success=None, ex=None,):
17854 
    self.success = success
17855 
    self.ex = ex
17856 
 
17857 
  def read(self, iprot):
17858 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
17859 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
17860 
      return
17861 
    iprot.readStructBegin()
17862 
    while True:
17863 
      (fname, ftype, fid) = iprot.readFieldBegin()
17864 
      if ftype == TType.STOP:
17865 
        break
17866 
      if fid == 0:
17867 
        if ftype == TType.STRUCT:
17868 
          self.success = Order()
17869 
          self.success.read(iprot)
17870 
        else:
17871 
          iprot.skip(ftype)
17872 
      elif fid == 1:
17873 
        if ftype == TType.STRUCT:
17874 
          self.ex = TransactionServiceException()
17875 
          self.ex.read(iprot)
17876 
        else:
17877 
          iprot.skip(ftype)
17878 
      else:
17879 
        iprot.skip(ftype)
17880 
      iprot.readFieldEnd()
17881 
    iprot.readStructEnd()
17882 
 
17883 
  def write(self, oprot):
17884 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
17885 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
17886 
      return
17887 
    oprot.writeStructBegin('updateWeight_result')
17888 
    if self.success is not None:
17889 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
17890 
      self.success.write(oprot)
17891 
      oprot.writeFieldEnd()
17892 
    if self.ex is not None:
17893 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
17894 
      self.ex.write(oprot)
17895 
      oprot.writeFieldEnd()
17896 
    oprot.writeFieldStop()
17897 
    oprot.writeStructEnd()
17898 
 
17899 
  def validate(self):
17900 
    return
17901 
 
17902 
 
17903 
  def __repr__(self):
17904 
    L = ['%s=%r' % (key, value)
17905 
      for key, value in self.__dict__.iteritems()]
17906 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
17907 
 
17908 
  def __eq__(self, other):
17909 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
17910 
 
17911 
  def __ne__(self, other):
17912 
    return not (self == other)
3469 chandransh 17913 
 
17914 
class changeItem_args:
17915 
  """
17916 
  Attributes:
17917 
   - orderId
17918 
   - itemId
17919 
  """
17920 
 
17921 
  thrift_spec = (
17922 
    None, # 0
17923 
    (1, TType.I64, 'orderId', None, None, ), # 1
17924 
    (2, TType.I64, 'itemId', None, None, ), # 2
17925 
  )
17926 
 
17927 
  def __init__(self, orderId=None, itemId=None,):
17928 
    self.orderId = orderId
17929 
    self.itemId = itemId
17930 
 
17931 
  def read(self, iprot):
17932 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
17933 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
17934 
      return
17935 
    iprot.readStructBegin()
17936 
    while True:
17937 
      (fname, ftype, fid) = iprot.readFieldBegin()
17938 
      if ftype == TType.STOP:
17939 
        break
17940 
      if fid == 1:
17941 
        if ftype == TType.I64:
17942 
          self.orderId = iprot.readI64();
17943 
        else:
17944 
          iprot.skip(ftype)
17945 
      elif fid == 2:
17946 
        if ftype == TType.I64:
17947 
          self.itemId = iprot.readI64();
17948 
        else:
17949 
          iprot.skip(ftype)
17950 
      else:
17951 
        iprot.skip(ftype)
17952 
      iprot.readFieldEnd()
17953 
    iprot.readStructEnd()
17954 
 
17955 
  def write(self, oprot):
17956 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
17957 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
17958 
      return
17959 
    oprot.writeStructBegin('changeItem_args')
17960 
    if self.orderId is not None:
17961 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
17962 
      oprot.writeI64(self.orderId)
17963 
      oprot.writeFieldEnd()
17964 
    if self.itemId is not None:
17965 
      oprot.writeFieldBegin('itemId', TType.I64, 2)
17966 
      oprot.writeI64(self.itemId)
17967 
      oprot.writeFieldEnd()
17968 
    oprot.writeFieldStop()
17969 
    oprot.writeStructEnd()
17970 
 
17971 
  def validate(self):
17972 
    return
17973 
 
17974 
 
17975 
  def __repr__(self):
17976 
    L = ['%s=%r' % (key, value)
17977 
      for key, value in self.__dict__.iteritems()]
17978 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
17979 
 
17980 
  def __eq__(self, other):
17981 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
17982 
 
17983 
  def __ne__(self, other):
17984 
    return not (self == other)
17985 
 
17986 
class changeItem_result:
17987 
  """
17988 
  Attributes:
17989 
   - success
17990 
   - ex
17991 
  """
17992 
 
17993 
  thrift_spec = (
17994 
    (0, TType.STRUCT, 'success', (Order, Order.thrift_spec), None, ), # 0
17995 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
17996 
  )
17997 
 
17998 
  def __init__(self, success=None, ex=None,):
17999 
    self.success = success
18000 
    self.ex = ex
18001 
 
18002 
  def read(self, iprot):
18003 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
18004 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
18005 
      return
18006 
    iprot.readStructBegin()
18007 
    while True:
18008 
      (fname, ftype, fid) = iprot.readFieldBegin()
18009 
      if ftype == TType.STOP:
18010 
        break
18011 
      if fid == 0:
18012 
        if ftype == TType.STRUCT:
18013 
          self.success = Order()
18014 
          self.success.read(iprot)
18015 
        else:
18016 
          iprot.skip(ftype)
18017 
      elif fid == 1:
18018 
        if ftype == TType.STRUCT:
18019 
          self.ex = TransactionServiceException()
18020 
          self.ex.read(iprot)
18021 
        else:
18022 
          iprot.skip(ftype)
18023 
      else:
18024 
        iprot.skip(ftype)
18025 
      iprot.readFieldEnd()
18026 
    iprot.readStructEnd()
18027 
 
18028 
  def write(self, oprot):
18029 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
18030 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
18031 
      return
18032 
    oprot.writeStructBegin('changeItem_result')
18033 
    if self.success is not None:
18034 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
18035 
      self.success.write(oprot)
18036 
      oprot.writeFieldEnd()
18037 
    if self.ex is not None:
18038 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
18039 
      self.ex.write(oprot)
18040 
      oprot.writeFieldEnd()
18041 
    oprot.writeFieldStop()
18042 
    oprot.writeStructEnd()
18043 
 
18044 
  def validate(self):
18045 
    return
18046 
 
18047 
 
18048 
  def __repr__(self):
18049 
    L = ['%s=%r' % (key, value)
18050 
      for key, value in self.__dict__.iteritems()]
18051 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
18052 
 
18053 
  def __eq__(self, other):
18054 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
18055 
 
18056 
  def __ne__(self, other):
18057 
    return not (self == other)
18058 
 
18059 
class shiftToWarehouse_args:
18060 
  """
18061 
  Attributes:
18062 
   - orderId
18063 
   - warehouseId
18064 
  """
18065 
 
18066 
  thrift_spec = (
18067 
    None, # 0
18068 
    (1, TType.I64, 'orderId', None, None, ), # 1
18069 
    (2, TType.I64, 'warehouseId', None, None, ), # 2
18070 
  )
18071 
 
18072 
  def __init__(self, orderId=None, warehouseId=None,):
18073 
    self.orderId = orderId
18074 
    self.warehouseId = warehouseId
18075 
 
18076 
  def read(self, iprot):
18077 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
18078 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
18079 
      return
18080 
    iprot.readStructBegin()
18081 
    while True:
18082 
      (fname, ftype, fid) = iprot.readFieldBegin()
18083 
      if ftype == TType.STOP:
18084 
        break
18085 
      if fid == 1:
18086 
        if ftype == TType.I64:
18087 
          self.orderId = iprot.readI64();
18088 
        else:
18089 
          iprot.skip(ftype)
18090 
      elif fid == 2:
18091 
        if ftype == TType.I64:
18092 
          self.warehouseId = iprot.readI64();
18093 
        else:
18094 
          iprot.skip(ftype)
18095 
      else:
18096 
        iprot.skip(ftype)
18097 
      iprot.readFieldEnd()
18098 
    iprot.readStructEnd()
18099 
 
18100 
  def write(self, oprot):
18101 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
18102 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
18103 
      return
18104 
    oprot.writeStructBegin('shiftToWarehouse_args')
18105 
    if self.orderId is not None:
18106 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
18107 
      oprot.writeI64(self.orderId)
18108 
      oprot.writeFieldEnd()
18109 
    if self.warehouseId is not None:
18110 
      oprot.writeFieldBegin('warehouseId', TType.I64, 2)
18111 
      oprot.writeI64(self.warehouseId)
18112 
      oprot.writeFieldEnd()
18113 
    oprot.writeFieldStop()
18114 
    oprot.writeStructEnd()
18115 
 
18116 
  def validate(self):
18117 
    return
18118 
 
18119 
 
18120 
  def __repr__(self):
18121 
    L = ['%s=%r' % (key, value)
18122 
      for key, value in self.__dict__.iteritems()]
18123 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
18124 
 
18125 
  def __eq__(self, other):
18126 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
18127 
 
18128 
  def __ne__(self, other):
18129 
    return not (self == other)
18130 
 
18131 
class shiftToWarehouse_result:
18132 
  """
18133 
  Attributes:
18134 
   - success
18135 
   - ex
18136 
  """
18137 
 
18138 
  thrift_spec = (
18139 
    (0, TType.STRUCT, 'success', (Order, Order.thrift_spec), None, ), # 0
18140 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
18141 
  )
18142 
 
18143 
  def __init__(self, success=None, ex=None,):
18144 
    self.success = success
18145 
    self.ex = ex
18146 
 
18147 
  def read(self, iprot):
18148 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
18149 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
18150 
      return
18151 
    iprot.readStructBegin()
18152 
    while True:
18153 
      (fname, ftype, fid) = iprot.readFieldBegin()
18154 
      if ftype == TType.STOP:
18155 
        break
18156 
      if fid == 0:
18157 
        if ftype == TType.STRUCT:
18158 
          self.success = Order()
18159 
          self.success.read(iprot)
18160 
        else:
18161 
          iprot.skip(ftype)
18162 
      elif fid == 1:
18163 
        if ftype == TType.STRUCT:
18164 
          self.ex = TransactionServiceException()
18165 
          self.ex.read(iprot)
18166 
        else:
18167 
          iprot.skip(ftype)
18168 
      else:
18169 
        iprot.skip(ftype)
18170 
      iprot.readFieldEnd()
18171 
    iprot.readStructEnd()
18172 
 
18173 
  def write(self, oprot):
18174 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
18175 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
18176 
      return
18177 
    oprot.writeStructBegin('shiftToWarehouse_result')
18178 
    if self.success is not None:
18179 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
18180 
      self.success.write(oprot)
18181 
      oprot.writeFieldEnd()
18182 
    if self.ex is not None:
18183 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
18184 
      self.ex.write(oprot)
18185 
      oprot.writeFieldEnd()
18186 
    oprot.writeFieldStop()
18187 
    oprot.writeStructEnd()
18188 
 
18189 
  def validate(self):
18190 
    return
18191 
 
18192 
 
18193 
  def __repr__(self):
18194 
    L = ['%s=%r' % (key, value)
18195 
      for key, value in self.__dict__.iteritems()]
18196 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
18197 
 
18198 
  def __eq__(self, other):
18199 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
18200 
 
18201 
  def __ne__(self, other):
18202 
    return not (self == other)
3553 chandransh 18203 
 
18204 
class addDelayReason_args:
18205 
  """
18206 
  Attributes:
18207 
   - orderId
18208 
   - delayReason
3986 chandransh 18209 
   - furtherDelay
4647 rajveer 18210 
   - delayReasonText
3553 chandransh 18211 
  """
18212 
 
18213 
  thrift_spec = (
18214 
    None, # 0
18215 
    (1, TType.I64, 'orderId', None, None, ), # 1
18216 
    (2, TType.I32, 'delayReason', None, None, ), # 2
3986 chandransh 18217 
    (3, TType.I64, 'furtherDelay', None, None, ), # 3
4647 rajveer 18218 
    (4, TType.STRING, 'delayReasonText', None, None, ), # 4
3553 chandransh 18219 
  )
18220 
 
4647 rajveer 18221 
  def __init__(self, orderId=None, delayReason=None, furtherDelay=None, delayReasonText=None,):
3553 chandransh 18222 
    self.orderId = orderId
18223 
    self.delayReason = delayReason
3986 chandransh 18224 
    self.furtherDelay = furtherDelay
4647 rajveer 18225 
    self.delayReasonText = delayReasonText
3553 chandransh 18226 
 
18227 
  def read(self, iprot):
18228 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
18229 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
18230 
      return
18231 
    iprot.readStructBegin()
18232 
    while True:
18233 
      (fname, ftype, fid) = iprot.readFieldBegin()
18234 
      if ftype == TType.STOP:
18235 
        break
18236 
      if fid == 1:
18237 
        if ftype == TType.I64:
18238 
          self.orderId = iprot.readI64();
18239 
        else:
18240 
          iprot.skip(ftype)
18241 
      elif fid == 2:
18242 
        if ftype == TType.I32:
18243 
          self.delayReason = iprot.readI32();
18244 
        else:
18245 
          iprot.skip(ftype)
3986 chandransh 18246 
      elif fid == 3:
18247 
        if ftype == TType.I64:
18248 
          self.furtherDelay = iprot.readI64();
18249 
        else:
18250 
          iprot.skip(ftype)
4647 rajveer 18251 
      elif fid == 4:
18252 
        if ftype == TType.STRING:
18253 
          self.delayReasonText = iprot.readString();
18254 
        else:
18255 
          iprot.skip(ftype)
3553 chandransh 18256 
      else:
18257 
        iprot.skip(ftype)
18258 
      iprot.readFieldEnd()
18259 
    iprot.readStructEnd()
18260 
 
18261 
  def write(self, oprot):
18262 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
18263 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
18264 
      return
18265 
    oprot.writeStructBegin('addDelayReason_args')
18266 
    if self.orderId is not None:
18267 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
18268 
      oprot.writeI64(self.orderId)
18269 
      oprot.writeFieldEnd()
18270 
    if self.delayReason is not None:
18271 
      oprot.writeFieldBegin('delayReason', TType.I32, 2)
18272 
      oprot.writeI32(self.delayReason)
18273 
      oprot.writeFieldEnd()
3986 chandransh 18274 
    if self.furtherDelay is not None:
18275 
      oprot.writeFieldBegin('furtherDelay', TType.I64, 3)
18276 
      oprot.writeI64(self.furtherDelay)
18277 
      oprot.writeFieldEnd()
4647 rajveer 18278 
    if self.delayReasonText is not None:
18279 
      oprot.writeFieldBegin('delayReasonText', TType.STRING, 4)
18280 
      oprot.writeString(self.delayReasonText)
18281 
      oprot.writeFieldEnd()
3553 chandransh 18282 
    oprot.writeFieldStop()
18283 
    oprot.writeStructEnd()
18284 
 
18285 
  def validate(self):
18286 
    return
18287 
 
18288 
 
18289 
  def __repr__(self):
18290 
    L = ['%s=%r' % (key, value)
18291 
      for key, value in self.__dict__.iteritems()]
18292 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
18293 
 
18294 
  def __eq__(self, other):
18295 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
18296 
 
18297 
  def __ne__(self, other):
18298 
    return not (self == other)
18299 
 
18300 
class addDelayReason_result:
18301 
  """
18302 
  Attributes:
18303 
   - success
18304 
   - ex
18305 
  """
18306 
 
18307 
  thrift_spec = (
18308 
    (0, TType.BOOL, 'success', None, None, ), # 0
18309 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
18310 
  )
18311 
 
18312 
  def __init__(self, success=None, ex=None,):
18313 
    self.success = success
18314 
    self.ex = ex
18315 
 
18316 
  def read(self, iprot):
18317 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
18318 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
18319 
      return
18320 
    iprot.readStructBegin()
18321 
    while True:
18322 
      (fname, ftype, fid) = iprot.readFieldBegin()
18323 
      if ftype == TType.STOP:
18324 
        break
18325 
      if fid == 0:
18326 
        if ftype == TType.BOOL:
18327 
          self.success = iprot.readBool();
18328 
        else:
18329 
          iprot.skip(ftype)
18330 
      elif fid == 1:
18331 
        if ftype == TType.STRUCT:
18332 
          self.ex = TransactionServiceException()
18333 
          self.ex.read(iprot)
18334 
        else:
18335 
          iprot.skip(ftype)
18336 
      else:
18337 
        iprot.skip(ftype)
18338 
      iprot.readFieldEnd()
18339 
    iprot.readStructEnd()
18340 
 
18341 
  def write(self, oprot):
18342 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
18343 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
18344 
      return
18345 
    oprot.writeStructBegin('addDelayReason_result')
18346 
    if self.success is not None:
18347 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
18348 
      oprot.writeBool(self.success)
18349 
      oprot.writeFieldEnd()
18350 
    if self.ex is not None:
18351 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
18352 
      self.ex.write(oprot)
18353 
      oprot.writeFieldEnd()
18354 
    oprot.writeFieldStop()
18355 
    oprot.writeStructEnd()
18356 
 
18357 
  def validate(self):
18358 
    return
18359 
 
18360 
 
18361 
  def __repr__(self):
18362 
    L = ['%s=%r' % (key, value)
18363 
      for key, value in self.__dict__.iteritems()]
18364 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
18365 
 
18366 
  def __eq__(self, other):
18367 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
18368 
 
18369 
  def __ne__(self, other):
18370 
    return not (self == other)
3956 chandransh 18371 
 
18372 
class reconcileCodCollection_args:
18373 
  """
18374 
  Attributes:
18375 
   - collectedAmountMap
18376 
   - xferBy
18377 
   - xferTxnId
18378 
   - xferDate
18379 
  """
18380 
 
18381 
  thrift_spec = (
18382 
    None, # 0
18383 
    (1, TType.MAP, 'collectedAmountMap', (TType.STRING,None,TType.DOUBLE,None), None, ), # 1
18384 
    (2, TType.STRING, 'xferBy', None, None, ), # 2
18385 
    (3, TType.STRING, 'xferTxnId', None, None, ), # 3
18386 
    (4, TType.I64, 'xferDate', None, None, ), # 4
18387 
  )
18388 
 
18389 
  def __init__(self, collectedAmountMap=None, xferBy=None, xferTxnId=None, xferDate=None,):
18390 
    self.collectedAmountMap = collectedAmountMap
18391 
    self.xferBy = xferBy
18392 
    self.xferTxnId = xferTxnId
18393 
    self.xferDate = xferDate
18394 
 
18395 
  def read(self, iprot):
18396 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
18397 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
18398 
      return
18399 
    iprot.readStructBegin()
18400 
    while True:
18401 
      (fname, ftype, fid) = iprot.readFieldBegin()
18402 
      if ftype == TType.STOP:
18403 
        break
18404 
      if fid == 1:
18405 
        if ftype == TType.MAP:
18406 
          self.collectedAmountMap = {}
5676 rajveer 18407 
          (_ktype404, _vtype405, _size403 ) = iprot.readMapBegin()
18408 
          for _i407 in xrange(_size403):
18409 
            _key408 = iprot.readString();
18410 
            _val409 = iprot.readDouble();
18411 
            self.collectedAmountMap[_key408] = _val409
3956 chandransh 18412 
          iprot.readMapEnd()
18413 
        else:
18414 
          iprot.skip(ftype)
18415 
      elif fid == 2:
18416 
        if ftype == TType.STRING:
18417 
          self.xferBy = iprot.readString();
18418 
        else:
18419 
          iprot.skip(ftype)
18420 
      elif fid == 3:
18421 
        if ftype == TType.STRING:
18422 
          self.xferTxnId = iprot.readString();
18423 
        else:
18424 
          iprot.skip(ftype)
18425 
      elif fid == 4:
18426 
        if ftype == TType.I64:
18427 
          self.xferDate = iprot.readI64();
18428 
        else:
18429 
          iprot.skip(ftype)
18430 
      else:
18431 
        iprot.skip(ftype)
18432 
      iprot.readFieldEnd()
18433 
    iprot.readStructEnd()
18434 
 
18435 
  def write(self, oprot):
18436 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
18437 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
18438 
      return
18439 
    oprot.writeStructBegin('reconcileCodCollection_args')
18440 
    if self.collectedAmountMap is not None:
18441 
      oprot.writeFieldBegin('collectedAmountMap', TType.MAP, 1)
18442 
      oprot.writeMapBegin(TType.STRING, TType.DOUBLE, len(self.collectedAmountMap))
5676 rajveer 18443 
      for kiter410,viter411 in self.collectedAmountMap.items():
18444 
        oprot.writeString(kiter410)
18445 
        oprot.writeDouble(viter411)
3956 chandransh 18446 
      oprot.writeMapEnd()
18447 
      oprot.writeFieldEnd()
18448 
    if self.xferBy is not None:
18449 
      oprot.writeFieldBegin('xferBy', TType.STRING, 2)
18450 
      oprot.writeString(self.xferBy)
18451 
      oprot.writeFieldEnd()
18452 
    if self.xferTxnId is not None:
18453 
      oprot.writeFieldBegin('xferTxnId', TType.STRING, 3)
18454 
      oprot.writeString(self.xferTxnId)
18455 
      oprot.writeFieldEnd()
18456 
    if self.xferDate is not None:
18457 
      oprot.writeFieldBegin('xferDate', TType.I64, 4)
18458 
      oprot.writeI64(self.xferDate)
18459 
      oprot.writeFieldEnd()
18460 
    oprot.writeFieldStop()
18461 
    oprot.writeStructEnd()
18462 
 
18463 
  def validate(self):
18464 
    return
18465 
 
18466 
 
18467 
  def __repr__(self):
18468 
    L = ['%s=%r' % (key, value)
18469 
      for key, value in self.__dict__.iteritems()]
18470 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
18471 
 
18472 
  def __eq__(self, other):
18473 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
18474 
 
18475 
  def __ne__(self, other):
18476 
    return not (self == other)
18477 
 
18478 
class reconcileCodCollection_result:
18479 
  """
18480 
  Attributes:
18481 
   - success
18482 
   - ex
18483 
  """
18484 
 
18485 
  thrift_spec = (
18486 
    (0, TType.MAP, 'success', (TType.STRING,None,TType.STRING,None), None, ), # 0
18487 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
18488 
  )
18489 
 
18490 
  def __init__(self, success=None, ex=None,):
18491 
    self.success = success
18492 
    self.ex = ex
18493 
 
18494 
  def read(self, iprot):
18495 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
18496 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
18497 
      return
18498 
    iprot.readStructBegin()
18499 
    while True:
18500 
      (fname, ftype, fid) = iprot.readFieldBegin()
18501 
      if ftype == TType.STOP:
18502 
        break
18503 
      if fid == 0:
18504 
        if ftype == TType.MAP:
18505 
          self.success = {}
5676 rajveer 18506 
          (_ktype413, _vtype414, _size412 ) = iprot.readMapBegin()
18507 
          for _i416 in xrange(_size412):
18508 
            _key417 = iprot.readString();
18509 
            _val418 = iprot.readString();
18510 
            self.success[_key417] = _val418
3956 chandransh 18511 
          iprot.readMapEnd()
18512 
        else:
18513 
          iprot.skip(ftype)
18514 
      elif fid == 1:
18515 
        if ftype == TType.STRUCT:
18516 
          self.ex = TransactionServiceException()
18517 
          self.ex.read(iprot)
18518 
        else:
18519 
          iprot.skip(ftype)
18520 
      else:
18521 
        iprot.skip(ftype)
18522 
      iprot.readFieldEnd()
18523 
    iprot.readStructEnd()
18524 
 
18525 
  def write(self, oprot):
18526 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
18527 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
18528 
      return
18529 
    oprot.writeStructBegin('reconcileCodCollection_result')
18530 
    if self.success is not None:
18531 
      oprot.writeFieldBegin('success', TType.MAP, 0)
18532 
      oprot.writeMapBegin(TType.STRING, TType.STRING, len(self.success))
5676 rajveer 18533 
      for kiter419,viter420 in self.success.items():
18534 
        oprot.writeString(kiter419)
18535 
        oprot.writeString(viter420)
3956 chandransh 18536 
      oprot.writeMapEnd()
18537 
      oprot.writeFieldEnd()
18538 
    if self.ex is not None:
18539 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
18540 
      self.ex.write(oprot)
18541 
      oprot.writeFieldEnd()
18542 
    oprot.writeFieldStop()
18543 
    oprot.writeStructEnd()
18544 
 
18545 
  def validate(self):
18546 
    return
18547 
 
18548 
 
18549 
  def __repr__(self):
18550 
    L = ['%s=%r' % (key, value)
18551 
      for key, value in self.__dict__.iteritems()]
18552 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
18553 
 
18554 
  def __eq__(self, other):
18555 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
18556 
 
18557 
  def __ne__(self, other):
18558 
    return not (self == other)
4008 mandeep.dh 18559 
 
18560 
class getTransactionsRequiringExtraProcessing_args:
18561 
  """
18562 
  Attributes:
18563 
   - category
18564 
  """
18565 
 
18566 
  thrift_spec = (
18567 
    None, # 0
18568 
    (1, TType.I32, 'category', None, None, ), # 1
18569 
  )
18570 
 
18571 
  def __init__(self, category=None,):
18572 
    self.category = category
18573 
 
18574 
  def read(self, iprot):
18575 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
18576 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
18577 
      return
18578 
    iprot.readStructBegin()
18579 
    while True:
18580 
      (fname, ftype, fid) = iprot.readFieldBegin()
18581 
      if ftype == TType.STOP:
18582 
        break
18583 
      if fid == 1:
18584 
        if ftype == TType.I32:
18585 
          self.category = iprot.readI32();
18586 
        else:
18587 
          iprot.skip(ftype)
18588 
      else:
18589 
        iprot.skip(ftype)
18590 
      iprot.readFieldEnd()
18591 
    iprot.readStructEnd()
18592 
 
18593 
  def write(self, oprot):
18594 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
18595 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
18596 
      return
18597 
    oprot.writeStructBegin('getTransactionsRequiringExtraProcessing_args')
18598 
    if self.category is not None:
18599 
      oprot.writeFieldBegin('category', TType.I32, 1)
18600 
      oprot.writeI32(self.category)
18601 
      oprot.writeFieldEnd()
18602 
    oprot.writeFieldStop()
18603 
    oprot.writeStructEnd()
18604 
 
18605 
  def validate(self):
18606 
    return
18607 
 
18608 
 
18609 
  def __repr__(self):
18610 
    L = ['%s=%r' % (key, value)
18611 
      for key, value in self.__dict__.iteritems()]
18612 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
18613 
 
18614 
  def __eq__(self, other):
18615 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
18616 
 
18617 
  def __ne__(self, other):
18618 
    return not (self == other)
18619 
 
18620 
class getTransactionsRequiringExtraProcessing_result:
18621 
  """
18622 
  Attributes:
18623 
   - success
18624 
  """
18625 
 
18626 
  thrift_spec = (
18627 
    (0, TType.LIST, 'success', (TType.I64,None), None, ), # 0
18628 
  )
18629 
 
18630 
  def __init__(self, success=None,):
18631 
    self.success = success
18632 
 
18633 
  def read(self, iprot):
18634 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
18635 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
18636 
      return
18637 
    iprot.readStructBegin()
18638 
    while True:
18639 
      (fname, ftype, fid) = iprot.readFieldBegin()
18640 
      if ftype == TType.STOP:
18641 
        break
18642 
      if fid == 0:
18643 
        if ftype == TType.LIST:
18644 
          self.success = []
5676 rajveer 18645 
          (_etype424, _size421) = iprot.readListBegin()
18646 
          for _i425 in xrange(_size421):
18647 
            _elem426 = iprot.readI64();
18648 
            self.success.append(_elem426)
4008 mandeep.dh 18649 
          iprot.readListEnd()
18650 
        else:
18651 
          iprot.skip(ftype)
18652 
      else:
18653 
        iprot.skip(ftype)
18654 
      iprot.readFieldEnd()
18655 
    iprot.readStructEnd()
18656 
 
18657 
  def write(self, oprot):
18658 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
18659 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
18660 
      return
18661 
    oprot.writeStructBegin('getTransactionsRequiringExtraProcessing_result')
18662 
    if self.success is not None:
18663 
      oprot.writeFieldBegin('success', TType.LIST, 0)
18664 
      oprot.writeListBegin(TType.I64, len(self.success))
5676 rajveer 18665 
      for iter427 in self.success:
18666 
        oprot.writeI64(iter427)
4008 mandeep.dh 18667 
      oprot.writeListEnd()
18668 
      oprot.writeFieldEnd()
18669 
    oprot.writeFieldStop()
18670 
    oprot.writeStructEnd()
18671 
 
18672 
  def validate(self):
18673 
    return
18674 
 
18675 
 
18676 
  def __repr__(self):
18677 
    L = ['%s=%r' % (key, value)
18678 
      for key, value in self.__dict__.iteritems()]
18679 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
18680 
 
18681 
  def __eq__(self, other):
18682 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
18683 
 
18684 
  def __ne__(self, other):
18685 
    return not (self == other)
18686 
 
18687 
class markTransactionAsProcessed_args:
18688 
  """
18689 
  Attributes:
18690 
   - transactionId
18691 
   - category
18692 
  """
18693 
 
18694 
  thrift_spec = (
18695 
    None, # 0
18696 
    (1, TType.I64, 'transactionId', None, None, ), # 1
18697 
    (2, TType.I32, 'category', None, None, ), # 2
18698 
  )
18699 
 
18700 
  def __init__(self, transactionId=None, category=None,):
18701 
    self.transactionId = transactionId
18702 
    self.category = category
18703 
 
18704 
  def read(self, iprot):
18705 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
18706 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
18707 
      return
18708 
    iprot.readStructBegin()
18709 
    while True:
18710 
      (fname, ftype, fid) = iprot.readFieldBegin()
18711 
      if ftype == TType.STOP:
18712 
        break
18713 
      if fid == 1:
18714 
        if ftype == TType.I64:
18715 
          self.transactionId = iprot.readI64();
18716 
        else:
18717 
          iprot.skip(ftype)
18718 
      elif fid == 2:
18719 
        if ftype == TType.I32:
18720 
          self.category = iprot.readI32();
18721 
        else:
18722 
          iprot.skip(ftype)
18723 
      else:
18724 
        iprot.skip(ftype)
18725 
      iprot.readFieldEnd()
18726 
    iprot.readStructEnd()
18727 
 
18728 
  def write(self, oprot):
18729 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
18730 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
18731 
      return
18732 
    oprot.writeStructBegin('markTransactionAsProcessed_args')
18733 
    if self.transactionId is not None:
18734 
      oprot.writeFieldBegin('transactionId', TType.I64, 1)
18735 
      oprot.writeI64(self.transactionId)
18736 
      oprot.writeFieldEnd()
18737 
    if self.category is not None:
18738 
      oprot.writeFieldBegin('category', TType.I32, 2)
18739 
      oprot.writeI32(self.category)
18740 
      oprot.writeFieldEnd()
18741 
    oprot.writeFieldStop()
18742 
    oprot.writeStructEnd()
18743 
 
18744 
  def validate(self):
18745 
    return
18746 
 
18747 
 
18748 
  def __repr__(self):
18749 
    L = ['%s=%r' % (key, value)
18750 
      for key, value in self.__dict__.iteritems()]
18751 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
18752 
 
18753 
  def __eq__(self, other):
18754 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
18755 
 
18756 
  def __ne__(self, other):
18757 
    return not (self == other)
18758 
 
18759 
class markTransactionAsProcessed_result:
18760 
 
18761 
  thrift_spec = (
18762 
  )
18763 
 
18764 
  def read(self, iprot):
18765 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
18766 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
18767 
      return
18768 
    iprot.readStructBegin()
18769 
    while True:
18770 
      (fname, ftype, fid) = iprot.readFieldBegin()
18771 
      if ftype == TType.STOP:
18772 
        break
18773 
      else:
18774 
        iprot.skip(ftype)
18775 
      iprot.readFieldEnd()
18776 
    iprot.readStructEnd()
18777 
 
18778 
  def write(self, oprot):
18779 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
18780 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
18781 
      return
18782 
    oprot.writeStructBegin('markTransactionAsProcessed_result')
18783 
    oprot.writeFieldStop()
18784 
    oprot.writeStructEnd()
18785 
 
18786 
  def validate(self):
18787 
    return
18788 
 
18789 
 
18790 
  def __repr__(self):
18791 
    L = ['%s=%r' % (key, value)
18792 
      for key, value in self.__dict__.iteritems()]
18793 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
18794 
 
18795 
  def __eq__(self, other):
18796 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
18797 
 
18798 
  def __ne__(self, other):
18799 
    return not (self == other)
4018 chandransh 18800 
 
18801 
class getItemWiseRiskyOrdersCount_args:
18802 
 
18803 
  thrift_spec = (
18804 
  )
18805 
 
18806 
  def read(self, iprot):
18807 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
18808 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
18809 
      return
18810 
    iprot.readStructBegin()
18811 
    while True:
18812 
      (fname, ftype, fid) = iprot.readFieldBegin()
18813 
      if ftype == TType.STOP:
18814 
        break
18815 
      else:
18816 
        iprot.skip(ftype)
18817 
      iprot.readFieldEnd()
18818 
    iprot.readStructEnd()
18819 
 
18820 
  def write(self, oprot):
18821 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
18822 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
18823 
      return
18824 
    oprot.writeStructBegin('getItemWiseRiskyOrdersCount_args')
18825 
    oprot.writeFieldStop()
18826 
    oprot.writeStructEnd()
18827 
 
18828 
  def validate(self):
18829 
    return
18830 
 
18831 
 
18832 
  def __repr__(self):
18833 
    L = ['%s=%r' % (key, value)
18834 
      for key, value in self.__dict__.iteritems()]
18835 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
18836 
 
18837 
  def __eq__(self, other):
18838 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
18839 
 
18840 
  def __ne__(self, other):
18841 
    return not (self == other)
18842 
 
18843 
class getItemWiseRiskyOrdersCount_result:
18844 
  """
18845 
  Attributes:
18846 
   - success
18847 
  """
18848 
 
18849 
  thrift_spec = (
18850 
    (0, TType.MAP, 'success', (TType.I64,None,TType.I64,None), None, ), # 0
18851 
  )
18852 
 
18853 
  def __init__(self, success=None,):
18854 
    self.success = success
18855 
 
18856 
  def read(self, iprot):
18857 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
18858 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
18859 
      return
18860 
    iprot.readStructBegin()
18861 
    while True:
18862 
      (fname, ftype, fid) = iprot.readFieldBegin()
18863 
      if ftype == TType.STOP:
18864 
        break
18865 
      if fid == 0:
18866 
        if ftype == TType.MAP:
18867 
          self.success = {}
5676 rajveer 18868 
          (_ktype429, _vtype430, _size428 ) = iprot.readMapBegin()
18869 
          for _i432 in xrange(_size428):
18870 
            _key433 = iprot.readI64();
18871 
            _val434 = iprot.readI64();
18872 
            self.success[_key433] = _val434
4018 chandransh 18873 
          iprot.readMapEnd()
18874 
        else:
18875 
          iprot.skip(ftype)
18876 
      else:
18877 
        iprot.skip(ftype)
18878 
      iprot.readFieldEnd()
18879 
    iprot.readStructEnd()
18880 
 
18881 
  def write(self, oprot):
18882 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
18883 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
18884 
      return
18885 
    oprot.writeStructBegin('getItemWiseRiskyOrdersCount_result')
18886 
    if self.success is not None:
18887 
      oprot.writeFieldBegin('success', TType.MAP, 0)
18888 
      oprot.writeMapBegin(TType.I64, TType.I64, len(self.success))
5676 rajveer 18889 
      for kiter435,viter436 in self.success.items():
18890 
        oprot.writeI64(kiter435)
18891 
        oprot.writeI64(viter436)
4018 chandransh 18892 
      oprot.writeMapEnd()
18893 
      oprot.writeFieldEnd()
18894 
    oprot.writeFieldStop()
18895 
    oprot.writeStructEnd()
18896 
 
18897 
  def validate(self):
18898 
    return
18899 
 
18900 
 
18901 
  def __repr__(self):
18902 
    L = ['%s=%r' % (key, value)
18903 
      for key, value in self.__dict__.iteritems()]
18904 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
18905 
 
18906 
  def __eq__(self, other):
18907 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
18908 
 
18909 
  def __ne__(self, other):
18910 
    return not (self == other)
4247 rajveer 18911 
 
4295 varun.gupt 18912 
class getOrdersForItemIds_args:
18913 
  """
18914 
  Attributes:
18915 
   - itemIds
18916 
  """
18917 
 
18918 
  thrift_spec = (
18919 
    None, # 0
18920 
    (1, TType.LIST, 'itemIds', (TType.I64,None), None, ), # 1
18921 
  )
18922 
 
18923 
  def __init__(self, itemIds=None,):
18924 
    self.itemIds = itemIds
18925 
 
18926 
  def read(self, iprot):
18927 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
18928 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
18929 
      return
18930 
    iprot.readStructBegin()
18931 
    while True:
18932 
      (fname, ftype, fid) = iprot.readFieldBegin()
18933 
      if ftype == TType.STOP:
18934 
        break
18935 
      if fid == 1:
18936 
        if ftype == TType.LIST:
18937 
          self.itemIds = []
5676 rajveer 18938 
          (_etype440, _size437) = iprot.readListBegin()
18939 
          for _i441 in xrange(_size437):
18940 
            _elem442 = iprot.readI64();
18941 
            self.itemIds.append(_elem442)
4295 varun.gupt 18942 
          iprot.readListEnd()
18943 
        else:
18944 
          iprot.skip(ftype)
18945 
      else:
18946 
        iprot.skip(ftype)
18947 
      iprot.readFieldEnd()
18948 
    iprot.readStructEnd()
18949 
 
18950 
  def write(self, oprot):
18951 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
18952 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
18953 
      return
18954 
    oprot.writeStructBegin('getOrdersForItemIds_args')
18955 
    if self.itemIds is not None:
18956 
      oprot.writeFieldBegin('itemIds', TType.LIST, 1)
18957 
      oprot.writeListBegin(TType.I64, len(self.itemIds))
5676 rajveer 18958 
      for iter443 in self.itemIds:
18959 
        oprot.writeI64(iter443)
4295 varun.gupt 18960 
      oprot.writeListEnd()
18961 
      oprot.writeFieldEnd()
18962 
    oprot.writeFieldStop()
18963 
    oprot.writeStructEnd()
18964 
 
18965 
  def validate(self):
18966 
    return
18967 
 
18968 
 
18969 
  def __repr__(self):
18970 
    L = ['%s=%r' % (key, value)
18971 
      for key, value in self.__dict__.iteritems()]
18972 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
18973 
 
18974 
  def __eq__(self, other):
18975 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
18976 
 
18977 
  def __ne__(self, other):
18978 
    return not (self == other)
18979 
 
18980 
class getOrdersForItemIds_result:
18981 
  """
18982 
  Attributes:
18983 
   - success
18984 
  """
18985 
 
18986 
  thrift_spec = (
18987 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
18988 
  )
18989 
 
18990 
  def __init__(self, success=None,):
18991 
    self.success = success
18992 
 
18993 
  def read(self, iprot):
18994 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
18995 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
18996 
      return
18997 
    iprot.readStructBegin()
18998 
    while True:
18999 
      (fname, ftype, fid) = iprot.readFieldBegin()
19000 
      if ftype == TType.STOP:
19001 
        break
19002 
      if fid == 0:
19003 
        if ftype == TType.LIST:
19004 
          self.success = []
5676 rajveer 19005 
          (_etype447, _size444) = iprot.readListBegin()
19006 
          for _i448 in xrange(_size444):
19007 
            _elem449 = Order()
19008 
            _elem449.read(iprot)
19009 
            self.success.append(_elem449)
4295 varun.gupt 19010 
          iprot.readListEnd()
19011 
        else:
19012 
          iprot.skip(ftype)
19013 
      else:
19014 
        iprot.skip(ftype)
19015 
      iprot.readFieldEnd()
19016 
    iprot.readStructEnd()
19017 
 
19018 
  def write(self, oprot):
19019 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
19020 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
19021 
      return
19022 
    oprot.writeStructBegin('getOrdersForItemIds_result')
19023 
    if self.success is not None:
19024 
      oprot.writeFieldBegin('success', TType.LIST, 0)
19025 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
5676 rajveer 19026 
      for iter450 in self.success:
19027 
        iter450.write(oprot)
4295 varun.gupt 19028 
      oprot.writeListEnd()
19029 
      oprot.writeFieldEnd()
19030 
    oprot.writeFieldStop()
19031 
    oprot.writeStructEnd()
19032 
 
19033 
  def validate(self):
19034 
    return
19035 
 
19036 
 
19037 
  def __repr__(self):
19038 
    L = ['%s=%r' % (key, value)
19039 
      for key, value in self.__dict__.iteritems()]
19040 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
19041 
 
19042 
  def __eq__(self, other):
19043 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
19044 
 
19045 
  def __ne__(self, other):
19046 
    return not (self == other)
19047 
 
4247 rajveer 19048 
class markOrderCancellationRequestReceived_args:
19049 
  """
19050 
  Attributes:
19051 
   - orderId
19052 
  """
19053 
 
19054 
  thrift_spec = (
19055 
    None, # 0
19056 
    (1, TType.I64, 'orderId', None, None, ), # 1
19057 
  )
19058 
 
19059 
  def __init__(self, orderId=None,):
19060 
    self.orderId = orderId
19061 
 
19062 
  def read(self, iprot):
19063 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
19064 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
19065 
      return
19066 
    iprot.readStructBegin()
19067 
    while True:
19068 
      (fname, ftype, fid) = iprot.readFieldBegin()
19069 
      if ftype == TType.STOP:
19070 
        break
19071 
      if fid == 1:
19072 
        if ftype == TType.I64:
19073 
          self.orderId = iprot.readI64();
19074 
        else:
19075 
          iprot.skip(ftype)
19076 
      else:
19077 
        iprot.skip(ftype)
19078 
      iprot.readFieldEnd()
19079 
    iprot.readStructEnd()
19080 
 
19081 
  def write(self, oprot):
19082 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
19083 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
19084 
      return
19085 
    oprot.writeStructBegin('markOrderCancellationRequestReceived_args')
19086 
    if self.orderId is not None:
19087 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
19088 
      oprot.writeI64(self.orderId)
19089 
      oprot.writeFieldEnd()
19090 
    oprot.writeFieldStop()
19091 
    oprot.writeStructEnd()
19092 
 
19093 
  def validate(self):
19094 
    return
19095 
 
19096 
 
19097 
  def __repr__(self):
19098 
    L = ['%s=%r' % (key, value)
19099 
      for key, value in self.__dict__.iteritems()]
19100 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
19101 
 
19102 
  def __eq__(self, other):
19103 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
19104 
 
19105 
  def __ne__(self, other):
19106 
    return not (self == other)
19107 
 
19108 
class markOrderCancellationRequestReceived_result:
19109 
  """
19110 
  Attributes:
19111 
   - ex
19112 
  """
19113 
 
19114 
  thrift_spec = (
19115 
    None, # 0
19116 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
19117 
  )
19118 
 
19119 
  def __init__(self, ex=None,):
19120 
    self.ex = ex
19121 
 
19122 
  def read(self, iprot):
19123 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
19124 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
19125 
      return
19126 
    iprot.readStructBegin()
19127 
    while True:
19128 
      (fname, ftype, fid) = iprot.readFieldBegin()
19129 
      if ftype == TType.STOP:
19130 
        break
19131 
      if fid == 1:
19132 
        if ftype == TType.STRUCT:
19133 
          self.ex = TransactionServiceException()
19134 
          self.ex.read(iprot)
19135 
        else:
19136 
          iprot.skip(ftype)
19137 
      else:
19138 
        iprot.skip(ftype)
19139 
      iprot.readFieldEnd()
19140 
    iprot.readStructEnd()
19141 
 
19142 
  def write(self, oprot):
19143 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
19144 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
19145 
      return
19146 
    oprot.writeStructBegin('markOrderCancellationRequestReceived_result')
19147 
    if self.ex is not None:
19148 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
19149 
      self.ex.write(oprot)
19150 
      oprot.writeFieldEnd()
19151 
    oprot.writeFieldStop()
19152 
    oprot.writeStructEnd()
19153 
 
19154 
  def validate(self):
19155 
    return
19156 
 
19157 
 
19158 
  def __repr__(self):
19159 
    L = ['%s=%r' % (key, value)
19160 
      for key, value in self.__dict__.iteritems()]
19161 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
19162 
 
19163 
  def __eq__(self, other):
19164 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
19165 
 
19166 
  def __ne__(self, other):
19167 
    return not (self == other)
19168 
 
19169 
class markOrderCancellationRequestConfirmed_args:
19170 
  """
19171 
  Attributes:
19172 
   - orderId
19173 
  """
19174 
 
19175 
  thrift_spec = (
19176 
    None, # 0
19177 
    (1, TType.I64, 'orderId', None, None, ), # 1
19178 
  )
19179 
 
19180 
  def __init__(self, orderId=None,):
19181 
    self.orderId = orderId
19182 
 
19183 
  def read(self, iprot):
19184 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
19185 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
19186 
      return
19187 
    iprot.readStructBegin()
19188 
    while True:
19189 
      (fname, ftype, fid) = iprot.readFieldBegin()
19190 
      if ftype == TType.STOP:
19191 
        break
19192 
      if fid == 1:
19193 
        if ftype == TType.I64:
19194 
          self.orderId = iprot.readI64();
19195 
        else:
19196 
          iprot.skip(ftype)
19197 
      else:
19198 
        iprot.skip(ftype)
19199 
      iprot.readFieldEnd()
19200 
    iprot.readStructEnd()
19201 
 
19202 
  def write(self, oprot):
19203 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
19204 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
19205 
      return
19206 
    oprot.writeStructBegin('markOrderCancellationRequestConfirmed_args')
19207 
    if self.orderId is not None:
19208 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
19209 
      oprot.writeI64(self.orderId)
19210 
      oprot.writeFieldEnd()
19211 
    oprot.writeFieldStop()
19212 
    oprot.writeStructEnd()
19213 
 
19214 
  def validate(self):
19215 
    return
19216 
 
19217 
 
19218 
  def __repr__(self):
19219 
    L = ['%s=%r' % (key, value)
19220 
      for key, value in self.__dict__.iteritems()]
19221 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
19222 
 
19223 
  def __eq__(self, other):
19224 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
19225 
 
19226 
  def __ne__(self, other):
19227 
    return not (self == other)
19228 
 
19229 
class markOrderCancellationRequestConfirmed_result:
19230 
  """
19231 
  Attributes:
19232 
   - ex
19233 
  """
19234 
 
19235 
  thrift_spec = (
19236 
    None, # 0
19237 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
19238 
  )
19239 
 
19240 
  def __init__(self, ex=None,):
19241 
    self.ex = ex
19242 
 
19243 
  def read(self, iprot):
19244 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
19245 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
19246 
      return
19247 
    iprot.readStructBegin()
19248 
    while True:
19249 
      (fname, ftype, fid) = iprot.readFieldBegin()
19250 
      if ftype == TType.STOP:
19251 
        break
19252 
      if fid == 1:
19253 
        if ftype == TType.STRUCT:
19254 
          self.ex = TransactionServiceException()
19255 
          self.ex.read(iprot)
19256 
        else:
19257 
          iprot.skip(ftype)
19258 
      else:
19259 
        iprot.skip(ftype)
19260 
      iprot.readFieldEnd()
19261 
    iprot.readStructEnd()
19262 
 
19263 
  def write(self, oprot):
19264 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
19265 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
19266 
      return
19267 
    oprot.writeStructBegin('markOrderCancellationRequestConfirmed_result')
19268 
    if self.ex is not None:
19269 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
19270 
      self.ex.write(oprot)
19271 
      oprot.writeFieldEnd()
19272 
    oprot.writeFieldStop()
19273 
    oprot.writeStructEnd()
19274 
 
19275 
  def validate(self):
19276 
    return
19277 
 
19278 
 
19279 
  def __repr__(self):
19280 
    L = ['%s=%r' % (key, value)
19281 
      for key, value in self.__dict__.iteritems()]
19282 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
19283 
 
19284 
  def __eq__(self, other):
19285 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
19286 
 
19287 
  def __ne__(self, other):
19288 
    return not (self == other)
19289 
 
19290 
class markOrderCancellationRequestDenied_args:
19291 
  """
19292 
  Attributes:
19293 
   - orderId
19294 
  """
19295 
 
19296 
  thrift_spec = (
19297 
    None, # 0
19298 
    (1, TType.I64, 'orderId', None, None, ), # 1
19299 
  )
19300 
 
19301 
  def __init__(self, orderId=None,):
19302 
    self.orderId = orderId
19303 
 
19304 
  def read(self, iprot):
19305 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
19306 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
19307 
      return
19308 
    iprot.readStructBegin()
19309 
    while True:
19310 
      (fname, ftype, fid) = iprot.readFieldBegin()
19311 
      if ftype == TType.STOP:
19312 
        break
19313 
      if fid == 1:
19314 
        if ftype == TType.I64:
19315 
          self.orderId = iprot.readI64();
19316 
        else:
19317 
          iprot.skip(ftype)
19318 
      else:
19319 
        iprot.skip(ftype)
19320 
      iprot.readFieldEnd()
19321 
    iprot.readStructEnd()
19322 
 
19323 
  def write(self, oprot):
19324 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
19325 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
19326 
      return
19327 
    oprot.writeStructBegin('markOrderCancellationRequestDenied_args')
19328 
    if self.orderId is not None:
19329 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
19330 
      oprot.writeI64(self.orderId)
19331 
      oprot.writeFieldEnd()
19332 
    oprot.writeFieldStop()
19333 
    oprot.writeStructEnd()
19334 
 
19335 
  def validate(self):
19336 
    return
19337 
 
19338 
 
19339 
  def __repr__(self):
19340 
    L = ['%s=%r' % (key, value)
19341 
      for key, value in self.__dict__.iteritems()]
19342 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
19343 
 
19344 
  def __eq__(self, other):
19345 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
19346 
 
19347 
  def __ne__(self, other):
19348 
    return not (self == other)
19349 
 
19350 
class markOrderCancellationRequestDenied_result:
19351 
  """
19352 
  Attributes:
19353 
   - ex
19354 
  """
19355 
 
19356 
  thrift_spec = (
19357 
    None, # 0
19358 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
19359 
  )
19360 
 
19361 
  def __init__(self, ex=None,):
19362 
    self.ex = ex
19363 
 
19364 
  def read(self, iprot):
19365 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
19366 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
19367 
      return
19368 
    iprot.readStructBegin()
19369 
    while True:
19370 
      (fname, ftype, fid) = iprot.readFieldBegin()
19371 
      if ftype == TType.STOP:
19372 
        break
19373 
      if fid == 1:
19374 
        if ftype == TType.STRUCT:
19375 
          self.ex = TransactionServiceException()
19376 
          self.ex.read(iprot)
19377 
        else:
19378 
          iprot.skip(ftype)
19379 
      else:
19380 
        iprot.skip(ftype)
19381 
      iprot.readFieldEnd()
19382 
    iprot.readStructEnd()
19383 
 
19384 
  def write(self, oprot):
19385 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
19386 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
19387 
      return
19388 
    oprot.writeStructBegin('markOrderCancellationRequestDenied_result')
19389 
    if self.ex is not None:
19390 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
19391 
      self.ex.write(oprot)
19392 
      oprot.writeFieldEnd()
19393 
    oprot.writeFieldStop()
19394 
    oprot.writeStructEnd()
19395 
 
19396 
  def validate(self):
19397 
    return
19398 
 
19399 
 
19400 
  def __repr__(self):
19401 
    L = ['%s=%r' % (key, value)
19402 
      for key, value in self.__dict__.iteritems()]
19403 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
19404 
 
19405 
  def __eq__(self, other):
19406 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
19407 
 
19408 
  def __ne__(self, other):
19409 
    return not (self == other)
19410 
 
4258 rajveer 19411 
class markTransactionAsPaymentFlagRemoved_args:
4247 rajveer 19412 
  """
19413 
  Attributes:
4258 rajveer 19414 
   - transactionId
4247 rajveer 19415 
  """
19416 
 
19417 
  thrift_spec = (
19418 
    None, # 0
4258 rajveer 19419 
    (1, TType.I64, 'transactionId', None, None, ), # 1
4247 rajveer 19420 
  )
19421 
 
4258 rajveer 19422 
  def __init__(self, transactionId=None,):
19423 
    self.transactionId = transactionId
4247 rajveer 19424 
 
19425 
  def read(self, iprot):
19426 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
19427 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
19428 
      return
19429 
    iprot.readStructBegin()
19430 
    while True:
19431 
      (fname, ftype, fid) = iprot.readFieldBegin()
19432 
      if ftype == TType.STOP:
19433 
        break
19434 
      if fid == 1:
19435 
        if ftype == TType.I64:
4258 rajveer 19436 
          self.transactionId = iprot.readI64();
4247 rajveer 19437 
        else:
19438 
          iprot.skip(ftype)
19439 
      else:
19440 
        iprot.skip(ftype)
19441 
      iprot.readFieldEnd()
19442 
    iprot.readStructEnd()
19443 
 
19444 
  def write(self, oprot):
19445 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
19446 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
19447 
      return
4258 rajveer 19448 
    oprot.writeStructBegin('markTransactionAsPaymentFlagRemoved_args')
19449 
    if self.transactionId is not None:
19450 
      oprot.writeFieldBegin('transactionId', TType.I64, 1)
19451 
      oprot.writeI64(self.transactionId)
4247 rajveer 19452 
      oprot.writeFieldEnd()
19453 
    oprot.writeFieldStop()
19454 
    oprot.writeStructEnd()
19455 
 
19456 
  def validate(self):
19457 
    return
19458 
 
19459 
 
19460 
  def __repr__(self):
19461 
    L = ['%s=%r' % (key, value)
19462 
      for key, value in self.__dict__.iteritems()]
19463 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
19464 
 
19465 
  def __eq__(self, other):
19466 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
19467 
 
19468 
  def __ne__(self, other):
19469 
    return not (self == other)
19470 
 
4258 rajveer 19471 
class markTransactionAsPaymentFlagRemoved_result:
4247 rajveer 19472 
  """
19473 
  Attributes:
19474 
   - ex
19475 
  """
19476 
 
19477 
  thrift_spec = (
19478 
    None, # 0
19479 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
19480 
  )
19481 
 
19482 
  def __init__(self, ex=None,):
19483 
    self.ex = ex
19484 
 
19485 
  def read(self, iprot):
19486 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
19487 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
19488 
      return
19489 
    iprot.readStructBegin()
19490 
    while True:
19491 
      (fname, ftype, fid) = iprot.readFieldBegin()
19492 
      if ftype == TType.STOP:
19493 
        break
19494 
      if fid == 1:
19495 
        if ftype == TType.STRUCT:
19496 
          self.ex = TransactionServiceException()
19497 
          self.ex.read(iprot)
19498 
        else:
19499 
          iprot.skip(ftype)
19500 
      else:
19501 
        iprot.skip(ftype)
19502 
      iprot.readFieldEnd()
19503 
    iprot.readStructEnd()
19504 
 
19505 
  def write(self, oprot):
19506 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
19507 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
19508 
      return
4258 rajveer 19509 
    oprot.writeStructBegin('markTransactionAsPaymentFlagRemoved_result')
4247 rajveer 19510 
    if self.ex is not None:
19511 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
19512 
      self.ex.write(oprot)
19513 
      oprot.writeFieldEnd()
19514 
    oprot.writeFieldStop()
19515 
    oprot.writeStructEnd()
19516 
 
19517 
  def validate(self):
19518 
    return
19519 
 
19520 
 
19521 
  def __repr__(self):
19522 
    L = ['%s=%r' % (key, value)
19523 
      for key, value in self.__dict__.iteritems()]
19524 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
19525 
 
19526 
  def __eq__(self, other):
19527 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
19528 
 
19529 
  def __ne__(self, other):
19530 
    return not (self == other)
4259 anupam.sin 19531 
 
19532 
class refundTransaction_args:
19533 
  """
19534 
  Attributes:
19535 
   - transactionId
19536 
   - refundedBy
19537 
   - reason
19538 
  """
19539 
 
19540 
  thrift_spec = (
19541 
    None, # 0
19542 
    (1, TType.I64, 'transactionId', None, None, ), # 1
19543 
    (2, TType.STRING, 'refundedBy', None, None, ), # 2
19544 
    (3, TType.STRING, 'reason', None, None, ), # 3
19545 
  )
19546 
 
19547 
  def __init__(self, transactionId=None, refundedBy=None, reason=None,):
19548 
    self.transactionId = transactionId
19549 
    self.refundedBy = refundedBy
19550 
    self.reason = reason
19551 
 
19552 
  def read(self, iprot):
19553 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
19554 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
19555 
      return
19556 
    iprot.readStructBegin()
19557 
    while True:
19558 
      (fname, ftype, fid) = iprot.readFieldBegin()
19559 
      if ftype == TType.STOP:
19560 
        break
19561 
      if fid == 1:
19562 
        if ftype == TType.I64:
19563 
          self.transactionId = iprot.readI64();
19564 
        else:
19565 
          iprot.skip(ftype)
19566 
      elif fid == 2:
19567 
        if ftype == TType.STRING:
19568 
          self.refundedBy = iprot.readString();
19569 
        else:
19570 
          iprot.skip(ftype)
19571 
      elif fid == 3:
19572 
        if ftype == TType.STRING:
19573 
          self.reason = iprot.readString();
19574 
        else:
19575 
          iprot.skip(ftype)
19576 
      else:
19577 
        iprot.skip(ftype)
19578 
      iprot.readFieldEnd()
19579 
    iprot.readStructEnd()
19580 
 
19581 
  def write(self, oprot):
19582 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
19583 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
19584 
      return
19585 
    oprot.writeStructBegin('refundTransaction_args')
19586 
    if self.transactionId is not None:
19587 
      oprot.writeFieldBegin('transactionId', TType.I64, 1)
19588 
      oprot.writeI64(self.transactionId)
19589 
      oprot.writeFieldEnd()
19590 
    if self.refundedBy is not None:
19591 
      oprot.writeFieldBegin('refundedBy', TType.STRING, 2)
19592 
      oprot.writeString(self.refundedBy)
19593 
      oprot.writeFieldEnd()
19594 
    if self.reason is not None:
19595 
      oprot.writeFieldBegin('reason', TType.STRING, 3)
19596 
      oprot.writeString(self.reason)
19597 
      oprot.writeFieldEnd()
19598 
    oprot.writeFieldStop()
19599 
    oprot.writeStructEnd()
19600 
 
19601 
  def validate(self):
19602 
    return
19603 
 
19604 
 
19605 
  def __repr__(self):
19606 
    L = ['%s=%r' % (key, value)
19607 
      for key, value in self.__dict__.iteritems()]
19608 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
19609 
 
19610 
  def __eq__(self, other):
19611 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
19612 
 
19613 
  def __ne__(self, other):
19614 
    return not (self == other)
19615 
 
19616 
class refundTransaction_result:
19617 
  """
19618 
  Attributes:
19619 
   - ex
19620 
  """
19621 
 
19622 
  thrift_spec = (
19623 
    None, # 0
19624 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
19625 
  )
19626 
 
19627 
  def __init__(self, ex=None,):
19628 
    self.ex = ex
19629 
 
19630 
  def read(self, iprot):
19631 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
19632 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
19633 
      return
19634 
    iprot.readStructBegin()
19635 
    while True:
19636 
      (fname, ftype, fid) = iprot.readFieldBegin()
19637 
      if ftype == TType.STOP:
19638 
        break
19639 
      if fid == 1:
19640 
        if ftype == TType.STRUCT:
19641 
          self.ex = TransactionServiceException()
19642 
          self.ex.read(iprot)
19643 
        else:
19644 
          iprot.skip(ftype)
19645 
      else:
19646 
        iprot.skip(ftype)
19647 
      iprot.readFieldEnd()
19648 
    iprot.readStructEnd()
19649 
 
19650 
  def write(self, oprot):
19651 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
19652 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
19653 
      return
19654 
    oprot.writeStructBegin('refundTransaction_result')
19655 
    if self.ex is not None:
19656 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
19657 
      self.ex.write(oprot)
19658 
      oprot.writeFieldEnd()
19659 
    oprot.writeFieldStop()
19660 
    oprot.writeStructEnd()
19661 
 
19662 
  def validate(self):
19663 
    return
19664 
 
19665 
 
19666 
  def __repr__(self):
19667 
    L = ['%s=%r' % (key, value)
19668 
      for key, value in self.__dict__.iteritems()]
19669 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
19670 
 
19671 
  def __eq__(self, other):
19672 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
19673 
 
19674 
  def __ne__(self, other):
19675 
    return not (self == other)
4285 rajveer 19676 
 
4324 mandeep.dh 19677 
class updateShipmentAddress_args:
19678 
  """
19679 
  Attributes:
19680 
   - orderId
19681 
   - addressId
19682 
  """
19683 
 
19684 
  thrift_spec = (
19685 
    None, # 0
19686 
    (1, TType.I64, 'orderId', None, None, ), # 1
19687 
    (2, TType.I64, 'addressId', None, None, ), # 2
19688 
  )
19689 
 
19690 
  def __init__(self, orderId=None, addressId=None,):
19691 
    self.orderId = orderId
19692 
    self.addressId = addressId
19693 
 
19694 
  def read(self, iprot):
19695 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
19696 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
19697 
      return
19698 
    iprot.readStructBegin()
19699 
    while True:
19700 
      (fname, ftype, fid) = iprot.readFieldBegin()
19701 
      if ftype == TType.STOP:
19702 
        break
19703 
      if fid == 1:
19704 
        if ftype == TType.I64:
19705 
          self.orderId = iprot.readI64();
19706 
        else:
19707 
          iprot.skip(ftype)
19708 
      elif fid == 2:
19709 
        if ftype == TType.I64:
19710 
          self.addressId = iprot.readI64();
19711 
        else:
19712 
          iprot.skip(ftype)
19713 
      else:
19714 
        iprot.skip(ftype)
19715 
      iprot.readFieldEnd()
19716 
    iprot.readStructEnd()
19717 
 
19718 
  def write(self, oprot):
19719 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
19720 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
19721 
      return
19722 
    oprot.writeStructBegin('updateShipmentAddress_args')
19723 
    if self.orderId is not None:
19724 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
19725 
      oprot.writeI64(self.orderId)
19726 
      oprot.writeFieldEnd()
19727 
    if self.addressId is not None:
19728 
      oprot.writeFieldBegin('addressId', TType.I64, 2)
19729 
      oprot.writeI64(self.addressId)
19730 
      oprot.writeFieldEnd()
19731 
    oprot.writeFieldStop()
19732 
    oprot.writeStructEnd()
19733 
 
19734 
  def validate(self):
19735 
    return
19736 
 
19737 
 
19738 
  def __repr__(self):
19739 
    L = ['%s=%r' % (key, value)
19740 
      for key, value in self.__dict__.iteritems()]
19741 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
19742 
 
19743 
  def __eq__(self, other):
19744 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
19745 
 
19746 
  def __ne__(self, other):
19747 
    return not (self == other)
19748 
 
19749 
class updateShipmentAddress_result:
19750 
  """
19751 
  Attributes:
19752 
   - ex
19753 
  """
19754 
 
19755 
  thrift_spec = (
19756 
    None, # 0
19757 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
19758 
  )
19759 
 
19760 
  def __init__(self, ex=None,):
19761 
    self.ex = ex
19762 
 
19763 
  def read(self, iprot):
19764 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
19765 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
19766 
      return
19767 
    iprot.readStructBegin()
19768 
    while True:
19769 
      (fname, ftype, fid) = iprot.readFieldBegin()
19770 
      if ftype == TType.STOP:
19771 
        break
19772 
      if fid == 1:
19773 
        if ftype == TType.STRUCT:
19774 
          self.ex = TransactionServiceException()
19775 
          self.ex.read(iprot)
19776 
        else:
19777 
          iprot.skip(ftype)
19778 
      else:
19779 
        iprot.skip(ftype)
19780 
      iprot.readFieldEnd()
19781 
    iprot.readStructEnd()
19782 
 
19783 
  def write(self, oprot):
19784 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
19785 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
19786 
      return
19787 
    oprot.writeStructBegin('updateShipmentAddress_result')
19788 
    if self.ex is not None:
19789 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
19790 
      self.ex.write(oprot)
19791 
      oprot.writeFieldEnd()
19792 
    oprot.writeFieldStop()
19793 
    oprot.writeStructEnd()
19794 
 
19795 
  def validate(self):
19796 
    return
19797 
 
19798 
 
19799 
  def __repr__(self):
19800 
    L = ['%s=%r' % (key, value)
19801 
      for key, value in self.__dict__.iteritems()]
19802 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
19803 
 
19804 
  def __eq__(self, other):
19805 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
19806 
 
19807 
  def __ne__(self, other):
19808 
    return not (self == other)
19809 
 
4285 rajveer 19810 
class acceptOrdersForItemId_args:
19811 
  """
19812 
  Attributes:
19813 
   - itemId
19814 
   - inventory
19815 
  """
19816 
 
19817 
  thrift_spec = (
19818 
    None, # 0
19819 
    (1, TType.I64, 'itemId', None, None, ), # 1
19820 
    (2, TType.I64, 'inventory', None, None, ), # 2
19821 
  )
19822 
 
19823 
  def __init__(self, itemId=None, inventory=None,):
19824 
    self.itemId = itemId
19825 
    self.inventory = inventory
19826 
 
19827 
  def read(self, iprot):
19828 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
19829 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
19830 
      return
19831 
    iprot.readStructBegin()
19832 
    while True:
19833 
      (fname, ftype, fid) = iprot.readFieldBegin()
19834 
      if ftype == TType.STOP:
19835 
        break
19836 
      if fid == 1:
19837 
        if ftype == TType.I64:
19838 
          self.itemId = iprot.readI64();
19839 
        else:
19840 
          iprot.skip(ftype)
19841 
      elif fid == 2:
19842 
        if ftype == TType.I64:
19843 
          self.inventory = iprot.readI64();
19844 
        else:
19845 
          iprot.skip(ftype)
19846 
      else:
19847 
        iprot.skip(ftype)
19848 
      iprot.readFieldEnd()
19849 
    iprot.readStructEnd()
19850 
 
19851 
  def write(self, oprot):
19852 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
19853 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
19854 
      return
19855 
    oprot.writeStructBegin('acceptOrdersForItemId_args')
19856 
    if self.itemId is not None:
19857 
      oprot.writeFieldBegin('itemId', TType.I64, 1)
19858 
      oprot.writeI64(self.itemId)
19859 
      oprot.writeFieldEnd()
19860 
    if self.inventory is not None:
19861 
      oprot.writeFieldBegin('inventory', TType.I64, 2)
19862 
      oprot.writeI64(self.inventory)
19863 
      oprot.writeFieldEnd()
19864 
    oprot.writeFieldStop()
19865 
    oprot.writeStructEnd()
19866 
 
19867 
  def validate(self):
19868 
    return
19869 
 
19870 
 
19871 
  def __repr__(self):
19872 
    L = ['%s=%r' % (key, value)
19873 
      for key, value in self.__dict__.iteritems()]
19874 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
19875 
 
19876 
  def __eq__(self, other):
19877 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
19878 
 
19879 
  def __ne__(self, other):
19880 
    return not (self == other)
19881 
 
19882 
class acceptOrdersForItemId_result:
19883 
  """
19884 
  Attributes:
19885 
   - success
19886 
   - ex
19887 
  """
19888 
 
19889 
  thrift_spec = (
19890 
    (0, TType.BOOL, 'success', None, None, ), # 0
19891 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
19892 
  )
19893 
 
19894 
  def __init__(self, success=None, ex=None,):
19895 
    self.success = success
19896 
    self.ex = ex
19897 
 
19898 
  def read(self, iprot):
19899 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
19900 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
19901 
      return
19902 
    iprot.readStructBegin()
19903 
    while True:
19904 
      (fname, ftype, fid) = iprot.readFieldBegin()
19905 
      if ftype == TType.STOP:
19906 
        break
19907 
      if fid == 0:
19908 
        if ftype == TType.BOOL:
19909 
          self.success = iprot.readBool();
19910 
        else:
19911 
          iprot.skip(ftype)
19912 
      elif fid == 1:
19913 
        if ftype == TType.STRUCT:
19914 
          self.ex = TransactionServiceException()
19915 
          self.ex.read(iprot)
19916 
        else:
19917 
          iprot.skip(ftype)
19918 
      else:
19919 
        iprot.skip(ftype)
19920 
      iprot.readFieldEnd()
19921 
    iprot.readStructEnd()
19922 
 
19923 
  def write(self, oprot):
19924 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
19925 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
19926 
      return
19927 
    oprot.writeStructBegin('acceptOrdersForItemId_result')
19928 
    if self.success is not None:
19929 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
19930 
      oprot.writeBool(self.success)
19931 
      oprot.writeFieldEnd()
19932 
    if self.ex is not None:
19933 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
19934 
      self.ex.write(oprot)
19935 
      oprot.writeFieldEnd()
19936 
    oprot.writeFieldStop()
19937 
    oprot.writeStructEnd()
19938 
 
19939 
  def validate(self):
19940 
    return
19941 
 
19942 
 
19943 
  def __repr__(self):
19944 
    L = ['%s=%r' % (key, value)
19945 
      for key, value in self.__dict__.iteritems()]
19946 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
19947 
 
19948 
  def __eq__(self, other):
19949 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
19950 
 
19951 
  def __ne__(self, other):
19952 
    return not (self == other)
4303 rajveer 19953 
 
19954 
class markOrdersAsPORaised_args:
19955 
  """
19956 
  Attributes:
19957 
   - vendorId
19958 
   - itemId
19959 
   - quantity
19960 
   - estimate
4369 rajveer 19961 
   - isReminder
4303 rajveer 19962 
  """
19963 
 
19964 
  thrift_spec = (
19965 
    None, # 0
19966 
    (1, TType.I64, 'vendorId', None, None, ), # 1
19967 
    (2, TType.I64, 'itemId', None, None, ), # 2
19968 
    (3, TType.I64, 'quantity', None, None, ), # 3
19969 
    (4, TType.I64, 'estimate', None, None, ), # 4
4369 rajveer 19970 
    (5, TType.BOOL, 'isReminder', None, None, ), # 5
4303 rajveer 19971 
  )
19972 
 
4369 rajveer 19973 
  def __init__(self, vendorId=None, itemId=None, quantity=None, estimate=None, isReminder=None,):
4303 rajveer 19974 
    self.vendorId = vendorId
19975 
    self.itemId = itemId
19976 
    self.quantity = quantity
19977 
    self.estimate = estimate
4369 rajveer 19978 
    self.isReminder = isReminder
4303 rajveer 19979 
 
19980 
  def read(self, iprot):
19981 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
19982 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
19983 
      return
19984 
    iprot.readStructBegin()
19985 
    while True:
19986 
      (fname, ftype, fid) = iprot.readFieldBegin()
19987 
      if ftype == TType.STOP:
19988 
        break
19989 
      if fid == 1:
19990 
        if ftype == TType.I64:
19991 
          self.vendorId = iprot.readI64();
19992 
        else:
19993 
          iprot.skip(ftype)
19994 
      elif fid == 2:
19995 
        if ftype == TType.I64:
19996 
          self.itemId = iprot.readI64();
19997 
        else:
19998 
          iprot.skip(ftype)
19999 
      elif fid == 3:
20000 
        if ftype == TType.I64:
20001 
          self.quantity = iprot.readI64();
20002 
        else:
20003 
          iprot.skip(ftype)
20004 
      elif fid == 4:
20005 
        if ftype == TType.I64:
20006 
          self.estimate = iprot.readI64();
20007 
        else:
20008 
          iprot.skip(ftype)
4369 rajveer 20009 
      elif fid == 5:
20010 
        if ftype == TType.BOOL:
20011 
          self.isReminder = iprot.readBool();
20012 
        else:
20013 
          iprot.skip(ftype)
4303 rajveer 20014 
      else:
20015 
        iprot.skip(ftype)
20016 
      iprot.readFieldEnd()
20017 
    iprot.readStructEnd()
20018 
 
20019 
  def write(self, oprot):
20020 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
20021 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
20022 
      return
20023 
    oprot.writeStructBegin('markOrdersAsPORaised_args')
20024 
    if self.vendorId is not None:
20025 
      oprot.writeFieldBegin('vendorId', TType.I64, 1)
20026 
      oprot.writeI64(self.vendorId)
20027 
      oprot.writeFieldEnd()
20028 
    if self.itemId is not None:
20029 
      oprot.writeFieldBegin('itemId', TType.I64, 2)
20030 
      oprot.writeI64(self.itemId)
20031 
      oprot.writeFieldEnd()
20032 
    if self.quantity is not None:
20033 
      oprot.writeFieldBegin('quantity', TType.I64, 3)
20034 
      oprot.writeI64(self.quantity)
20035 
      oprot.writeFieldEnd()
20036 
    if self.estimate is not None:
20037 
      oprot.writeFieldBegin('estimate', TType.I64, 4)
20038 
      oprot.writeI64(self.estimate)
20039 
      oprot.writeFieldEnd()
4369 rajveer 20040 
    if self.isReminder is not None:
20041 
      oprot.writeFieldBegin('isReminder', TType.BOOL, 5)
20042 
      oprot.writeBool(self.isReminder)
20043 
      oprot.writeFieldEnd()
4303 rajveer 20044 
    oprot.writeFieldStop()
20045 
    oprot.writeStructEnd()
20046 
 
20047 
  def validate(self):
20048 
    return
20049 
 
20050 
 
20051 
  def __repr__(self):
20052 
    L = ['%s=%r' % (key, value)
20053 
      for key, value in self.__dict__.iteritems()]
20054 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
20055 
 
20056 
  def __eq__(self, other):
20057 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
20058 
 
20059 
  def __ne__(self, other):
20060 
    return not (self == other)
20061 
 
20062 
class markOrdersAsPORaised_result:
20063 
  """
20064 
  Attributes:
20065 
   - ex
20066 
  """
20067 
 
20068 
  thrift_spec = (
20069 
    None, # 0
20070 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
20071 
  )
20072 
 
20073 
  def __init__(self, ex=None,):
20074 
    self.ex = ex
20075 
 
20076 
  def read(self, iprot):
20077 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
20078 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
20079 
      return
20080 
    iprot.readStructBegin()
20081 
    while True:
20082 
      (fname, ftype, fid) = iprot.readFieldBegin()
20083 
      if ftype == TType.STOP:
20084 
        break
20085 
      if fid == 1:
20086 
        if ftype == TType.STRUCT:
20087 
          self.ex = TransactionServiceException()
20088 
          self.ex.read(iprot)
20089 
        else:
20090 
          iprot.skip(ftype)
20091 
      else:
20092 
        iprot.skip(ftype)
20093 
      iprot.readFieldEnd()
20094 
    iprot.readStructEnd()
20095 
 
20096 
  def write(self, oprot):
20097 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
20098 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
20099 
      return
20100 
    oprot.writeStructBegin('markOrdersAsPORaised_result')
20101 
    if self.ex is not None:
20102 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
20103 
      self.ex.write(oprot)
20104 
      oprot.writeFieldEnd()
20105 
    oprot.writeFieldStop()
20106 
    oprot.writeStructEnd()
20107 
 
20108 
  def validate(self):
20109 
    return
20110 
 
20111 
 
20112 
  def __repr__(self):
20113 
    L = ['%s=%r' % (key, value)
20114 
      for key, value in self.__dict__.iteritems()]
20115 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
20116 
 
20117 
  def __eq__(self, other):
20118 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
20119 
 
20120 
  def __ne__(self, other):
20121 
    return not (self == other)
20122 
 
20123 
class markOrdersAsReversalInitiated_args:
20124 
  """
20125 
  Attributes:
20126 
   - vendorId
20127 
   - itemId
20128 
   - quantity
20129 
   - estimate
4369 rajveer 20130 
   - isReminder
4303 rajveer 20131 
  """
20132 
 
20133 
  thrift_spec = (
20134 
    None, # 0
20135 
    (1, TType.I64, 'vendorId', None, None, ), # 1
20136 
    (2, TType.I64, 'itemId', None, None, ), # 2
20137 
    (3, TType.I64, 'quantity', None, None, ), # 3
20138 
    (4, TType.I64, 'estimate', None, None, ), # 4
4369 rajveer 20139 
    (5, TType.BOOL, 'isReminder', None, None, ), # 5
4303 rajveer 20140 
  )
20141 
 
4369 rajveer 20142 
  def __init__(self, vendorId=None, itemId=None, quantity=None, estimate=None, isReminder=None,):
4303 rajveer 20143 
    self.vendorId = vendorId
20144 
    self.itemId = itemId
20145 
    self.quantity = quantity
20146 
    self.estimate = estimate
4369 rajveer 20147 
    self.isReminder = isReminder
4303 rajveer 20148 
 
20149 
  def read(self, iprot):
20150 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
20151 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
20152 
      return
20153 
    iprot.readStructBegin()
20154 
    while True:
20155 
      (fname, ftype, fid) = iprot.readFieldBegin()
20156 
      if ftype == TType.STOP:
20157 
        break
20158 
      if fid == 1:
20159 
        if ftype == TType.I64:
20160 
          self.vendorId = iprot.readI64();
20161 
        else:
20162 
          iprot.skip(ftype)
20163 
      elif fid == 2:
20164 
        if ftype == TType.I64:
20165 
          self.itemId = iprot.readI64();
20166 
        else:
20167 
          iprot.skip(ftype)
20168 
      elif fid == 3:
20169 
        if ftype == TType.I64:
20170 
          self.quantity = iprot.readI64();
20171 
        else:
20172 
          iprot.skip(ftype)
20173 
      elif fid == 4:
20174 
        if ftype == TType.I64:
20175 
          self.estimate = iprot.readI64();
20176 
        else:
20177 
          iprot.skip(ftype)
4369 rajveer 20178 
      elif fid == 5:
20179 
        if ftype == TType.BOOL:
20180 
          self.isReminder = iprot.readBool();
20181 
        else:
20182 
          iprot.skip(ftype)
4303 rajveer 20183 
      else:
20184 
        iprot.skip(ftype)
20185 
      iprot.readFieldEnd()
20186 
    iprot.readStructEnd()
20187 
 
20188 
  def write(self, oprot):
20189 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
20190 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
20191 
      return
20192 
    oprot.writeStructBegin('markOrdersAsReversalInitiated_args')
20193 
    if self.vendorId is not None:
20194 
      oprot.writeFieldBegin('vendorId', TType.I64, 1)
20195 
      oprot.writeI64(self.vendorId)
20196 
      oprot.writeFieldEnd()
20197 
    if self.itemId is not None:
20198 
      oprot.writeFieldBegin('itemId', TType.I64, 2)
20199 
      oprot.writeI64(self.itemId)
20200 
      oprot.writeFieldEnd()
20201 
    if self.quantity is not None:
20202 
      oprot.writeFieldBegin('quantity', TType.I64, 3)
20203 
      oprot.writeI64(self.quantity)
20204 
      oprot.writeFieldEnd()
20205 
    if self.estimate is not None:
20206 
      oprot.writeFieldBegin('estimate', TType.I64, 4)
20207 
      oprot.writeI64(self.estimate)
20208 
      oprot.writeFieldEnd()
4369 rajveer 20209 
    if self.isReminder is not None:
20210 
      oprot.writeFieldBegin('isReminder', TType.BOOL, 5)
20211 
      oprot.writeBool(self.isReminder)
20212 
      oprot.writeFieldEnd()
4303 rajveer 20213 
    oprot.writeFieldStop()
20214 
    oprot.writeStructEnd()
20215 
 
20216 
  def validate(self):
20217 
    return
20218 
 
20219 
 
20220 
  def __repr__(self):
20221 
    L = ['%s=%r' % (key, value)
20222 
      for key, value in self.__dict__.iteritems()]
20223 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
20224 
 
20225 
  def __eq__(self, other):
20226 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
20227 
 
20228 
  def __ne__(self, other):
20229 
    return not (self == other)
20230 
 
20231 
class markOrdersAsReversalInitiated_result:
20232 
  """
20233 
  Attributes:
20234 
   - ex
20235 
  """
20236 
 
20237 
  thrift_spec = (
20238 
    None, # 0
20239 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
20240 
  )
20241 
 
20242 
  def __init__(self, ex=None,):
20243 
    self.ex = ex
20244 
 
20245 
  def read(self, iprot):
20246 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
20247 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
20248 
      return
20249 
    iprot.readStructBegin()
20250 
    while True:
20251 
      (fname, ftype, fid) = iprot.readFieldBegin()
20252 
      if ftype == TType.STOP:
20253 
        break
20254 
      if fid == 1:
20255 
        if ftype == TType.STRUCT:
20256 
          self.ex = TransactionServiceException()
20257 
          self.ex.read(iprot)
20258 
        else:
20259 
          iprot.skip(ftype)
20260 
      else:
20261 
        iprot.skip(ftype)
20262 
      iprot.readFieldEnd()
20263 
    iprot.readStructEnd()
20264 
 
20265 
  def write(self, oprot):
20266 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
20267 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
20268 
      return
20269 
    oprot.writeStructBegin('markOrdersAsReversalInitiated_result')
20270 
    if self.ex is not None:
20271 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
20272 
      self.ex.write(oprot)
20273 
      oprot.writeFieldEnd()
20274 
    oprot.writeFieldStop()
20275 
    oprot.writeStructEnd()
20276 
 
20277 
  def validate(self):
20278 
    return
20279 
 
20280 
 
20281 
  def __repr__(self):
20282 
    L = ['%s=%r' % (key, value)
20283 
      for key, value in self.__dict__.iteritems()]
20284 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
20285 
 
20286 
  def __eq__(self, other):
20287 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
20288 
 
20289 
  def __ne__(self, other):
20290 
    return not (self == other)
20291 
 
20292 
class markOrdersAsNotAvailabke_args:
20293 
  """
20294 
  Attributes:
20295 
   - vendorId
20296 
   - itemId
20297 
   - quantity
20298 
   - estimate
4369 rajveer 20299 
   - isReminder
4303 rajveer 20300 
  """
20301 
 
20302 
  thrift_spec = (
20303 
    None, # 0
20304 
    (1, TType.I64, 'vendorId', None, None, ), # 1
20305 
    (2, TType.I64, 'itemId', None, None, ), # 2
20306 
    (3, TType.I64, 'quantity', None, None, ), # 3
20307 
    (4, TType.I64, 'estimate', None, None, ), # 4
4369 rajveer 20308 
    (5, TType.BOOL, 'isReminder', None, None, ), # 5
4303 rajveer 20309 
  )
20310 
 
4369 rajveer 20311 
  def __init__(self, vendorId=None, itemId=None, quantity=None, estimate=None, isReminder=None,):
4303 rajveer 20312 
    self.vendorId = vendorId
20313 
    self.itemId = itemId
20314 
    self.quantity = quantity
20315 
    self.estimate = estimate
4369 rajveer 20316 
    self.isReminder = isReminder
4303 rajveer 20317 
 
20318 
  def read(self, iprot):
20319 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
20320 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
20321 
      return
20322 
    iprot.readStructBegin()
20323 
    while True:
20324 
      (fname, ftype, fid) = iprot.readFieldBegin()
20325 
      if ftype == TType.STOP:
20326 
        break
20327 
      if fid == 1:
20328 
        if ftype == TType.I64:
20329 
          self.vendorId = iprot.readI64();
20330 
        else:
20331 
          iprot.skip(ftype)
20332 
      elif fid == 2:
20333 
        if ftype == TType.I64:
20334 
          self.itemId = iprot.readI64();
20335 
        else:
20336 
          iprot.skip(ftype)
20337 
      elif fid == 3:
20338 
        if ftype == TType.I64:
20339 
          self.quantity = iprot.readI64();
20340 
        else:
20341 
          iprot.skip(ftype)
20342 
      elif fid == 4:
20343 
        if ftype == TType.I64:
20344 
          self.estimate = iprot.readI64();
20345 
        else:
20346 
          iprot.skip(ftype)
4369 rajveer 20347 
      elif fid == 5:
20348 
        if ftype == TType.BOOL:
20349 
          self.isReminder = iprot.readBool();
20350 
        else:
20351 
          iprot.skip(ftype)
4303 rajveer 20352 
      else:
20353 
        iprot.skip(ftype)
20354 
      iprot.readFieldEnd()
20355 
    iprot.readStructEnd()
20356 
 
20357 
  def write(self, oprot):
20358 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
20359 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
20360 
      return
20361 
    oprot.writeStructBegin('markOrdersAsNotAvailabke_args')
20362 
    if self.vendorId is not None:
20363 
      oprot.writeFieldBegin('vendorId', TType.I64, 1)
20364 
      oprot.writeI64(self.vendorId)
20365 
      oprot.writeFieldEnd()
20366 
    if self.itemId is not None:
20367 
      oprot.writeFieldBegin('itemId', TType.I64, 2)
20368 
      oprot.writeI64(self.itemId)
20369 
      oprot.writeFieldEnd()
20370 
    if self.quantity is not None:
20371 
      oprot.writeFieldBegin('quantity', TType.I64, 3)
20372 
      oprot.writeI64(self.quantity)
20373 
      oprot.writeFieldEnd()
20374 
    if self.estimate is not None:
20375 
      oprot.writeFieldBegin('estimate', TType.I64, 4)
20376 
      oprot.writeI64(self.estimate)
20377 
      oprot.writeFieldEnd()
4369 rajveer 20378 
    if self.isReminder is not None:
20379 
      oprot.writeFieldBegin('isReminder', TType.BOOL, 5)
20380 
      oprot.writeBool(self.isReminder)
20381 
      oprot.writeFieldEnd()
4303 rajveer 20382 
    oprot.writeFieldStop()
20383 
    oprot.writeStructEnd()
20384 
 
20385 
  def validate(self):
20386 
    return
20387 
 
20388 
 
20389 
  def __repr__(self):
20390 
    L = ['%s=%r' % (key, value)
20391 
      for key, value in self.__dict__.iteritems()]
20392 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
20393 
 
20394 
  def __eq__(self, other):
20395 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
20396 
 
20397 
  def __ne__(self, other):
20398 
    return not (self == other)
20399 
 
20400 
class markOrdersAsNotAvailabke_result:
20401 
  """
20402 
  Attributes:
20403 
   - ex
20404 
  """
20405 
 
20406 
  thrift_spec = (
20407 
    None, # 0
20408 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
20409 
  )
20410 
 
20411 
  def __init__(self, ex=None,):
20412 
    self.ex = ex
20413 
 
20414 
  def read(self, iprot):
20415 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
20416 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
20417 
      return
20418 
    iprot.readStructBegin()
20419 
    while True:
20420 
      (fname, ftype, fid) = iprot.readFieldBegin()
20421 
      if ftype == TType.STOP:
20422 
        break
20423 
      if fid == 1:
20424 
        if ftype == TType.STRUCT:
20425 
          self.ex = TransactionServiceException()
20426 
          self.ex.read(iprot)
20427 
        else:
20428 
          iprot.skip(ftype)
20429 
      else:
20430 
        iprot.skip(ftype)
20431 
      iprot.readFieldEnd()
20432 
    iprot.readStructEnd()
20433 
 
20434 
  def write(self, oprot):
20435 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
20436 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
20437 
      return
20438 
    oprot.writeStructBegin('markOrdersAsNotAvailabke_result')
20439 
    if self.ex is not None:
20440 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
20441 
      self.ex.write(oprot)
20442 
      oprot.writeFieldEnd()
20443 
    oprot.writeFieldStop()
20444 
    oprot.writeStructEnd()
20445 
 
20446 
  def validate(self):
20447 
    return
20448 
 
20449 
 
20450 
  def __repr__(self):
20451 
    L = ['%s=%r' % (key, value)
20452 
      for key, value in self.__dict__.iteritems()]
20453 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
20454 
 
20455 
  def __eq__(self, other):
20456 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
20457 
 
20458 
  def __ne__(self, other):
20459 
    return not (self == other)
4369 rajveer 20460 
 
20461 
class markOrdersAsTimeout_args:
20462 
  """
20463 
  Attributes:
20464 
   - vendorId
20465 
  """
20466 
 
20467 
  thrift_spec = (
20468 
    None, # 0
20469 
    (1, TType.I64, 'vendorId', None, None, ), # 1
20470 
  )
20471 
 
20472 
  def __init__(self, vendorId=None,):
20473 
    self.vendorId = vendorId
20474 
 
20475 
  def read(self, iprot):
20476 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
20477 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
20478 
      return
20479 
    iprot.readStructBegin()
20480 
    while True:
20481 
      (fname, ftype, fid) = iprot.readFieldBegin()
20482 
      if ftype == TType.STOP:
20483 
        break
20484 
      if fid == 1:
20485 
        if ftype == TType.I64:
20486 
          self.vendorId = iprot.readI64();
20487 
        else:
20488 
          iprot.skip(ftype)
20489 
      else:
20490 
        iprot.skip(ftype)
20491 
      iprot.readFieldEnd()
20492 
    iprot.readStructEnd()
20493 
 
20494 
  def write(self, oprot):
20495 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
20496 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
20497 
      return
20498 
    oprot.writeStructBegin('markOrdersAsTimeout_args')
20499 
    if self.vendorId is not None:
20500 
      oprot.writeFieldBegin('vendorId', TType.I64, 1)
20501 
      oprot.writeI64(self.vendorId)
20502 
      oprot.writeFieldEnd()
20503 
    oprot.writeFieldStop()
20504 
    oprot.writeStructEnd()
20505 
 
20506 
  def validate(self):
20507 
    return
20508 
 
20509 
 
20510 
  def __repr__(self):
20511 
    L = ['%s=%r' % (key, value)
20512 
      for key, value in self.__dict__.iteritems()]
20513 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
20514 
 
20515 
  def __eq__(self, other):
20516 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
20517 
 
20518 
  def __ne__(self, other):
20519 
    return not (self == other)
20520 
 
20521 
class markOrdersAsTimeout_result:
20522 
  """
20523 
  Attributes:
20524 
   - success
20525 
   - ex
20526 
  """
20527 
 
20528 
  thrift_spec = (
20529 
    (0, TType.MAP, 'success', (TType.I32,None,TType.STRUCT,(TimeoutSummary, TimeoutSummary.thrift_spec)), None, ), # 0
20530 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
20531 
  )
20532 
 
20533 
  def __init__(self, success=None, ex=None,):
20534 
    self.success = success
20535 
    self.ex = ex
20536 
 
20537 
  def read(self, iprot):
20538 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
20539 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
20540 
      return
20541 
    iprot.readStructBegin()
20542 
    while True:
20543 
      (fname, ftype, fid) = iprot.readFieldBegin()
20544 
      if ftype == TType.STOP:
20545 
        break
20546 
      if fid == 0:
20547 
        if ftype == TType.MAP:
20548 
          self.success = {}
5676 rajveer 20549 
          (_ktype452, _vtype453, _size451 ) = iprot.readMapBegin()
20550 
          for _i455 in xrange(_size451):
20551 
            _key456 = iprot.readI32();
20552 
            _val457 = TimeoutSummary()
20553 
            _val457.read(iprot)
20554 
            self.success[_key456] = _val457
4369 rajveer 20555 
          iprot.readMapEnd()
20556 
        else:
20557 
          iprot.skip(ftype)
20558 
      elif fid == 1:
20559 
        if ftype == TType.STRUCT:
20560 
          self.ex = TransactionServiceException()
20561 
          self.ex.read(iprot)
20562 
        else:
20563 
          iprot.skip(ftype)
20564 
      else:
20565 
        iprot.skip(ftype)
20566 
      iprot.readFieldEnd()
20567 
    iprot.readStructEnd()
20568 
 
20569 
  def write(self, oprot):
20570 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
20571 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
20572 
      return
20573 
    oprot.writeStructBegin('markOrdersAsTimeout_result')
20574 
    if self.success is not None:
20575 
      oprot.writeFieldBegin('success', TType.MAP, 0)
20576 
      oprot.writeMapBegin(TType.I32, TType.STRUCT, len(self.success))
5676 rajveer 20577 
      for kiter458,viter459 in self.success.items():
20578 
        oprot.writeI32(kiter458)
20579 
        viter459.write(oprot)
4369 rajveer 20580 
      oprot.writeMapEnd()
20581 
      oprot.writeFieldEnd()
20582 
    if self.ex is not None:
20583 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
20584 
      self.ex.write(oprot)
20585 
      oprot.writeFieldEnd()
20586 
    oprot.writeFieldStop()
20587 
    oprot.writeStructEnd()
20588 
 
20589 
  def validate(self):
20590 
    return
20591 
 
20592 
 
20593 
  def __repr__(self):
20594 
    L = ['%s=%r' % (key, value)
20595 
      for key, value in self.__dict__.iteritems()]
20596 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
20597 
 
20598 
  def __eq__(self, other):
20599 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
20600 
 
20601 
  def __ne__(self, other):
20602 
    return not (self == other)
4386 anupam.sin 20603 
 
4662 rajveer 20604 
class markOrderAsLostInTransit_args:
20605 
  """
20606 
  Attributes:
20607 
   - orderId
20608 
  """
20609 
 
20610 
  thrift_spec = (
20611 
    None, # 0
20612 
    (1, TType.I64, 'orderId', None, None, ), # 1
20613 
  )
20614 
 
20615 
  def __init__(self, orderId=None,):
20616 
    self.orderId = orderId
20617 
 
20618 
  def read(self, iprot):
20619 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
20620 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
20621 
      return
20622 
    iprot.readStructBegin()
20623 
    while True:
20624 
      (fname, ftype, fid) = iprot.readFieldBegin()
20625 
      if ftype == TType.STOP:
20626 
        break
20627 
      if fid == 1:
20628 
        if ftype == TType.I64:
20629 
          self.orderId = iprot.readI64();
20630 
        else:
20631 
          iprot.skip(ftype)
20632 
      else:
20633 
        iprot.skip(ftype)
20634 
      iprot.readFieldEnd()
20635 
    iprot.readStructEnd()
20636 
 
20637 
  def write(self, oprot):
20638 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
20639 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
20640 
      return
20641 
    oprot.writeStructBegin('markOrderAsLostInTransit_args')
20642 
    if self.orderId is not None:
20643 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
20644 
      oprot.writeI64(self.orderId)
20645 
      oprot.writeFieldEnd()
20646 
    oprot.writeFieldStop()
20647 
    oprot.writeStructEnd()
20648 
 
20649 
  def validate(self):
20650 
    return
20651 
 
20652 
 
20653 
  def __repr__(self):
20654 
    L = ['%s=%r' % (key, value)
20655 
      for key, value in self.__dict__.iteritems()]
20656 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
20657 
 
20658 
  def __eq__(self, other):
20659 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
20660 
 
20661 
  def __ne__(self, other):
20662 
    return not (self == other)
20663 
 
20664 
class markOrderAsLostInTransit_result:
20665 
  """
20666 
  Attributes:
20667 
   - success
20668 
   - ex
20669 
  """
20670 
 
20671 
  thrift_spec = (
20672 
    (0, TType.BOOL, 'success', None, None, ), # 0
20673 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
20674 
  )
20675 
 
20676 
  def __init__(self, success=None, ex=None,):
20677 
    self.success = success
20678 
    self.ex = ex
20679 
 
20680 
  def read(self, iprot):
20681 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
20682 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
20683 
      return
20684 
    iprot.readStructBegin()
20685 
    while True:
20686 
      (fname, ftype, fid) = iprot.readFieldBegin()
20687 
      if ftype == TType.STOP:
20688 
        break
20689 
      if fid == 0:
20690 
        if ftype == TType.BOOL:
20691 
          self.success = iprot.readBool();
20692 
        else:
20693 
          iprot.skip(ftype)
20694 
      elif fid == 1:
20695 
        if ftype == TType.STRUCT:
20696 
          self.ex = TransactionServiceException()
20697 
          self.ex.read(iprot)
20698 
        else:
20699 
          iprot.skip(ftype)
20700 
      else:
20701 
        iprot.skip(ftype)
20702 
      iprot.readFieldEnd()
20703 
    iprot.readStructEnd()
20704 
 
20705 
  def write(self, oprot):
20706 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
20707 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
20708 
      return
20709 
    oprot.writeStructBegin('markOrderAsLostInTransit_result')
20710 
    if self.success is not None:
20711 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
20712 
      oprot.writeBool(self.success)
20713 
      oprot.writeFieldEnd()
20714 
    if self.ex is not None:
20715 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
20716 
      self.ex.write(oprot)
20717 
      oprot.writeFieldEnd()
20718 
    oprot.writeFieldStop()
20719 
    oprot.writeStructEnd()
20720 
 
20721 
  def validate(self):
20722 
    return
20723 
 
20724 
 
20725 
  def __repr__(self):
20726 
    L = ['%s=%r' % (key, value)
20727 
      for key, value in self.__dict__.iteritems()]
20728 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
20729 
 
20730 
  def __eq__(self, other):
20731 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
20732 
 
20733 
  def __ne__(self, other):
20734 
    return not (self == other)
20735 
 
4386 anupam.sin 20736 
class getOrderForAwb_args:
20737 
  """
20738 
  Attributes:
20739 
   - awb
20740 
  """
20741 
 
20742 
  thrift_spec = (
20743 
    None, # 0
20744 
    (1, TType.STRING, 'awb', None, None, ), # 1
20745 
  )
20746 
 
20747 
  def __init__(self, awb=None,):
20748 
    self.awb = awb
20749 
 
20750 
  def read(self, iprot):
20751 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
20752 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
20753 
      return
20754 
    iprot.readStructBegin()
20755 
    while True:
20756 
      (fname, ftype, fid) = iprot.readFieldBegin()
20757 
      if ftype == TType.STOP:
20758 
        break
20759 
      if fid == 1:
20760 
        if ftype == TType.STRING:
20761 
          self.awb = iprot.readString();
20762 
        else:
20763 
          iprot.skip(ftype)
20764 
      else:
20765 
        iprot.skip(ftype)
20766 
      iprot.readFieldEnd()
20767 
    iprot.readStructEnd()
20768 
 
20769 
  def write(self, oprot):
20770 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
20771 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
20772 
      return
20773 
    oprot.writeStructBegin('getOrderForAwb_args')
20774 
    if self.awb is not None:
20775 
      oprot.writeFieldBegin('awb', TType.STRING, 1)
20776 
      oprot.writeString(self.awb)
20777 
      oprot.writeFieldEnd()
20778 
    oprot.writeFieldStop()
20779 
    oprot.writeStructEnd()
20780 
 
20781 
  def validate(self):
20782 
    return
20783 
 
20784 
 
20785 
  def __repr__(self):
20786 
    L = ['%s=%r' % (key, value)
20787 
      for key, value in self.__dict__.iteritems()]
20788 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
20789 
 
20790 
  def __eq__(self, other):
20791 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
20792 
 
20793 
  def __ne__(self, other):
20794 
    return not (self == other)
20795 
 
20796 
class getOrderForAwb_result:
20797 
  """
20798 
  Attributes:
20799 
   - success
20800 
   - ex
20801 
  """
20802 
 
20803 
  thrift_spec = (
20804 
    (0, TType.STRUCT, 'success', (Order, Order.thrift_spec), None, ), # 0
20805 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
20806 
  )
20807 
 
20808 
  def __init__(self, success=None, ex=None,):
20809 
    self.success = success
20810 
    self.ex = ex
20811 
 
20812 
  def read(self, iprot):
20813 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
20814 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
20815 
      return
20816 
    iprot.readStructBegin()
20817 
    while True:
20818 
      (fname, ftype, fid) = iprot.readFieldBegin()
20819 
      if ftype == TType.STOP:
20820 
        break
20821 
      if fid == 0:
20822 
        if ftype == TType.STRUCT:
20823 
          self.success = Order()
20824 
          self.success.read(iprot)
20825 
        else:
20826 
          iprot.skip(ftype)
20827 
      elif fid == 1:
20828 
        if ftype == TType.STRUCT:
20829 
          self.ex = TransactionServiceException()
20830 
          self.ex.read(iprot)
20831 
        else:
20832 
          iprot.skip(ftype)
20833 
      else:
20834 
        iprot.skip(ftype)
20835 
      iprot.readFieldEnd()
20836 
    iprot.readStructEnd()
20837 
 
20838 
  def write(self, oprot):
20839 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
20840 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
20841 
      return
20842 
    oprot.writeStructBegin('getOrderForAwb_result')
20843 
    if self.success is not None:
20844 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
20845 
      self.success.write(oprot)
20846 
      oprot.writeFieldEnd()
20847 
    if self.ex is not None:
20848 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
20849 
      self.ex.write(oprot)
20850 
      oprot.writeFieldEnd()
20851 
    oprot.writeFieldStop()
20852 
    oprot.writeStructEnd()
20853 
 
20854 
  def validate(self):
20855 
    return
20856 
 
20857 
 
20858 
  def __repr__(self):
20859 
    L = ['%s=%r' % (key, value)
20860 
      for key, value in self.__dict__.iteritems()]
20861 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
20862 
 
20863 
  def __eq__(self, other):
20864 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
20865 
 
20866 
  def __ne__(self, other):
20867 
    return not (self == other)
4506 phani.kuma 20868 
 
20869 
class getOrdersForProviderForStatus_args:
20870 
  """
20871 
  Attributes:
20872 
   - logistics_provider_id
4910 phani.kuma 20873 
   - order_status_list
4506 phani.kuma 20874 
  """
20875 
 
20876 
  thrift_spec = (
20877 
    None, # 0
20878 
    (1, TType.I64, 'logistics_provider_id', None, None, ), # 1
4910 phani.kuma 20879 
    (2, TType.LIST, 'order_status_list', (TType.I32,None), None, ), # 2
4506 phani.kuma 20880 
  )
20881 
 
4910 phani.kuma 20882 
  def __init__(self, logistics_provider_id=None, order_status_list=None,):
4506 phani.kuma 20883 
    self.logistics_provider_id = logistics_provider_id
4910 phani.kuma 20884 
    self.order_status_list = order_status_list
4506 phani.kuma 20885 
 
20886 
  def read(self, iprot):
20887 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
20888 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
20889 
      return
20890 
    iprot.readStructBegin()
20891 
    while True:
20892 
      (fname, ftype, fid) = iprot.readFieldBegin()
20893 
      if ftype == TType.STOP:
20894 
        break
20895 
      if fid == 1:
20896 
        if ftype == TType.I64:
20897 
          self.logistics_provider_id = iprot.readI64();
20898 
        else:
20899 
          iprot.skip(ftype)
20900 
      elif fid == 2:
4910 phani.kuma 20901 
        if ftype == TType.LIST:
20902 
          self.order_status_list = []
5676 rajveer 20903 
          (_etype463, _size460) = iprot.readListBegin()
20904 
          for _i464 in xrange(_size460):
20905 
            _elem465 = iprot.readI32();
20906 
            self.order_status_list.append(_elem465)
4910 phani.kuma 20907 
          iprot.readListEnd()
4506 phani.kuma 20908 
        else:
20909 
          iprot.skip(ftype)
20910 
      else:
20911 
        iprot.skip(ftype)
20912 
      iprot.readFieldEnd()
20913 
    iprot.readStructEnd()
20914 
 
20915 
  def write(self, oprot):
20916 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
20917 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
20918 
      return
20919 
    oprot.writeStructBegin('getOrdersForProviderForStatus_args')
20920 
    if self.logistics_provider_id is not None:
20921 
      oprot.writeFieldBegin('logistics_provider_id', TType.I64, 1)
20922 
      oprot.writeI64(self.logistics_provider_id)
20923 
      oprot.writeFieldEnd()
4910 phani.kuma 20924 
    if self.order_status_list is not None:
20925 
      oprot.writeFieldBegin('order_status_list', TType.LIST, 2)
20926 
      oprot.writeListBegin(TType.I32, len(self.order_status_list))
5676 rajveer 20927 
      for iter466 in self.order_status_list:
20928 
        oprot.writeI32(iter466)
4910 phani.kuma 20929 
      oprot.writeListEnd()
4506 phani.kuma 20930 
      oprot.writeFieldEnd()
20931 
    oprot.writeFieldStop()
20932 
    oprot.writeStructEnd()
20933 
 
20934 
  def validate(self):
20935 
    return
20936 
 
20937 
 
20938 
  def __repr__(self):
20939 
    L = ['%s=%r' % (key, value)
20940 
      for key, value in self.__dict__.iteritems()]
20941 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
20942 
 
20943 
  def __eq__(self, other):
20944 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
20945 
 
20946 
  def __ne__(self, other):
20947 
    return not (self == other)
20948 
 
20949 
class getOrdersForProviderForStatus_result:
20950 
  """
20951 
  Attributes:
20952 
   - success
20953 
   - ex
20954 
  """
20955 
 
20956 
  thrift_spec = (
20957 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
20958 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
20959 
  )
20960 
 
20961 
  def __init__(self, success=None, ex=None,):
20962 
    self.success = success
20963 
    self.ex = ex
20964 
 
20965 
  def read(self, iprot):
20966 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
20967 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
20968 
      return
20969 
    iprot.readStructBegin()
20970 
    while True:
20971 
      (fname, ftype, fid) = iprot.readFieldBegin()
20972 
      if ftype == TType.STOP:
20973 
        break
20974 
      if fid == 0:
20975 
        if ftype == TType.LIST:
20976 
          self.success = []
5676 rajveer 20977 
          (_etype470, _size467) = iprot.readListBegin()
20978 
          for _i471 in xrange(_size467):
20979 
            _elem472 = Order()
20980 
            _elem472.read(iprot)
20981 
            self.success.append(_elem472)
4506 phani.kuma 20982 
          iprot.readListEnd()
20983 
        else:
20984 
          iprot.skip(ftype)
20985 
      elif fid == 1:
20986 
        if ftype == TType.STRUCT:
20987 
          self.ex = TransactionServiceException()
20988 
          self.ex.read(iprot)
20989 
        else:
20990 
          iprot.skip(ftype)
20991 
      else:
20992 
        iprot.skip(ftype)
20993 
      iprot.readFieldEnd()
20994 
    iprot.readStructEnd()
20995 
 
20996 
  def write(self, oprot):
20997 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
20998 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
20999 
      return
21000 
    oprot.writeStructBegin('getOrdersForProviderForStatus_result')
21001 
    if self.success is not None:
21002 
      oprot.writeFieldBegin('success', TType.LIST, 0)
21003 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
5676 rajveer 21004 
      for iter473 in self.success:
21005 
        iter473.write(oprot)
4506 phani.kuma 21006 
      oprot.writeListEnd()
21007 
      oprot.writeFieldEnd()
21008 
    if self.ex is not None:
21009 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
21010 
      self.ex.write(oprot)
21011 
      oprot.writeFieldEnd()
21012 
    oprot.writeFieldStop()
21013 
    oprot.writeStructEnd()
21014 
 
21015 
  def validate(self):
21016 
    return
21017 
 
21018 
 
21019 
  def __repr__(self):
21020 
    L = ['%s=%r' % (key, value)
21021 
      for key, value in self.__dict__.iteritems()]
21022 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
21023 
 
21024 
  def __eq__(self, other):
21025 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
21026 
 
21027 
  def __ne__(self, other):
21028 
    return not (self == other)
4600 varun.gupt 21029 
 
21030 
class getBilledOrdersForVendor_args:
21031 
  """
21032 
  Attributes:
21033 
   - vendorId
21034 
   - billingDateFrom
21035 
   - billingDateTo
21036 
  """
21037 
 
21038 
  thrift_spec = (
21039 
    None, # 0
21040 
    (1, TType.I64, 'vendorId', None, None, ), # 1
21041 
    (2, TType.I64, 'billingDateFrom', None, None, ), # 2
21042 
    (3, TType.I64, 'billingDateTo', None, None, ), # 3
21043 
  )
21044 
 
21045 
  def __init__(self, vendorId=None, billingDateFrom=None, billingDateTo=None,):
21046 
    self.vendorId = vendorId
21047 
    self.billingDateFrom = billingDateFrom
21048 
    self.billingDateTo = billingDateTo
21049 
 
21050 
  def read(self, iprot):
21051 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
21052 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
21053 
      return
21054 
    iprot.readStructBegin()
21055 
    while True:
21056 
      (fname, ftype, fid) = iprot.readFieldBegin()
21057 
      if ftype == TType.STOP:
21058 
        break
21059 
      if fid == 1:
21060 
        if ftype == TType.I64:
21061 
          self.vendorId = iprot.readI64();
21062 
        else:
21063 
          iprot.skip(ftype)
21064 
      elif fid == 2:
21065 
        if ftype == TType.I64:
21066 
          self.billingDateFrom = iprot.readI64();
21067 
        else:
21068 
          iprot.skip(ftype)
21069 
      elif fid == 3:
21070 
        if ftype == TType.I64:
21071 
          self.billingDateTo = iprot.readI64();
21072 
        else:
21073 
          iprot.skip(ftype)
21074 
      else:
21075 
        iprot.skip(ftype)
21076 
      iprot.readFieldEnd()
21077 
    iprot.readStructEnd()
21078 
 
21079 
  def write(self, oprot):
21080 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
21081 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
21082 
      return
21083 
    oprot.writeStructBegin('getBilledOrdersForVendor_args')
21084 
    if self.vendorId is not None:
21085 
      oprot.writeFieldBegin('vendorId', TType.I64, 1)
21086 
      oprot.writeI64(self.vendorId)
21087 
      oprot.writeFieldEnd()
21088 
    if self.billingDateFrom is not None:
21089 
      oprot.writeFieldBegin('billingDateFrom', TType.I64, 2)
21090 
      oprot.writeI64(self.billingDateFrom)
21091 
      oprot.writeFieldEnd()
21092 
    if self.billingDateTo is not None:
21093 
      oprot.writeFieldBegin('billingDateTo', TType.I64, 3)
21094 
      oprot.writeI64(self.billingDateTo)
21095 
      oprot.writeFieldEnd()
21096 
    oprot.writeFieldStop()
21097 
    oprot.writeStructEnd()
21098 
 
21099 
  def validate(self):
21100 
    return
21101 
 
21102 
 
21103 
  def __repr__(self):
21104 
    L = ['%s=%r' % (key, value)
21105 
      for key, value in self.__dict__.iteritems()]
21106 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
21107 
 
21108 
  def __eq__(self, other):
21109 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
21110 
 
21111 
  def __ne__(self, other):
21112 
    return not (self == other)
21113 
 
21114 
class getBilledOrdersForVendor_result:
21115 
  """
21116 
  Attributes:
21117 
   - success
21118 
   - ex
21119 
  """
21120 
 
21121 
  thrift_spec = (
21122 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
21123 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
21124 
  )
21125 
 
21126 
  def __init__(self, success=None, ex=None,):
21127 
    self.success = success
21128 
    self.ex = ex
21129 
 
21130 
  def read(self, iprot):
21131 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
21132 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
21133 
      return
21134 
    iprot.readStructBegin()
21135 
    while True:
21136 
      (fname, ftype, fid) = iprot.readFieldBegin()
21137 
      if ftype == TType.STOP:
21138 
        break
21139 
      if fid == 0:
21140 
        if ftype == TType.LIST:
21141 
          self.success = []
5676 rajveer 21142 
          (_etype477, _size474) = iprot.readListBegin()
21143 
          for _i478 in xrange(_size474):
21144 
            _elem479 = Order()
21145 
            _elem479.read(iprot)
21146 
            self.success.append(_elem479)
4600 varun.gupt 21147 
          iprot.readListEnd()
21148 
        else:
21149 
          iprot.skip(ftype)
21150 
      elif fid == 1:
21151 
        if ftype == TType.STRUCT:
21152 
          self.ex = TransactionServiceException()
21153 
          self.ex.read(iprot)
21154 
        else:
21155 
          iprot.skip(ftype)
21156 
      else:
21157 
        iprot.skip(ftype)
21158 
      iprot.readFieldEnd()
21159 
    iprot.readStructEnd()
21160 
 
21161 
  def write(self, oprot):
21162 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
21163 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
21164 
      return
21165 
    oprot.writeStructBegin('getBilledOrdersForVendor_result')
21166 
    if self.success is not None:
21167 
      oprot.writeFieldBegin('success', TType.LIST, 0)
21168 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
5676 rajveer 21169 
      for iter480 in self.success:
21170 
        iter480.write(oprot)
4600 varun.gupt 21171 
      oprot.writeListEnd()
21172 
      oprot.writeFieldEnd()
21173 
    if self.ex is not None:
21174 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
21175 
      self.ex.write(oprot)
21176 
      oprot.writeFieldEnd()
21177 
    oprot.writeFieldStop()
21178 
    oprot.writeStructEnd()
21179 
 
21180 
  def validate(self):
21181 
    return
21182 
 
21183 
 
21184 
  def __repr__(self):
21185 
    L = ['%s=%r' % (key, value)
21186 
      for key, value in self.__dict__.iteritems()]
21187 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
21188 
 
21189 
  def __eq__(self, other):
21190 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
21191 
 
21192 
  def __ne__(self, other):
21193 
    return not (self == other)
21194 
 
4607 rajveer 21195 
class getSlippedSippingDateOrders_args:
21196 
 
21197 
  thrift_spec = (
21198 
  )
21199 
 
21200 
  def read(self, iprot):
21201 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
21202 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
21203 
      return
21204 
    iprot.readStructBegin()
21205 
    while True:
21206 
      (fname, ftype, fid) = iprot.readFieldBegin()
21207 
      if ftype == TType.STOP:
21208 
        break
21209 
      else:
21210 
        iprot.skip(ftype)
21211 
      iprot.readFieldEnd()
21212 
    iprot.readStructEnd()
21213 
 
21214 
  def write(self, oprot):
21215 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
21216 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
21217 
      return
21218 
    oprot.writeStructBegin('getSlippedSippingDateOrders_args')
21219 
    oprot.writeFieldStop()
21220 
    oprot.writeStructEnd()
21221 
 
21222 
  def validate(self):
21223 
    return
21224 
 
21225 
 
21226 
  def __repr__(self):
21227 
    L = ['%s=%r' % (key, value)
21228 
      for key, value in self.__dict__.iteritems()]
21229 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
21230 
 
21231 
  def __eq__(self, other):
21232 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
21233 
 
21234 
  def __ne__(self, other):
21235 
    return not (self == other)
21236 
 
21237 
class getSlippedSippingDateOrders_result:
21238 
  """
21239 
  Attributes:
21240 
   - success
21241 
   - ex
21242 
  """
21243 
 
21244 
  thrift_spec = (
21245 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
21246 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
21247 
  )
21248 
 
21249 
  def __init__(self, success=None, ex=None,):
21250 
    self.success = success
21251 
    self.ex = ex
21252 
 
21253 
  def read(self, iprot):
21254 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
21255 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
21256 
      return
21257 
    iprot.readStructBegin()
21258 
    while True:
21259 
      (fname, ftype, fid) = iprot.readFieldBegin()
21260 
      if ftype == TType.STOP:
21261 
        break
21262 
      if fid == 0:
21263 
        if ftype == TType.LIST:
21264 
          self.success = []
5676 rajveer 21265 
          (_etype484, _size481) = iprot.readListBegin()
21266 
          for _i485 in xrange(_size481):
21267 
            _elem486 = Order()
21268 
            _elem486.read(iprot)
21269 
            self.success.append(_elem486)
4607 rajveer 21270 
          iprot.readListEnd()
21271 
        else:
21272 
          iprot.skip(ftype)
21273 
      elif fid == 1:
21274 
        if ftype == TType.STRUCT:
21275 
          self.ex = TransactionServiceException()
21276 
          self.ex.read(iprot)
21277 
        else:
21278 
          iprot.skip(ftype)
21279 
      else:
21280 
        iprot.skip(ftype)
21281 
      iprot.readFieldEnd()
21282 
    iprot.readStructEnd()
21283 
 
21284 
  def write(self, oprot):
21285 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
21286 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
21287 
      return
21288 
    oprot.writeStructBegin('getSlippedSippingDateOrders_result')
21289 
    if self.success is not None:
21290 
      oprot.writeFieldBegin('success', TType.LIST, 0)
21291 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
5676 rajveer 21292 
      for iter487 in self.success:
21293 
        iter487.write(oprot)
4607 rajveer 21294 
      oprot.writeListEnd()
21295 
      oprot.writeFieldEnd()
21296 
    if self.ex is not None:
21297 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
21298 
      self.ex.write(oprot)
21299 
      oprot.writeFieldEnd()
21300 
    oprot.writeFieldStop()
21301 
    oprot.writeStructEnd()
21302 
 
21303 
  def validate(self):
21304 
    return
21305 
 
21306 
 
21307 
  def __repr__(self):
21308 
    L = ['%s=%r' % (key, value)
21309 
      for key, value in self.__dict__.iteritems()]
21310 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
21311 
 
21312 
  def __eq__(self, other):
21313 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
21314 
 
21315 
  def __ne__(self, other):
21316 
    return not (self == other)
21317 
 
4709 rajveer 21318 
class getCancelledOrders_args:
21319 
  """
21320 
  Attributes:
21321 
   - cancelDateFrom
21322 
   - cancelDateTo
21323 
  """
21324 
 
21325 
  thrift_spec = (
21326 
    None, # 0
21327 
    (1, TType.I64, 'cancelDateFrom', None, None, ), # 1
21328 
    (2, TType.I64, 'cancelDateTo', None, None, ), # 2
21329 
  )
21330 
 
21331 
  def __init__(self, cancelDateFrom=None, cancelDateTo=None,):
21332 
    self.cancelDateFrom = cancelDateFrom
21333 
    self.cancelDateTo = cancelDateTo
21334 
 
21335 
  def read(self, iprot):
21336 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
21337 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
21338 
      return
21339 
    iprot.readStructBegin()
21340 
    while True:
21341 
      (fname, ftype, fid) = iprot.readFieldBegin()
21342 
      if ftype == TType.STOP:
21343 
        break
21344 
      if fid == 1:
21345 
        if ftype == TType.I64:
21346 
          self.cancelDateFrom = iprot.readI64();
21347 
        else:
21348 
          iprot.skip(ftype)
21349 
      elif fid == 2:
21350 
        if ftype == TType.I64:
21351 
          self.cancelDateTo = iprot.readI64();
21352 
        else:
21353 
          iprot.skip(ftype)
21354 
      else:
21355 
        iprot.skip(ftype)
21356 
      iprot.readFieldEnd()
21357 
    iprot.readStructEnd()
21358 
 
21359 
  def write(self, oprot):
21360 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
21361 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
21362 
      return
21363 
    oprot.writeStructBegin('getCancelledOrders_args')
21364 
    if self.cancelDateFrom is not None:
21365 
      oprot.writeFieldBegin('cancelDateFrom', TType.I64, 1)
21366 
      oprot.writeI64(self.cancelDateFrom)
21367 
      oprot.writeFieldEnd()
21368 
    if self.cancelDateTo is not None:
21369 
      oprot.writeFieldBegin('cancelDateTo', TType.I64, 2)
21370 
      oprot.writeI64(self.cancelDateTo)
21371 
      oprot.writeFieldEnd()
21372 
    oprot.writeFieldStop()
21373 
    oprot.writeStructEnd()
21374 
 
21375 
  def validate(self):
21376 
    return
21377 
 
21378 
 
21379 
  def __repr__(self):
21380 
    L = ['%s=%r' % (key, value)
21381 
      for key, value in self.__dict__.iteritems()]
21382 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
21383 
 
21384 
  def __eq__(self, other):
21385 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
21386 
 
21387 
  def __ne__(self, other):
21388 
    return not (self == other)
21389 
 
21390 
class getCancelledOrders_result:
21391 
  """
21392 
  Attributes:
21393 
   - success
21394 
   - ex
21395 
  """
21396 
 
21397 
  thrift_spec = (
21398 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
21399 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
21400 
  )
21401 
 
21402 
  def __init__(self, success=None, ex=None,):
21403 
    self.success = success
21404 
    self.ex = ex
21405 
 
21406 
  def read(self, iprot):
21407 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
21408 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
21409 
      return
21410 
    iprot.readStructBegin()
21411 
    while True:
21412 
      (fname, ftype, fid) = iprot.readFieldBegin()
21413 
      if ftype == TType.STOP:
21414 
        break
21415 
      if fid == 0:
21416 
        if ftype == TType.LIST:
21417 
          self.success = []
5676 rajveer 21418 
          (_etype491, _size488) = iprot.readListBegin()
21419 
          for _i492 in xrange(_size488):
21420 
            _elem493 = Order()
21421 
            _elem493.read(iprot)
21422 
            self.success.append(_elem493)
4709 rajveer 21423 
          iprot.readListEnd()
21424 
        else:
21425 
          iprot.skip(ftype)
21426 
      elif fid == 1:
21427 
        if ftype == TType.STRUCT:
21428 
          self.ex = TransactionServiceException()
21429 
          self.ex.read(iprot)
21430 
        else:
21431 
          iprot.skip(ftype)
21432 
      else:
21433 
        iprot.skip(ftype)
21434 
      iprot.readFieldEnd()
21435 
    iprot.readStructEnd()
21436 
 
21437 
  def write(self, oprot):
21438 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
21439 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
21440 
      return
21441 
    oprot.writeStructBegin('getCancelledOrders_result')
21442 
    if self.success is not None:
21443 
      oprot.writeFieldBegin('success', TType.LIST, 0)
21444 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
5676 rajveer 21445 
      for iter494 in self.success:
21446 
        iter494.write(oprot)
4709 rajveer 21447 
      oprot.writeListEnd()
21448 
      oprot.writeFieldEnd()
21449 
    if self.ex is not None:
21450 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
21451 
      self.ex.write(oprot)
21452 
      oprot.writeFieldEnd()
21453 
    oprot.writeFieldStop()
21454 
    oprot.writeStructEnd()
21455 
 
21456 
  def validate(self):
21457 
    return
21458 
 
21459 
 
21460 
  def __repr__(self):
21461 
    L = ['%s=%r' % (key, value)
21462 
      for key, value in self.__dict__.iteritems()]
21463 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
21464 
 
21465 
  def __eq__(self, other):
21466 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
21467 
 
21468 
  def __ne__(self, other):
21469 
    return not (self == other)
21470 
 
4600 varun.gupt 21471 
class saveBluedartSettlements_args:
21472 
  """
21473 
  Attributes:
21474 
   - mapAWBAndAmount
21475 
  """
21476 
 
21477 
  thrift_spec = (
21478 
    None, # 0
21479 
    (1, TType.MAP, 'mapAWBAndAmount', (TType.I64,None,TType.DOUBLE,None), None, ), # 1
21480 
  )
21481 
 
21482 
  def __init__(self, mapAWBAndAmount=None,):
21483 
    self.mapAWBAndAmount = mapAWBAndAmount
21484 
 
21485 
  def read(self, iprot):
21486 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
21487 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
21488 
      return
21489 
    iprot.readStructBegin()
21490 
    while True:
21491 
      (fname, ftype, fid) = iprot.readFieldBegin()
21492 
      if ftype == TType.STOP:
21493 
        break
21494 
      if fid == 1:
21495 
        if ftype == TType.MAP:
21496 
          self.mapAWBAndAmount = {}
5676 rajveer 21497 
          (_ktype496, _vtype497, _size495 ) = iprot.readMapBegin()
21498 
          for _i499 in xrange(_size495):
21499 
            _key500 = iprot.readI64();
21500 
            _val501 = iprot.readDouble();
21501 
            self.mapAWBAndAmount[_key500] = _val501
4600 varun.gupt 21502 
          iprot.readMapEnd()
21503 
        else:
21504 
          iprot.skip(ftype)
21505 
      else:
21506 
        iprot.skip(ftype)
21507 
      iprot.readFieldEnd()
21508 
    iprot.readStructEnd()
21509 
 
21510 
  def write(self, oprot):
21511 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
21512 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
21513 
      return
21514 
    oprot.writeStructBegin('saveBluedartSettlements_args')
21515 
    if self.mapAWBAndAmount is not None:
21516 
      oprot.writeFieldBegin('mapAWBAndAmount', TType.MAP, 1)
21517 
      oprot.writeMapBegin(TType.I64, TType.DOUBLE, len(self.mapAWBAndAmount))
5676 rajveer 21518 
      for kiter502,viter503 in self.mapAWBAndAmount.items():
21519 
        oprot.writeI64(kiter502)
21520 
        oprot.writeDouble(viter503)
4600 varun.gupt 21521 
      oprot.writeMapEnd()
21522 
      oprot.writeFieldEnd()
21523 
    oprot.writeFieldStop()
21524 
    oprot.writeStructEnd()
21525 
 
21526 
  def validate(self):
21527 
    return
21528 
 
21529 
 
21530 
  def __repr__(self):
21531 
    L = ['%s=%r' % (key, value)
21532 
      for key, value in self.__dict__.iteritems()]
21533 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
21534 
 
21535 
  def __eq__(self, other):
21536 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
21537 
 
21538 
  def __ne__(self, other):
21539 
    return not (self == other)
21540 
 
21541 
class saveBluedartSettlements_result:
21542 
  """
21543 
  Attributes:
21544 
   - ex
21545 
  """
21546 
 
21547 
  thrift_spec = (
21548 
    None, # 0
21549 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
21550 
  )
21551 
 
21552 
  def __init__(self, ex=None,):
21553 
    self.ex = ex
21554 
 
21555 
  def read(self, iprot):
21556 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
21557 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
21558 
      return
21559 
    iprot.readStructBegin()
21560 
    while True:
21561 
      (fname, ftype, fid) = iprot.readFieldBegin()
21562 
      if ftype == TType.STOP:
21563 
        break
21564 
      if fid == 1:
21565 
        if ftype == TType.STRUCT:
21566 
          self.ex = TransactionServiceException()
21567 
          self.ex.read(iprot)
21568 
        else:
21569 
          iprot.skip(ftype)
21570 
      else:
21571 
        iprot.skip(ftype)
21572 
      iprot.readFieldEnd()
21573 
    iprot.readStructEnd()
21574 
 
21575 
  def write(self, oprot):
21576 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
21577 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
21578 
      return
21579 
    oprot.writeStructBegin('saveBluedartSettlements_result')
21580 
    if self.ex is not None:
21581 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
21582 
      self.ex.write(oprot)
21583 
      oprot.writeFieldEnd()
21584 
    oprot.writeFieldStop()
21585 
    oprot.writeStructEnd()
21586 
 
21587 
  def validate(self):
21588 
    return
21589 
 
21590 
 
21591 
  def __repr__(self):
21592 
    L = ['%s=%r' % (key, value)
21593 
      for key, value in self.__dict__.iteritems()]
21594 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
21595 
 
21596 
  def __eq__(self, other):
21597 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
21598 
 
21599 
  def __ne__(self, other):
21600 
    return not (self == other)
21601 
 
21602 
class savePaymentSettlements_args:
21603 
  """
21604 
  Attributes:
21605 
   - settlementDate
21606 
   - paymentGatewayId
4905 varun.gupt 21607 
   - referenceId
4600 varun.gupt 21608 
   - serviceTax
21609 
   - otherCharges
21610 
   - netCollection
21611 
  """
21612 
 
21613 
  thrift_spec = (
21614 
    None, # 0
21615 
    (1, TType.I64, 'settlementDate', None, None, ), # 1
21616 
    (2, TType.I64, 'paymentGatewayId', None, None, ), # 2
4905 varun.gupt 21617 
    (3, TType.I64, 'referenceId', None, None, ), # 3
4600 varun.gupt 21618 
    (4, TType.DOUBLE, 'serviceTax', None, None, ), # 4
21619 
    (5, TType.DOUBLE, 'otherCharges', None, None, ), # 5
21620 
    (6, TType.DOUBLE, 'netCollection', None, None, ), # 6
21621 
  )
21622 
 
4905 varun.gupt 21623 
  def __init__(self, settlementDate=None, paymentGatewayId=None, referenceId=None, serviceTax=None, otherCharges=None, netCollection=None,):
4600 varun.gupt 21624 
    self.settlementDate = settlementDate
21625 
    self.paymentGatewayId = paymentGatewayId
4905 varun.gupt 21626 
    self.referenceId = referenceId
4600 varun.gupt 21627 
    self.serviceTax = serviceTax
21628 
    self.otherCharges = otherCharges
21629 
    self.netCollection = netCollection
21630 
 
21631 
  def read(self, iprot):
21632 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
21633 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
21634 
      return
21635 
    iprot.readStructBegin()
21636 
    while True:
21637 
      (fname, ftype, fid) = iprot.readFieldBegin()
21638 
      if ftype == TType.STOP:
21639 
        break
21640 
      if fid == 1:
21641 
        if ftype == TType.I64:
21642 
          self.settlementDate = iprot.readI64();
21643 
        else:
21644 
          iprot.skip(ftype)
21645 
      elif fid == 2:
21646 
        if ftype == TType.I64:
21647 
          self.paymentGatewayId = iprot.readI64();
21648 
        else:
21649 
          iprot.skip(ftype)
21650 
      elif fid == 3:
21651 
        if ftype == TType.I64:
4905 varun.gupt 21652 
          self.referenceId = iprot.readI64();
4600 varun.gupt 21653 
        else:
21654 
          iprot.skip(ftype)
21655 
      elif fid == 4:
21656 
        if ftype == TType.DOUBLE:
21657 
          self.serviceTax = iprot.readDouble();
21658 
        else:
21659 
          iprot.skip(ftype)
21660 
      elif fid == 5:
21661 
        if ftype == TType.DOUBLE:
21662 
          self.otherCharges = iprot.readDouble();
21663 
        else:
21664 
          iprot.skip(ftype)
21665 
      elif fid == 6:
21666 
        if ftype == TType.DOUBLE:
21667 
          self.netCollection = iprot.readDouble();
21668 
        else:
21669 
          iprot.skip(ftype)
21670 
      else:
21671 
        iprot.skip(ftype)
21672 
      iprot.readFieldEnd()
21673 
    iprot.readStructEnd()
21674 
 
21675 
  def write(self, oprot):
21676 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
21677 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
21678 
      return
21679 
    oprot.writeStructBegin('savePaymentSettlements_args')
21680 
    if self.settlementDate is not None:
21681 
      oprot.writeFieldBegin('settlementDate', TType.I64, 1)
21682 
      oprot.writeI64(self.settlementDate)
21683 
      oprot.writeFieldEnd()
21684 
    if self.paymentGatewayId is not None:
21685 
      oprot.writeFieldBegin('paymentGatewayId', TType.I64, 2)
21686 
      oprot.writeI64(self.paymentGatewayId)
21687 
      oprot.writeFieldEnd()
4905 varun.gupt 21688 
    if self.referenceId is not None:
21689 
      oprot.writeFieldBegin('referenceId', TType.I64, 3)
21690 
      oprot.writeI64(self.referenceId)
4600 varun.gupt 21691 
      oprot.writeFieldEnd()
21692 
    if self.serviceTax is not None:
21693 
      oprot.writeFieldBegin('serviceTax', TType.DOUBLE, 4)
21694 
      oprot.writeDouble(self.serviceTax)
21695 
      oprot.writeFieldEnd()
21696 
    if self.otherCharges is not None:
21697 
      oprot.writeFieldBegin('otherCharges', TType.DOUBLE, 5)
21698 
      oprot.writeDouble(self.otherCharges)
21699 
      oprot.writeFieldEnd()
21700 
    if self.netCollection is not None:
21701 
      oprot.writeFieldBegin('netCollection', TType.DOUBLE, 6)
21702 
      oprot.writeDouble(self.netCollection)
21703 
      oprot.writeFieldEnd()
21704 
    oprot.writeFieldStop()
21705 
    oprot.writeStructEnd()
21706 
 
21707 
  def validate(self):
21708 
    return
21709 
 
21710 
 
21711 
  def __repr__(self):
21712 
    L = ['%s=%r' % (key, value)
21713 
      for key, value in self.__dict__.iteritems()]
21714 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
21715 
 
21716 
  def __eq__(self, other):
21717 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
21718 
 
21719 
  def __ne__(self, other):
21720 
    return not (self == other)
21721 
 
21722 
class savePaymentSettlements_result:
21723 
  """
21724 
  Attributes:
21725 
   - ex
21726 
  """
21727 
 
21728 
  thrift_spec = (
21729 
    None, # 0
21730 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
21731 
  )
21732 
 
21733 
  def __init__(self, ex=None,):
21734 
    self.ex = ex
21735 
 
21736 
  def read(self, iprot):
21737 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
21738 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
21739 
      return
21740 
    iprot.readStructBegin()
21741 
    while True:
21742 
      (fname, ftype, fid) = iprot.readFieldBegin()
21743 
      if ftype == TType.STOP:
21744 
        break
21745 
      if fid == 1:
21746 
        if ftype == TType.STRUCT:
21747 
          self.ex = TransactionServiceException()
21748 
          self.ex.read(iprot)
21749 
        else:
21750 
          iprot.skip(ftype)
21751 
      else:
21752 
        iprot.skip(ftype)
21753 
      iprot.readFieldEnd()
21754 
    iprot.readStructEnd()
21755 
 
21756 
  def write(self, oprot):
21757 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
21758 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
21759 
      return
21760 
    oprot.writeStructBegin('savePaymentSettlements_result')
21761 
    if self.ex is not None:
21762 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
21763 
      self.ex.write(oprot)
21764 
      oprot.writeFieldEnd()
21765 
    oprot.writeFieldStop()
21766 
    oprot.writeStructEnd()
21767 
 
21768 
  def validate(self):
21769 
    return
21770 
 
21771 
 
21772 
  def __repr__(self):
21773 
    L = ['%s=%r' % (key, value)
21774 
      for key, value in self.__dict__.iteritems()]
21775 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
21776 
 
21777 
  def __eq__(self, other):
21778 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
21779 
 
21780 
  def __ne__(self, other):
21781 
    return not (self == other)
21782 
 
21783 
class saveEBSSettlementSummary_args:
21784 
  """
21785 
  Attributes:
21786 
   - settlementId
21787 
   - settlementDate
21788 
   - transactionDateFrom
21789 
   - transactionDateTo
21790 
   - amount
21791 
  """
21792 
 
21793 
  thrift_spec = (
21794 
    None, # 0
21795 
    (1, TType.I64, 'settlementId', None, None, ), # 1
21796 
    (2, TType.I64, 'settlementDate', None, None, ), # 2
21797 
    (3, TType.I64, 'transactionDateFrom', None, None, ), # 3
21798 
    (4, TType.I64, 'transactionDateTo', None, None, ), # 4
21799 
    (5, TType.DOUBLE, 'amount', None, None, ), # 5
21800 
  )
21801 
 
21802 
  def __init__(self, settlementId=None, settlementDate=None, transactionDateFrom=None, transactionDateTo=None, amount=None,):
21803 
    self.settlementId = settlementId
21804 
    self.settlementDate = settlementDate
21805 
    self.transactionDateFrom = transactionDateFrom
21806 
    self.transactionDateTo = transactionDateTo
21807 
    self.amount = amount
21808 
 
21809 
  def read(self, iprot):
21810 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
21811 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
21812 
      return
21813 
    iprot.readStructBegin()
21814 
    while True:
21815 
      (fname, ftype, fid) = iprot.readFieldBegin()
21816 
      if ftype == TType.STOP:
21817 
        break
21818 
      if fid == 1:
21819 
        if ftype == TType.I64:
21820 
          self.settlementId = iprot.readI64();
21821 
        else:
21822 
          iprot.skip(ftype)
21823 
      elif fid == 2:
21824 
        if ftype == TType.I64:
21825 
          self.settlementDate = iprot.readI64();
21826 
        else:
21827 
          iprot.skip(ftype)
21828 
      elif fid == 3:
21829 
        if ftype == TType.I64:
21830 
          self.transactionDateFrom = iprot.readI64();
21831 
        else:
21832 
          iprot.skip(ftype)
21833 
      elif fid == 4:
21834 
        if ftype == TType.I64:
21835 
          self.transactionDateTo = iprot.readI64();
21836 
        else:
21837 
          iprot.skip(ftype)
21838 
      elif fid == 5:
21839 
        if ftype == TType.DOUBLE:
21840 
          self.amount = iprot.readDouble();
21841 
        else:
21842 
          iprot.skip(ftype)
21843 
      else:
21844 
        iprot.skip(ftype)
21845 
      iprot.readFieldEnd()
21846 
    iprot.readStructEnd()
21847 
 
21848 
  def write(self, oprot):
21849 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
21850 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
21851 
      return
21852 
    oprot.writeStructBegin('saveEBSSettlementSummary_args')
21853 
    if self.settlementId is not None:
21854 
      oprot.writeFieldBegin('settlementId', TType.I64, 1)
21855 
      oprot.writeI64(self.settlementId)
21856 
      oprot.writeFieldEnd()
21857 
    if self.settlementDate is not None:
21858 
      oprot.writeFieldBegin('settlementDate', TType.I64, 2)
21859 
      oprot.writeI64(self.settlementDate)
21860 
      oprot.writeFieldEnd()
21861 
    if self.transactionDateFrom is not None:
21862 
      oprot.writeFieldBegin('transactionDateFrom', TType.I64, 3)
21863 
      oprot.writeI64(self.transactionDateFrom)
21864 
      oprot.writeFieldEnd()
21865 
    if self.transactionDateTo is not None:
21866 
      oprot.writeFieldBegin('transactionDateTo', TType.I64, 4)
21867 
      oprot.writeI64(self.transactionDateTo)
21868 
      oprot.writeFieldEnd()
21869 
    if self.amount is not None:
21870 
      oprot.writeFieldBegin('amount', TType.DOUBLE, 5)
21871 
      oprot.writeDouble(self.amount)
21872 
      oprot.writeFieldEnd()
21873 
    oprot.writeFieldStop()
21874 
    oprot.writeStructEnd()
21875 
 
21876 
  def validate(self):
21877 
    return
21878 
 
21879 
 
21880 
  def __repr__(self):
21881 
    L = ['%s=%r' % (key, value)
21882 
      for key, value in self.__dict__.iteritems()]
21883 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
21884 
 
21885 
  def __eq__(self, other):
21886 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
21887 
 
21888 
  def __ne__(self, other):
21889 
    return not (self == other)
21890 
 
21891 
class saveEBSSettlementSummary_result:
21892 
  """
21893 
  Attributes:
21894 
   - ex
21895 
  """
21896 
 
21897 
  thrift_spec = (
21898 
    None, # 0
21899 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
21900 
  )
21901 
 
21902 
  def __init__(self, ex=None,):
21903 
    self.ex = ex
21904 
 
21905 
  def read(self, iprot):
21906 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
21907 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
21908 
      return
21909 
    iprot.readStructBegin()
21910 
    while True:
21911 
      (fname, ftype, fid) = iprot.readFieldBegin()
21912 
      if ftype == TType.STOP:
21913 
        break
21914 
      if fid == 1:
21915 
        if ftype == TType.STRUCT:
21916 
          self.ex = TransactionServiceException()
21917 
          self.ex.read(iprot)
21918 
        else:
21919 
          iprot.skip(ftype)
21920 
      else:
21921 
        iprot.skip(ftype)
21922 
      iprot.readFieldEnd()
21923 
    iprot.readStructEnd()
21924 
 
21925 
  def write(self, oprot):
21926 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
21927 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
21928 
      return
21929 
    oprot.writeStructBegin('saveEBSSettlementSummary_result')
21930 
    if self.ex is not None:
21931 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
21932 
      self.ex.write(oprot)
21933 
      oprot.writeFieldEnd()
21934 
    oprot.writeFieldStop()
21935 
    oprot.writeStructEnd()
21936 
 
21937 
  def validate(self):
21938 
    return
21939 
 
21940 
 
21941 
  def __repr__(self):
21942 
    L = ['%s=%r' % (key, value)
21943 
      for key, value in self.__dict__.iteritems()]
21944 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
21945 
 
21946 
  def __eq__(self, other):
21947 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
21948 
 
21949 
  def __ne__(self, other):
21950 
    return not (self == other)
21951 
 
5386 phani.kuma 21952 
class getSettlementForPrepaid_args:
4600 varun.gupt 21953 
  """
21954 
  Attributes:
5189 varun.gupt 21955 
   - referenceId
21956 
   - isRefund
4600 varun.gupt 21957 
  """
21958 
 
21959 
  thrift_spec = (
21960 
    None, # 0
5189 varun.gupt 21961 
    (1, TType.I64, 'referenceId', None, None, ), # 1
5386 phani.kuma 21962 
    (2, TType.BOOL, 'isRefund', None, None, ), # 2
4600 varun.gupt 21963 
  )
21964 
 
5386 phani.kuma 21965 
  def __init__(self, referenceId=None, isRefund=None,):
5189 varun.gupt 21966 
    self.referenceId = referenceId
21967 
    self.isRefund = isRefund
4600 varun.gupt 21968 
 
21969 
  def read(self, iprot):
21970 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
21971 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
21972 
      return
21973 
    iprot.readStructBegin()
21974 
    while True:
21975 
      (fname, ftype, fid) = iprot.readFieldBegin()
21976 
      if ftype == TType.STOP:
21977 
        break
21978 
      if fid == 1:
21979 
        if ftype == TType.I64:
5189 varun.gupt 21980 
          self.referenceId = iprot.readI64();
4600 varun.gupt 21981 
        else:
21982 
          iprot.skip(ftype)
5189 varun.gupt 21983 
      elif fid == 2:
21984 
        if ftype == TType.BOOL:
21985 
          self.isRefund = iprot.readBool();
21986 
        else:
21987 
          iprot.skip(ftype)
4600 varun.gupt 21988 
      else:
21989 
        iprot.skip(ftype)
21990 
      iprot.readFieldEnd()
21991 
    iprot.readStructEnd()
21992 
 
21993 
  def write(self, oprot):
21994 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
21995 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
21996 
      return
5386 phani.kuma 21997 
    oprot.writeStructBegin('getSettlementForPrepaid_args')
5189 varun.gupt 21998 
    if self.referenceId is not None:
21999 
      oprot.writeFieldBegin('referenceId', TType.I64, 1)
22000 
      oprot.writeI64(self.referenceId)
4600 varun.gupt 22001 
      oprot.writeFieldEnd()
5386 phani.kuma 22002 
    if self.isRefund is not None:
22003 
      oprot.writeFieldBegin('isRefund', TType.BOOL, 2)
22004 
      oprot.writeBool(self.isRefund)
5382 varun.gupt 22005 
      oprot.writeFieldEnd()
5386 phani.kuma 22006 
    oprot.writeFieldStop()
22007 
    oprot.writeStructEnd()
22008 
 
22009 
  def validate(self):
22010 
    return
22011 
 
22012 
 
22013 
  def __repr__(self):
22014 
    L = ['%s=%r' % (key, value)
22015 
      for key, value in self.__dict__.iteritems()]
22016 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
22017 
 
22018 
  def __eq__(self, other):
22019 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
22020 
 
22021 
  def __ne__(self, other):
22022 
    return not (self == other)
22023 
 
22024 
class getSettlementForPrepaid_result:
22025 
  """
22026 
  Attributes:
22027 
   - success
22028 
   - ex
22029 
  """
22030 
 
22031 
  thrift_spec = (
22032 
    (0, TType.STRUCT, 'success', (PaymentSettlement, PaymentSettlement.thrift_spec), None, ), # 0
22033 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
22034 
  )
22035 
 
22036 
  def __init__(self, success=None, ex=None,):
22037 
    self.success = success
22038 
    self.ex = ex
22039 
 
22040 
  def read(self, iprot):
22041 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
22042 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
22043 
      return
22044 
    iprot.readStructBegin()
22045 
    while True:
22046 
      (fname, ftype, fid) = iprot.readFieldBegin()
22047 
      if ftype == TType.STOP:
22048 
        break
22049 
      if fid == 0:
22050 
        if ftype == TType.STRUCT:
22051 
          self.success = PaymentSettlement()
22052 
          self.success.read(iprot)
22053 
        else:
22054 
          iprot.skip(ftype)
22055 
      elif fid == 1:
22056 
        if ftype == TType.STRUCT:
22057 
          self.ex = TransactionServiceException()
22058 
          self.ex.read(iprot)
22059 
        else:
22060 
          iprot.skip(ftype)
22061 
      else:
22062 
        iprot.skip(ftype)
22063 
      iprot.readFieldEnd()
22064 
    iprot.readStructEnd()
22065 
 
22066 
  def write(self, oprot):
22067 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
22068 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
22069 
      return
22070 
    oprot.writeStructBegin('getSettlementForPrepaid_result')
22071 
    if self.success is not None:
22072 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
22073 
      self.success.write(oprot)
22074 
      oprot.writeFieldEnd()
22075 
    if self.ex is not None:
22076 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
22077 
      self.ex.write(oprot)
22078 
      oprot.writeFieldEnd()
22079 
    oprot.writeFieldStop()
22080 
    oprot.writeStructEnd()
22081 
 
22082 
  def validate(self):
22083 
    return
22084 
 
22085 
 
22086 
  def __repr__(self):
22087 
    L = ['%s=%r' % (key, value)
22088 
      for key, value in self.__dict__.iteritems()]
22089 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
22090 
 
22091 
  def __eq__(self, other):
22092 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
22093 
 
22094 
  def __ne__(self, other):
22095 
    return not (self == other)
22096 
 
22097 
class getSettlementForCod_args:
22098 
  """
22099 
  Attributes:
22100 
   - orderId
22101 
   - isRefund
22102 
  """
22103 
 
22104 
  thrift_spec = (
22105 
    None, # 0
22106 
    (1, TType.I64, 'orderId', None, None, ), # 1
22107 
    (2, TType.BOOL, 'isRefund', None, None, ), # 2
22108 
  )
22109 
 
22110 
  def __init__(self, orderId=None, isRefund=None,):
22111 
    self.orderId = orderId
22112 
    self.isRefund = isRefund
22113 
 
22114 
  def read(self, iprot):
22115 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
22116 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
22117 
      return
22118 
    iprot.readStructBegin()
22119 
    while True:
22120 
      (fname, ftype, fid) = iprot.readFieldBegin()
22121 
      if ftype == TType.STOP:
22122 
        break
22123 
      if fid == 1:
22124 
        if ftype == TType.I64:
22125 
          self.orderId = iprot.readI64();
22126 
        else:
22127 
          iprot.skip(ftype)
22128 
      elif fid == 2:
22129 
        if ftype == TType.BOOL:
22130 
          self.isRefund = iprot.readBool();
22131 
        else:
22132 
          iprot.skip(ftype)
22133 
      else:
22134 
        iprot.skip(ftype)
22135 
      iprot.readFieldEnd()
22136 
    iprot.readStructEnd()
22137 
 
22138 
  def write(self, oprot):
22139 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
22140 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
22141 
      return
22142 
    oprot.writeStructBegin('getSettlementForCod_args')
22143 
    if self.orderId is not None:
22144 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
22145 
      oprot.writeI64(self.orderId)
22146 
      oprot.writeFieldEnd()
5189 varun.gupt 22147 
    if self.isRefund is not None:
5386 phani.kuma 22148 
      oprot.writeFieldBegin('isRefund', TType.BOOL, 2)
5189 varun.gupt 22149 
      oprot.writeBool(self.isRefund)
22150 
      oprot.writeFieldEnd()
4600 varun.gupt 22151 
    oprot.writeFieldStop()
22152 
    oprot.writeStructEnd()
22153 
 
22154 
  def validate(self):
22155 
    return
22156 
 
22157 
 
22158 
  def __repr__(self):
22159 
    L = ['%s=%r' % (key, value)
22160 
      for key, value in self.__dict__.iteritems()]
22161 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
22162 
 
22163 
  def __eq__(self, other):
22164 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
22165 
 
22166 
  def __ne__(self, other):
22167 
    return not (self == other)
22168 
 
5386 phani.kuma 22169 
class getSettlementForCod_result:
4600 varun.gupt 22170 
  """
22171 
  Attributes:
22172 
   - success
22173 
   - ex
22174 
  """
22175 
 
22176 
  thrift_spec = (
22177 
    (0, TType.STRUCT, 'success', (PaymentSettlement, PaymentSettlement.thrift_spec), None, ), # 0
22178 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
22179 
  )
22180 
 
22181 
  def __init__(self, success=None, ex=None,):
22182 
    self.success = success
22183 
    self.ex = ex
22184 
 
22185 
  def read(self, iprot):
22186 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
22187 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
22188 
      return
22189 
    iprot.readStructBegin()
22190 
    while True:
22191 
      (fname, ftype, fid) = iprot.readFieldBegin()
22192 
      if ftype == TType.STOP:
22193 
        break
22194 
      if fid == 0:
22195 
        if ftype == TType.STRUCT:
22196 
          self.success = PaymentSettlement()
22197 
          self.success.read(iprot)
22198 
        else:
22199 
          iprot.skip(ftype)
22200 
      elif fid == 1:
22201 
        if ftype == TType.STRUCT:
22202 
          self.ex = TransactionServiceException()
22203 
          self.ex.read(iprot)
22204 
        else:
22205 
          iprot.skip(ftype)
22206 
      else:
22207 
        iprot.skip(ftype)
22208 
      iprot.readFieldEnd()
22209 
    iprot.readStructEnd()
22210 
 
22211 
  def write(self, oprot):
22212 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
22213 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
22214 
      return
5386 phani.kuma 22215 
    oprot.writeStructBegin('getSettlementForCod_result')
4600 varun.gupt 22216 
    if self.success is not None:
22217 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
22218 
      self.success.write(oprot)
22219 
      oprot.writeFieldEnd()
22220 
    if self.ex is not None:
22221 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
22222 
      self.ex.write(oprot)
22223 
      oprot.writeFieldEnd()
22224 
    oprot.writeFieldStop()
22225 
    oprot.writeStructEnd()
22226 
 
22227 
  def validate(self):
22228 
    return
22229 
 
22230 
 
22231 
  def __repr__(self):
22232 
    L = ['%s=%r' % (key, value)
22233 
      for key, value in self.__dict__.iteritems()]
22234 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
22235 
 
22236 
  def __eq__(self, other):
22237 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
22238 
 
22239 
  def __ne__(self, other):
22240 
    return not (self == other)
22241 
 
22242 
class getEBSSettlementSummaries_args:
22243 
 
22244 
  thrift_spec = (
22245 
  )
22246 
 
22247 
  def read(self, iprot):
22248 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
22249 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
22250 
      return
22251 
    iprot.readStructBegin()
22252 
    while True:
22253 
      (fname, ftype, fid) = iprot.readFieldBegin()
22254 
      if ftype == TType.STOP:
22255 
        break
22256 
      else:
22257 
        iprot.skip(ftype)
22258 
      iprot.readFieldEnd()
22259 
    iprot.readStructEnd()
22260 
 
22261 
  def write(self, oprot):
22262 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
22263 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
22264 
      return
22265 
    oprot.writeStructBegin('getEBSSettlementSummaries_args')
22266 
    oprot.writeFieldStop()
22267 
    oprot.writeStructEnd()
22268 
 
22269 
  def validate(self):
22270 
    return
22271 
 
22272 
 
22273 
  def __repr__(self):
22274 
    L = ['%s=%r' % (key, value)
22275 
      for key, value in self.__dict__.iteritems()]
22276 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
22277 
 
22278 
  def __eq__(self, other):
22279 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
22280 
 
22281 
  def __ne__(self, other):
22282 
    return not (self == other)
22283 
 
22284 
class getEBSSettlementSummaries_result:
22285 
  """
22286 
  Attributes:
22287 
   - success
22288 
   - ex
22289 
  """
22290 
 
22291 
  thrift_spec = (
22292 
    (0, TType.MAP, 'success', (TType.I64,None,TType.STRING,None), None, ), # 0
22293 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
22294 
  )
22295 
 
22296 
  def __init__(self, success=None, ex=None,):
22297 
    self.success = success
22298 
    self.ex = ex
22299 
 
22300 
  def read(self, iprot):
22301 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
22302 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
22303 
      return
22304 
    iprot.readStructBegin()
22305 
    while True:
22306 
      (fname, ftype, fid) = iprot.readFieldBegin()
22307 
      if ftype == TType.STOP:
22308 
        break
22309 
      if fid == 0:
22310 
        if ftype == TType.MAP:
22311 
          self.success = {}
5676 rajveer 22312 
          (_ktype505, _vtype506, _size504 ) = iprot.readMapBegin()
22313 
          for _i508 in xrange(_size504):
22314 
            _key509 = iprot.readI64();
22315 
            _val510 = iprot.readString();
22316 
            self.success[_key509] = _val510
4600 varun.gupt 22317 
          iprot.readMapEnd()
22318 
        else:
22319 
          iprot.skip(ftype)
22320 
      elif fid == 1:
22321 
        if ftype == TType.STRUCT:
22322 
          self.ex = TransactionServiceException()
22323 
          self.ex.read(iprot)
22324 
        else:
22325 
          iprot.skip(ftype)
22326 
      else:
22327 
        iprot.skip(ftype)
22328 
      iprot.readFieldEnd()
22329 
    iprot.readStructEnd()
22330 
 
22331 
  def write(self, oprot):
22332 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
22333 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
22334 
      return
22335 
    oprot.writeStructBegin('getEBSSettlementSummaries_result')
22336 
    if self.success is not None:
22337 
      oprot.writeFieldBegin('success', TType.MAP, 0)
22338 
      oprot.writeMapBegin(TType.I64, TType.STRING, len(self.success))
5676 rajveer 22339 
      for kiter511,viter512 in self.success.items():
22340 
        oprot.writeI64(kiter511)
22341 
        oprot.writeString(viter512)
4600 varun.gupt 22342 
      oprot.writeMapEnd()
22343 
      oprot.writeFieldEnd()
22344 
    if self.ex is not None:
22345 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
22346 
      self.ex.write(oprot)
22347 
      oprot.writeFieldEnd()
22348 
    oprot.writeFieldStop()
22349 
    oprot.writeStructEnd()
22350 
 
22351 
  def validate(self):
22352 
    return
22353 
 
22354 
 
22355 
  def __repr__(self):
22356 
    L = ['%s=%r' % (key, value)
22357 
      for key, value in self.__dict__.iteritems()]
22358 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
22359 
 
22360 
  def __eq__(self, other):
22361 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
22362 
 
22363 
  def __ne__(self, other):
22364 
    return not (self == other)
22365 
 
22366 
class markEBSSettlementUploaded_args:
22367 
  """
22368 
  Attributes:
22369 
   - settlementId
22370 
  """
22371 
 
22372 
  thrift_spec = (
22373 
    None, # 0
22374 
    (1, TType.I64, 'settlementId', None, None, ), # 1
22375 
  )
22376 
 
22377 
  def __init__(self, settlementId=None,):
22378 
    self.settlementId = settlementId
22379 
 
22380 
  def read(self, iprot):
22381 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
22382 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
22383 
      return
22384 
    iprot.readStructBegin()
22385 
    while True:
22386 
      (fname, ftype, fid) = iprot.readFieldBegin()
22387 
      if ftype == TType.STOP:
22388 
        break
22389 
      if fid == 1:
22390 
        if ftype == TType.I64:
22391 
          self.settlementId = iprot.readI64();
22392 
        else:
22393 
          iprot.skip(ftype)
22394 
      else:
22395 
        iprot.skip(ftype)
22396 
      iprot.readFieldEnd()
22397 
    iprot.readStructEnd()
22398 
 
22399 
  def write(self, oprot):
22400 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
22401 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
22402 
      return
22403 
    oprot.writeStructBegin('markEBSSettlementUploaded_args')
22404 
    if self.settlementId is not None:
22405 
      oprot.writeFieldBegin('settlementId', TType.I64, 1)
22406 
      oprot.writeI64(self.settlementId)
22407 
      oprot.writeFieldEnd()
22408 
    oprot.writeFieldStop()
22409 
    oprot.writeStructEnd()
22410 
 
22411 
  def validate(self):
22412 
    return
22413 
 
22414 
 
22415 
  def __repr__(self):
22416 
    L = ['%s=%r' % (key, value)
22417 
      for key, value in self.__dict__.iteritems()]
22418 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
22419 
 
22420 
  def __eq__(self, other):
22421 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
22422 
 
22423 
  def __ne__(self, other):
22424 
    return not (self == other)
22425 
 
22426 
class markEBSSettlementUploaded_result:
22427 
  """
22428 
  Attributes:
22429 
   - ex
22430 
  """
22431 
 
22432 
  thrift_spec = (
22433 
    None, # 0
22434 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
22435 
  )
22436 
 
22437 
  def __init__(self, ex=None,):
22438 
    self.ex = ex
22439 
 
22440 
  def read(self, iprot):
22441 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
22442 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
22443 
      return
22444 
    iprot.readStructBegin()
22445 
    while True:
22446 
      (fname, ftype, fid) = iprot.readFieldBegin()
22447 
      if ftype == TType.STOP:
22448 
        break
22449 
      if fid == 1:
22450 
        if ftype == TType.STRUCT:
22451 
          self.ex = TransactionServiceException()
22452 
          self.ex.read(iprot)
22453 
        else:
22454 
          iprot.skip(ftype)
22455 
      else:
22456 
        iprot.skip(ftype)
22457 
      iprot.readFieldEnd()
22458 
    iprot.readStructEnd()
22459 
 
22460 
  def write(self, oprot):
22461 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
22462 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
22463 
      return
22464 
    oprot.writeStructBegin('markEBSSettlementUploaded_result')
22465 
    if self.ex is not None:
22466 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
22467 
      self.ex.write(oprot)
22468 
      oprot.writeFieldEnd()
22469 
    oprot.writeFieldStop()
22470 
    oprot.writeStructEnd()
22471 
 
22472 
  def validate(self):
22473 
    return
22474 
 
22475 
 
22476 
  def __repr__(self):
22477 
    L = ['%s=%r' % (key, value)
22478 
      for key, value in self.__dict__.iteritems()]
22479 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
22480 
 
22481 
  def __eq__(self, other):
22482 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
22483 
 
22484 
  def __ne__(self, other):
22485 
    return not (self == other)
22486 
 
22487 
class getEBSSettlementDate_args:
22488 
  """
22489 
  Attributes:
22490 
   - settlementId
22491 
  """
22492 
 
22493 
  thrift_spec = (
22494 
    None, # 0
22495 
    (1, TType.I64, 'settlementId', None, None, ), # 1
22496 
  )
22497 
 
22498 
  def __init__(self, settlementId=None,):
22499 
    self.settlementId = settlementId
22500 
 
22501 
  def read(self, iprot):
22502 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
22503 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
22504 
      return
22505 
    iprot.readStructBegin()
22506 
    while True:
22507 
      (fname, ftype, fid) = iprot.readFieldBegin()
22508 
      if ftype == TType.STOP:
22509 
        break
22510 
      if fid == 1:
22511 
        if ftype == TType.I64:
22512 
          self.settlementId = iprot.readI64();
22513 
        else:
22514 
          iprot.skip(ftype)
22515 
      else:
22516 
        iprot.skip(ftype)
22517 
      iprot.readFieldEnd()
22518 
    iprot.readStructEnd()
22519 
 
22520 
  def write(self, oprot):
22521 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
22522 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
22523 
      return
22524 
    oprot.writeStructBegin('getEBSSettlementDate_args')
22525 
    if self.settlementId is not None:
22526 
      oprot.writeFieldBegin('settlementId', TType.I64, 1)
22527 
      oprot.writeI64(self.settlementId)
22528 
      oprot.writeFieldEnd()
22529 
    oprot.writeFieldStop()
22530 
    oprot.writeStructEnd()
22531 
 
22532 
  def validate(self):
22533 
    return
22534 
 
22535 
 
22536 
  def __repr__(self):
22537 
    L = ['%s=%r' % (key, value)
22538 
      for key, value in self.__dict__.iteritems()]
22539 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
22540 
 
22541 
  def __eq__(self, other):
22542 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
22543 
 
22544 
  def __ne__(self, other):
22545 
    return not (self == other)
22546 
 
22547 
class getEBSSettlementDate_result:
22548 
  """
22549 
  Attributes:
22550 
   - success
22551 
   - ex
22552 
  """
22553 
 
22554 
  thrift_spec = (
22555 
    (0, TType.I64, 'success', None, None, ), # 0
22556 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
22557 
  )
22558 
 
22559 
  def __init__(self, success=None, ex=None,):
22560 
    self.success = success
22561 
    self.ex = ex
22562 
 
22563 
  def read(self, iprot):
22564 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
22565 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
22566 
      return
22567 
    iprot.readStructBegin()
22568 
    while True:
22569 
      (fname, ftype, fid) = iprot.readFieldBegin()
22570 
      if ftype == TType.STOP:
22571 
        break
22572 
      if fid == 0:
22573 
        if ftype == TType.I64:
22574 
          self.success = iprot.readI64();
22575 
        else:
22576 
          iprot.skip(ftype)
22577 
      elif fid == 1:
22578 
        if ftype == TType.STRUCT:
22579 
          self.ex = TransactionServiceException()
22580 
          self.ex.read(iprot)
22581 
        else:
22582 
          iprot.skip(ftype)
22583 
      else:
22584 
        iprot.skip(ftype)
22585 
      iprot.readFieldEnd()
22586 
    iprot.readStructEnd()
22587 
 
22588 
  def write(self, oprot):
22589 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
22590 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
22591 
      return
22592 
    oprot.writeStructBegin('getEBSSettlementDate_result')
22593 
    if self.success is not None:
22594 
      oprot.writeFieldBegin('success', TType.I64, 0)
22595 
      oprot.writeI64(self.success)
22596 
      oprot.writeFieldEnd()
22597 
    if self.ex is not None:
22598 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
22599 
      self.ex.write(oprot)
22600 
      oprot.writeFieldEnd()
22601 
    oprot.writeFieldStop()
22602 
    oprot.writeStructEnd()
22603 
 
22604 
  def validate(self):
22605 
    return
22606 
 
22607 
 
22608 
  def __repr__(self):
22609 
    L = ['%s=%r' % (key, value)
22610 
      for key, value in self.__dict__.iteritems()]
22611 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
22612 
 
22613 
  def __eq__(self, other):
22614 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
22615 
 
22616 
  def __ne__(self, other):
22617 
    return not (self == other)
4715 varun.gupt 22618 
 
22619 
class getSettlementsByDate_args:
22620 
  """
22621 
  Attributes:
22622 
   - settlementDateFrom
22623 
   - settlementDateTo
22624 
   - isRefund
22625 
  """
22626 
 
22627 
  thrift_spec = (
22628 
    None, # 0
22629 
    (1, TType.I64, 'settlementDateFrom', None, None, ), # 1
22630 
    (2, TType.I64, 'settlementDateTo', None, None, ), # 2
22631 
    (3, TType.BOOL, 'isRefund', None, None, ), # 3
22632 
  )
22633 
 
22634 
  def __init__(self, settlementDateFrom=None, settlementDateTo=None, isRefund=None,):
22635 
    self.settlementDateFrom = settlementDateFrom
22636 
    self.settlementDateTo = settlementDateTo
22637 
    self.isRefund = isRefund
22638 
 
22639 
  def read(self, iprot):
22640 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
22641 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
22642 
      return
22643 
    iprot.readStructBegin()
22644 
    while True:
22645 
      (fname, ftype, fid) = iprot.readFieldBegin()
22646 
      if ftype == TType.STOP:
22647 
        break
22648 
      if fid == 1:
22649 
        if ftype == TType.I64:
22650 
          self.settlementDateFrom = iprot.readI64();
22651 
        else:
22652 
          iprot.skip(ftype)
22653 
      elif fid == 2:
22654 
        if ftype == TType.I64:
22655 
          self.settlementDateTo = iprot.readI64();
22656 
        else:
22657 
          iprot.skip(ftype)
22658 
      elif fid == 3:
22659 
        if ftype == TType.BOOL:
22660 
          self.isRefund = iprot.readBool();
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('getSettlementsByDate_args')
22673 
    if self.settlementDateFrom is not None:
22674 
      oprot.writeFieldBegin('settlementDateFrom', TType.I64, 1)
22675 
      oprot.writeI64(self.settlementDateFrom)
22676 
      oprot.writeFieldEnd()
22677 
    if self.settlementDateTo is not None:
22678 
      oprot.writeFieldBegin('settlementDateTo', TType.I64, 2)
22679 
      oprot.writeI64(self.settlementDateTo)
22680 
      oprot.writeFieldEnd()
22681 
    if self.isRefund is not None:
22682 
      oprot.writeFieldBegin('isRefund', TType.BOOL, 3)
22683 
      oprot.writeBool(self.isRefund)
22684 
      oprot.writeFieldEnd()
22685 
    oprot.writeFieldStop()
22686 
    oprot.writeStructEnd()
22687 
 
22688 
  def validate(self):
22689 
    return
22690 
 
22691 
 
22692 
  def __repr__(self):
22693 
    L = ['%s=%r' % (key, value)
22694 
      for key, value in self.__dict__.iteritems()]
22695 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
22696 
 
22697 
  def __eq__(self, other):
22698 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
22699 
 
22700 
  def __ne__(self, other):
22701 
    return not (self == other)
22702 
 
22703 
class getSettlementsByDate_result:
22704 
  """
22705 
  Attributes:
22706 
   - success
22707 
   - ex
22708 
  """
22709 
 
22710 
  thrift_spec = (
22711 
    (0, TType.LIST, 'success', (TType.STRUCT,(PaymentSettlement, PaymentSettlement.thrift_spec)), None, ), # 0
22712 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
22713 
  )
22714 
 
22715 
  def __init__(self, success=None, ex=None,):
22716 
    self.success = success
22717 
    self.ex = ex
22718 
 
22719 
  def read(self, iprot):
22720 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
22721 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
22722 
      return
22723 
    iprot.readStructBegin()
22724 
    while True:
22725 
      (fname, ftype, fid) = iprot.readFieldBegin()
22726 
      if ftype == TType.STOP:
22727 
        break
22728 
      if fid == 0:
22729 
        if ftype == TType.LIST:
22730 
          self.success = []
5676 rajveer 22731 
          (_etype516, _size513) = iprot.readListBegin()
22732 
          for _i517 in xrange(_size513):
22733 
            _elem518 = PaymentSettlement()
22734 
            _elem518.read(iprot)
22735 
            self.success.append(_elem518)
4715 varun.gupt 22736 
          iprot.readListEnd()
22737 
        else:
22738 
          iprot.skip(ftype)
22739 
      elif fid == 1:
22740 
        if ftype == TType.STRUCT:
22741 
          self.ex = TransactionServiceException()
22742 
          self.ex.read(iprot)
22743 
        else:
22744 
          iprot.skip(ftype)
22745 
      else:
22746 
        iprot.skip(ftype)
22747 
      iprot.readFieldEnd()
22748 
    iprot.readStructEnd()
22749 
 
22750 
  def write(self, oprot):
22751 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
22752 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
22753 
      return
22754 
    oprot.writeStructBegin('getSettlementsByDate_result')
22755 
    if self.success is not None:
22756 
      oprot.writeFieldBegin('success', TType.LIST, 0)
22757 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
5676 rajveer 22758 
      for iter519 in self.success:
22759 
        iter519.write(oprot)
4715 varun.gupt 22760 
      oprot.writeListEnd()
22761 
      oprot.writeFieldEnd()
22762 
    if self.ex is not None:
22763 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
22764 
      self.ex.write(oprot)
22765 
      oprot.writeFieldEnd()
22766 
    oprot.writeFieldStop()
22767 
    oprot.writeStructEnd()
22768 
 
22769 
  def validate(self):
22770 
    return
22771 
 
22772 
 
22773 
  def __repr__(self):
22774 
    L = ['%s=%r' % (key, value)
22775 
      for key, value in self.__dict__.iteritems()]
22776 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
22777 
 
22778 
  def __eq__(self, other):
22779 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
22780 
 
22781 
  def __ne__(self, other):
22782 
    return not (self == other)
22783 
 
22784 
class getReshippedOrderIds_args:
22785 
  """
22786 
  Attributes:
22787 
   - orderIds
22788 
  """
22789 
 
22790 
  thrift_spec = (
22791 
    None, # 0
22792 
    (1, TType.LIST, 'orderIds', (TType.I64,None), None, ), # 1
22793 
  )
22794 
 
22795 
  def __init__(self, orderIds=None,):
22796 
    self.orderIds = orderIds
22797 
 
22798 
  def read(self, iprot):
22799 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
22800 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
22801 
      return
22802 
    iprot.readStructBegin()
22803 
    while True:
22804 
      (fname, ftype, fid) = iprot.readFieldBegin()
22805 
      if ftype == TType.STOP:
22806 
        break
22807 
      if fid == 1:
22808 
        if ftype == TType.LIST:
22809 
          self.orderIds = []
5676 rajveer 22810 
          (_etype523, _size520) = iprot.readListBegin()
22811 
          for _i524 in xrange(_size520):
22812 
            _elem525 = iprot.readI64();
22813 
            self.orderIds.append(_elem525)
4715 varun.gupt 22814 
          iprot.readListEnd()
22815 
        else:
22816 
          iprot.skip(ftype)
22817 
      else:
22818 
        iprot.skip(ftype)
22819 
      iprot.readFieldEnd()
22820 
    iprot.readStructEnd()
22821 
 
22822 
  def write(self, oprot):
22823 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
22824 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
22825 
      return
22826 
    oprot.writeStructBegin('getReshippedOrderIds_args')
22827 
    if self.orderIds is not None:
22828 
      oprot.writeFieldBegin('orderIds', TType.LIST, 1)
22829 
      oprot.writeListBegin(TType.I64, len(self.orderIds))
5676 rajveer 22830 
      for iter526 in self.orderIds:
22831 
        oprot.writeI64(iter526)
4715 varun.gupt 22832 
      oprot.writeListEnd()
22833 
      oprot.writeFieldEnd()
22834 
    oprot.writeFieldStop()
22835 
    oprot.writeStructEnd()
22836 
 
22837 
  def validate(self):
22838 
    return
22839 
 
22840 
 
22841 
  def __repr__(self):
22842 
    L = ['%s=%r' % (key, value)
22843 
      for key, value in self.__dict__.iteritems()]
22844 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
22845 
 
22846 
  def __eq__(self, other):
22847 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
22848 
 
22849 
  def __ne__(self, other):
22850 
    return not (self == other)
22851 
 
22852 
class getReshippedOrderIds_result:
22853 
  """
22854 
  Attributes:
22855 
   - success
22856 
   - ex
22857 
  """
22858 
 
22859 
  thrift_spec = (
22860 
    (0, TType.LIST, 'success', (TType.I64,None), None, ), # 0
22861 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
22862 
  )
22863 
 
22864 
  def __init__(self, success=None, ex=None,):
22865 
    self.success = success
22866 
    self.ex = ex
22867 
 
22868 
  def read(self, iprot):
22869 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
22870 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
22871 
      return
22872 
    iprot.readStructBegin()
22873 
    while True:
22874 
      (fname, ftype, fid) = iprot.readFieldBegin()
22875 
      if ftype == TType.STOP:
22876 
        break
22877 
      if fid == 0:
22878 
        if ftype == TType.LIST:
22879 
          self.success = []
5676 rajveer 22880 
          (_etype530, _size527) = iprot.readListBegin()
22881 
          for _i531 in xrange(_size527):
22882 
            _elem532 = iprot.readI64();
22883 
            self.success.append(_elem532)
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('getReshippedOrderIds_result')
22903 
    if self.success is not None:
22904 
      oprot.writeFieldBegin('success', TType.LIST, 0)
22905 
      oprot.writeListBegin(TType.I64, len(self.success))
5676 rajveer 22906 
      for iter533 in self.success:
22907 
        oprot.writeI64(iter533)
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)
4757 mandeep.dh 22931 
 
5481 phani.kuma 22932 
class getBilledOrders_args:
4875 varun.gupt 22933 
  """
22934 
  Attributes:
22935 
   - vendorId
5481 phani.kuma 22936 
   - onlyVendorNotPaid
22937 
   - billingDateFrom
22938 
   - billingDateTo
4875 varun.gupt 22939 
  """
22940 
 
22941 
  thrift_spec = (
22942 
    None, # 0
22943 
    (1, TType.I64, 'vendorId', None, None, ), # 1
5481 phani.kuma 22944 
    (2, TType.BOOL, 'onlyVendorNotPaid', None, None, ), # 2
22945 
    (3, TType.I64, 'billingDateFrom', None, None, ), # 3
22946 
    (4, TType.I64, 'billingDateTo', None, None, ), # 4
4875 varun.gupt 22947 
  )
22948 
 
5481 phani.kuma 22949 
  def __init__(self, vendorId=None, onlyVendorNotPaid=None, billingDateFrom=None, billingDateTo=None,):
4875 varun.gupt 22950 
    self.vendorId = vendorId
5481 phani.kuma 22951 
    self.onlyVendorNotPaid = onlyVendorNotPaid
22952 
    self.billingDateFrom = billingDateFrom
22953 
    self.billingDateTo = billingDateTo
4875 varun.gupt 22954 
 
22955 
  def read(self, iprot):
22956 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
22957 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
22958 
      return
22959 
    iprot.readStructBegin()
22960 
    while True:
22961 
      (fname, ftype, fid) = iprot.readFieldBegin()
22962 
      if ftype == TType.STOP:
22963 
        break
22964 
      if fid == 1:
22965 
        if ftype == TType.I64:
22966 
          self.vendorId = iprot.readI64();
22967 
        else:
22968 
          iprot.skip(ftype)
5481 phani.kuma 22969 
      elif fid == 2:
22970 
        if ftype == TType.BOOL:
22971 
          self.onlyVendorNotPaid = iprot.readBool();
22972 
        else:
22973 
          iprot.skip(ftype)
22974 
      elif fid == 3:
22975 
        if ftype == TType.I64:
22976 
          self.billingDateFrom = iprot.readI64();
22977 
        else:
22978 
          iprot.skip(ftype)
22979 
      elif fid == 4:
22980 
        if ftype == TType.I64:
22981 
          self.billingDateTo = iprot.readI64();
22982 
        else:
22983 
          iprot.skip(ftype)
4875 varun.gupt 22984 
      else:
22985 
        iprot.skip(ftype)
22986 
      iprot.readFieldEnd()
22987 
    iprot.readStructEnd()
22988 
 
22989 
  def write(self, oprot):
22990 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
22991 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
22992 
      return
5481 phani.kuma 22993 
    oprot.writeStructBegin('getBilledOrders_args')
4875 varun.gupt 22994 
    if self.vendorId is not None:
22995 
      oprot.writeFieldBegin('vendorId', TType.I64, 1)
22996 
      oprot.writeI64(self.vendorId)
22997 
      oprot.writeFieldEnd()
5481 phani.kuma 22998 
    if self.onlyVendorNotPaid is not None:
22999 
      oprot.writeFieldBegin('onlyVendorNotPaid', TType.BOOL, 2)
23000 
      oprot.writeBool(self.onlyVendorNotPaid)
23001 
      oprot.writeFieldEnd()
23002 
    if self.billingDateFrom is not None:
23003 
      oprot.writeFieldBegin('billingDateFrom', TType.I64, 3)
23004 
      oprot.writeI64(self.billingDateFrom)
23005 
      oprot.writeFieldEnd()
23006 
    if self.billingDateTo is not None:
23007 
      oprot.writeFieldBegin('billingDateTo', TType.I64, 4)
23008 
      oprot.writeI64(self.billingDateTo)
23009 
      oprot.writeFieldEnd()
4875 varun.gupt 23010 
    oprot.writeFieldStop()
23011 
    oprot.writeStructEnd()
23012 
 
23013 
  def validate(self):
23014 
    return
23015 
 
23016 
 
23017 
  def __repr__(self):
23018 
    L = ['%s=%r' % (key, value)
23019 
      for key, value in self.__dict__.iteritems()]
23020 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
23021 
 
23022 
  def __eq__(self, other):
23023 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
23024 
 
23025 
  def __ne__(self, other):
23026 
    return not (self == other)
23027 
 
5481 phani.kuma 23028 
class getBilledOrders_result:
4875 varun.gupt 23029 
  """
23030 
  Attributes:
23031 
   - success
23032 
   - ex
23033 
  """
23034 
 
23035 
  thrift_spec = (
23036 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
23037 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
23038 
  )
23039 
 
23040 
  def __init__(self, success=None, ex=None,):
23041 
    self.success = success
23042 
    self.ex = ex
23043 
 
23044 
  def read(self, iprot):
23045 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
23046 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
23047 
      return
23048 
    iprot.readStructBegin()
23049 
    while True:
23050 
      (fname, ftype, fid) = iprot.readFieldBegin()
23051 
      if ftype == TType.STOP:
23052 
        break
23053 
      if fid == 0:
23054 
        if ftype == TType.LIST:
23055 
          self.success = []
5676 rajveer 23056 
          (_etype537, _size534) = iprot.readListBegin()
23057 
          for _i538 in xrange(_size534):
23058 
            _elem539 = Order()
23059 
            _elem539.read(iprot)
23060 
            self.success.append(_elem539)
4875 varun.gupt 23061 
          iprot.readListEnd()
23062 
        else:
23063 
          iprot.skip(ftype)
23064 
      elif fid == 1:
23065 
        if ftype == TType.STRUCT:
23066 
          self.ex = TransactionServiceException()
23067 
          self.ex.read(iprot)
23068 
        else:
23069 
          iprot.skip(ftype)
23070 
      else:
23071 
        iprot.skip(ftype)
23072 
      iprot.readFieldEnd()
23073 
    iprot.readStructEnd()
23074 
 
23075 
  def write(self, oprot):
23076 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
23077 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
23078 
      return
5481 phani.kuma 23079 
    oprot.writeStructBegin('getBilledOrders_result')
4875 varun.gupt 23080 
    if self.success is not None:
23081 
      oprot.writeFieldBegin('success', TType.LIST, 0)
23082 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
5676 rajveer 23083 
      for iter540 in self.success:
23084 
        iter540.write(oprot)
4875 varun.gupt 23085 
      oprot.writeListEnd()
23086 
      oprot.writeFieldEnd()
23087 
    if self.ex is not None:
23088 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
23089 
      self.ex.write(oprot)
23090 
      oprot.writeFieldEnd()
23091 
    oprot.writeFieldStop()
23092 
    oprot.writeStructEnd()
23093 
 
23094 
  def validate(self):
23095 
    return
23096 
 
23097 
 
23098 
  def __repr__(self):
23099 
    L = ['%s=%r' % (key, value)
23100 
      for key, value in self.__dict__.iteritems()]
23101 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
23102 
 
23103 
  def __eq__(self, other):
23104 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
23105 
 
23106 
  def __ne__(self, other):
23107 
    return not (self == other)
5031 varun.gupt 23108 
 
23109 
class getStatusDistributionOfOrders_args:
23110 
  """
23111 
  Attributes:
23112 
   - startDate
23113 
   - endDate
23114 
  """
23115 
 
23116 
  thrift_spec = (
23117 
    None, # 0
23118 
    (1, TType.I64, 'startDate', None, None, ), # 1
23119 
    (2, TType.I64, 'endDate', None, None, ), # 2
23120 
  )
23121 
 
23122 
  def __init__(self, startDate=None, endDate=None,):
23123 
    self.startDate = startDate
23124 
    self.endDate = endDate
23125 
 
23126 
  def read(self, iprot):
23127 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
23128 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
23129 
      return
23130 
    iprot.readStructBegin()
23131 
    while True:
23132 
      (fname, ftype, fid) = iprot.readFieldBegin()
23133 
      if ftype == TType.STOP:
23134 
        break
23135 
      if fid == 1:
23136 
        if ftype == TType.I64:
23137 
          self.startDate = iprot.readI64();
23138 
        else:
23139 
          iprot.skip(ftype)
23140 
      elif fid == 2:
23141 
        if ftype == TType.I64:
23142 
          self.endDate = iprot.readI64();
23143 
        else:
23144 
          iprot.skip(ftype)
23145 
      else:
23146 
        iprot.skip(ftype)
23147 
      iprot.readFieldEnd()
23148 
    iprot.readStructEnd()
23149 
 
23150 
  def write(self, oprot):
23151 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
23152 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
23153 
      return
23154 
    oprot.writeStructBegin('getStatusDistributionOfOrders_args')
23155 
    if self.startDate is not None:
23156 
      oprot.writeFieldBegin('startDate', TType.I64, 1)
23157 
      oprot.writeI64(self.startDate)
23158 
      oprot.writeFieldEnd()
23159 
    if self.endDate is not None:
23160 
      oprot.writeFieldBegin('endDate', TType.I64, 2)
23161 
      oprot.writeI64(self.endDate)
23162 
      oprot.writeFieldEnd()
23163 
    oprot.writeFieldStop()
23164 
    oprot.writeStructEnd()
23165 
 
23166 
  def validate(self):
23167 
    return
23168 
 
23169 
 
23170 
  def __repr__(self):
23171 
    L = ['%s=%r' % (key, value)
23172 
      for key, value in self.__dict__.iteritems()]
23173 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
23174 
 
23175 
  def __eq__(self, other):
23176 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
23177 
 
23178 
  def __ne__(self, other):
23179 
    return not (self == other)
23180 
 
23181 
class getStatusDistributionOfOrders_result:
23182 
  """
23183 
  Attributes:
23184 
   - success
23185 
   - ex
23186 
  """
23187 
 
23188 
  thrift_spec = (
23189 
    (0, TType.MAP, 'success', (TType.I64,None,TType.I64,None), None, ), # 0
23190 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
23191 
  )
23192 
 
23193 
  def __init__(self, success=None, ex=None,):
23194 
    self.success = success
23195 
    self.ex = ex
23196 
 
23197 
  def read(self, iprot):
23198 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
23199 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
23200 
      return
23201 
    iprot.readStructBegin()
23202 
    while True:
23203 
      (fname, ftype, fid) = iprot.readFieldBegin()
23204 
      if ftype == TType.STOP:
23205 
        break
23206 
      if fid == 0:
23207 
        if ftype == TType.MAP:
23208 
          self.success = {}
5676 rajveer 23209 
          (_ktype542, _vtype543, _size541 ) = iprot.readMapBegin()
23210 
          for _i545 in xrange(_size541):
23211 
            _key546 = iprot.readI64();
23212 
            _val547 = iprot.readI64();
23213 
            self.success[_key546] = _val547
5031 varun.gupt 23214 
          iprot.readMapEnd()
23215 
        else:
23216 
          iprot.skip(ftype)
23217 
      elif fid == 1:
23218 
        if ftype == TType.STRUCT:
23219 
          self.ex = TransactionServiceException()
23220 
          self.ex.read(iprot)
23221 
        else:
23222 
          iprot.skip(ftype)
23223 
      else:
23224 
        iprot.skip(ftype)
23225 
      iprot.readFieldEnd()
23226 
    iprot.readStructEnd()
23227 
 
23228 
  def write(self, oprot):
23229 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
23230 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
23231 
      return
23232 
    oprot.writeStructBegin('getStatusDistributionOfOrders_result')
23233 
    if self.success is not None:
23234 
      oprot.writeFieldBegin('success', TType.MAP, 0)
23235 
      oprot.writeMapBegin(TType.I64, TType.I64, len(self.success))
5676 rajveer 23236 
      for kiter548,viter549 in self.success.items():
23237 
        oprot.writeI64(kiter548)
23238 
        oprot.writeI64(viter549)
5031 varun.gupt 23239 
      oprot.writeMapEnd()
23240 
      oprot.writeFieldEnd()
23241 
    if self.ex is not None:
23242 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
23243 
      self.ex.write(oprot)
23244 
      oprot.writeFieldEnd()
23245 
    oprot.writeFieldStop()
23246 
    oprot.writeStructEnd()
23247 
 
23248 
  def validate(self):
23249 
    return
23250 
 
23251 
 
23252 
  def __repr__(self):
23253 
    L = ['%s=%r' % (key, value)
23254 
      for key, value in self.__dict__.iteritems()]
23255 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
23256 
 
23257 
  def __eq__(self, other):
23258 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
23259 
 
23260 
  def __ne__(self, other):
23261 
    return not (self == other)
5067 varun.gupt 23262 
 
23263 
class getOrderIdsForStatus_args:
23264 
  """
23265 
  Attributes:
23266 
   - status
23267 
   - startDatetime
23268 
   - endDatetime
23269 
  """
23270 
 
23271 
  thrift_spec = (
23272 
    None, # 0
23273 
    (1, TType.I64, 'status', None, None, ), # 1
23274 
    (2, TType.I64, 'startDatetime', None, None, ), # 2
23275 
    (3, TType.I64, 'endDatetime', None, None, ), # 3
23276 
  )
23277 
 
23278 
  def __init__(self, status=None, startDatetime=None, endDatetime=None,):
23279 
    self.status = status
23280 
    self.startDatetime = startDatetime
23281 
    self.endDatetime = endDatetime
23282 
 
23283 
  def read(self, iprot):
23284 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
23285 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
23286 
      return
23287 
    iprot.readStructBegin()
23288 
    while True:
23289 
      (fname, ftype, fid) = iprot.readFieldBegin()
23290 
      if ftype == TType.STOP:
23291 
        break
23292 
      if fid == 1:
23293 
        if ftype == TType.I64:
23294 
          self.status = iprot.readI64();
23295 
        else:
23296 
          iprot.skip(ftype)
23297 
      elif fid == 2:
23298 
        if ftype == TType.I64:
23299 
          self.startDatetime = iprot.readI64();
23300 
        else:
23301 
          iprot.skip(ftype)
23302 
      elif fid == 3:
23303 
        if ftype == TType.I64:
23304 
          self.endDatetime = iprot.readI64();
23305 
        else:
23306 
          iprot.skip(ftype)
23307 
      else:
23308 
        iprot.skip(ftype)
23309 
      iprot.readFieldEnd()
23310 
    iprot.readStructEnd()
23311 
 
23312 
  def write(self, oprot):
23313 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
23314 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
23315 
      return
23316 
    oprot.writeStructBegin('getOrderIdsForStatus_args')
23317 
    if self.status is not None:
23318 
      oprot.writeFieldBegin('status', TType.I64, 1)
23319 
      oprot.writeI64(self.status)
23320 
      oprot.writeFieldEnd()
23321 
    if self.startDatetime is not None:
23322 
      oprot.writeFieldBegin('startDatetime', TType.I64, 2)
23323 
      oprot.writeI64(self.startDatetime)
23324 
      oprot.writeFieldEnd()
23325 
    if self.endDatetime is not None:
23326 
      oprot.writeFieldBegin('endDatetime', TType.I64, 3)
23327 
      oprot.writeI64(self.endDatetime)
23328 
      oprot.writeFieldEnd()
23329 
    oprot.writeFieldStop()
23330 
    oprot.writeStructEnd()
23331 
 
23332 
  def validate(self):
23333 
    return
23334 
 
23335 
 
23336 
  def __repr__(self):
23337 
    L = ['%s=%r' % (key, value)
23338 
      for key, value in self.__dict__.iteritems()]
23339 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
23340 
 
23341 
  def __eq__(self, other):
23342 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
23343 
 
23344 
  def __ne__(self, other):
23345 
    return not (self == other)
23346 
 
23347 
class getOrderIdsForStatus_result:
23348 
  """
23349 
  Attributes:
23350 
   - success
23351 
   - ex
23352 
  """
23353 
 
23354 
  thrift_spec = (
23355 
    (0, TType.LIST, 'success', (TType.I64,None), None, ), # 0
23356 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
23357 
  )
23358 
 
23359 
  def __init__(self, success=None, ex=None,):
23360 
    self.success = success
23361 
    self.ex = ex
23362 
 
23363 
  def read(self, iprot):
23364 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
23365 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
23366 
      return
23367 
    iprot.readStructBegin()
23368 
    while True:
23369 
      (fname, ftype, fid) = iprot.readFieldBegin()
23370 
      if ftype == TType.STOP:
23371 
        break
23372 
      if fid == 0:
23373 
        if ftype == TType.LIST:
23374 
          self.success = []
5676 rajveer 23375 
          (_etype553, _size550) = iprot.readListBegin()
23376 
          for _i554 in xrange(_size550):
23377 
            _elem555 = iprot.readI64();
23378 
            self.success.append(_elem555)
5067 varun.gupt 23379 
          iprot.readListEnd()
23380 
        else:
23381 
          iprot.skip(ftype)
23382 
      elif fid == 1:
23383 
        if ftype == TType.STRUCT:
23384 
          self.ex = TransactionServiceException()
23385 
          self.ex.read(iprot)
23386 
        else:
23387 
          iprot.skip(ftype)
23388 
      else:
23389 
        iprot.skip(ftype)
23390 
      iprot.readFieldEnd()
23391 
    iprot.readStructEnd()
23392 
 
23393 
  def write(self, oprot):
23394 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
23395 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
23396 
      return
23397 
    oprot.writeStructBegin('getOrderIdsForStatus_result')
23398 
    if self.success is not None:
23399 
      oprot.writeFieldBegin('success', TType.LIST, 0)
23400 
      oprot.writeListBegin(TType.I64, len(self.success))
5676 rajveer 23401 
      for iter556 in self.success:
23402 
        oprot.writeI64(iter556)
5067 varun.gupt 23403 
      oprot.writeListEnd()
23404 
      oprot.writeFieldEnd()
23405 
    if self.ex is not None:
23406 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
23407 
      self.ex.write(oprot)
23408 
      oprot.writeFieldEnd()
23409 
    oprot.writeFieldStop()
23410 
    oprot.writeStructEnd()
23411 
 
23412 
  def validate(self):
23413 
    return
23414 
 
23415 
 
23416 
  def __repr__(self):
23417 
    L = ['%s=%r' % (key, value)
23418 
      for key, value in self.__dict__.iteritems()]
23419 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
23420 
 
23421 
  def __eq__(self, other):
23422 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
23423 
 
23424 
  def __ne__(self, other):
23425 
    return not (self == other)
5099 varun.gupt 23426 
 
5348 anupam.sin 23427 
class updateCODAgent_args:
23428 
  """
23429 
  Attributes:
23430 
   - agent
23431 
   - orderId
23432 
  """
23433 
 
23434 
  thrift_spec = (
23435 
    None, # 0
23436 
    (1, TType.STRING, 'agent', None, None, ), # 1
23437 
    (2, TType.I64, 'orderId', None, None, ), # 2
23438 
  )
23439 
 
23440 
  def __init__(self, agent=None, orderId=None,):
23441 
    self.agent = agent
23442 
    self.orderId = orderId
23443 
 
23444 
  def read(self, iprot):
23445 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
23446 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
23447 
      return
23448 
    iprot.readStructBegin()
23449 
    while True:
23450 
      (fname, ftype, fid) = iprot.readFieldBegin()
23451 
      if ftype == TType.STOP:
23452 
        break
23453 
      if fid == 1:
23454 
        if ftype == TType.STRING:
23455 
          self.agent = iprot.readString();
23456 
        else:
23457 
          iprot.skip(ftype)
23458 
      elif fid == 2:
23459 
        if ftype == TType.I64:
23460 
          self.orderId = iprot.readI64();
23461 
        else:
23462 
          iprot.skip(ftype)
23463 
      else:
23464 
        iprot.skip(ftype)
23465 
      iprot.readFieldEnd()
23466 
    iprot.readStructEnd()
23467 
 
23468 
  def write(self, oprot):
23469 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
23470 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
23471 
      return
23472 
    oprot.writeStructBegin('updateCODAgent_args')
23473 
    if self.agent is not None:
23474 
      oprot.writeFieldBegin('agent', TType.STRING, 1)
23475 
      oprot.writeString(self.agent)
23476 
      oprot.writeFieldEnd()
23477 
    if self.orderId is not None:
23478 
      oprot.writeFieldBegin('orderId', TType.I64, 2)
23479 
      oprot.writeI64(self.orderId)
23480 
      oprot.writeFieldEnd()
23481 
    oprot.writeFieldStop()
23482 
    oprot.writeStructEnd()
23483 
 
23484 
  def validate(self):
23485 
    return
23486 
 
23487 
 
23488 
  def __repr__(self):
23489 
    L = ['%s=%r' % (key, value)
23490 
      for key, value in self.__dict__.iteritems()]
23491 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
23492 
 
23493 
  def __eq__(self, other):
23494 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
23495 
 
23496 
  def __ne__(self, other):
23497 
    return not (self == other)
23498 
 
23499 
class updateCODAgent_result:
23500 
  """
23501 
  Attributes:
23502 
   - ex
23503 
  """
23504 
 
23505 
  thrift_spec = (
23506 
    None, # 0
23507 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
23508 
  )
23509 
 
23510 
  def __init__(self, ex=None,):
23511 
    self.ex = ex
23512 
 
23513 
  def read(self, iprot):
23514 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
23515 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
23516 
      return
23517 
    iprot.readStructBegin()
23518 
    while True:
23519 
      (fname, ftype, fid) = iprot.readFieldBegin()
23520 
      if ftype == TType.STOP:
23521 
        break
23522 
      if fid == 1:
23523 
        if ftype == TType.STRUCT:
23524 
          self.ex = TransactionServiceException()
23525 
          self.ex.read(iprot)
23526 
        else:
23527 
          iprot.skip(ftype)
23528 
      else:
23529 
        iprot.skip(ftype)
23530 
      iprot.readFieldEnd()
23531 
    iprot.readStructEnd()
23532 
 
23533 
  def write(self, oprot):
23534 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
23535 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
23536 
      return
23537 
    oprot.writeStructBegin('updateCODAgent_result')
23538 
    if self.ex is not None:
23539 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
23540 
      self.ex.write(oprot)
23541 
      oprot.writeFieldEnd()
23542 
    oprot.writeFieldStop()
23543 
    oprot.writeStructEnd()
23544 
 
23545 
  def validate(self):
23546 
    return
23547 
 
23548 
 
23549 
  def __repr__(self):
23550 
    L = ['%s=%r' % (key, value)
23551 
      for key, value in self.__dict__.iteritems()]
23552 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
23553 
 
23554 
  def __eq__(self, other):
23555 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
23556 
 
23557 
  def __ne__(self, other):
23558 
    return not (self == other)
23559 
 
5099 varun.gupt 23560 
class updateOrderAsPaidToVendor_args:
23561 
  """
23562 
  Attributes:
23563 
   - orderId
23564 
  """
23565 
 
23566 
  thrift_spec = (
23567 
    None, # 0
23568 
    (1, TType.I64, 'orderId', None, None, ), # 1
23569 
  )
23570 
 
23571 
  def __init__(self, orderId=None,):
23572 
    self.orderId = orderId
23573 
 
23574 
  def read(self, iprot):
23575 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
23576 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
23577 
      return
23578 
    iprot.readStructBegin()
23579 
    while True:
23580 
      (fname, ftype, fid) = iprot.readFieldBegin()
23581 
      if ftype == TType.STOP:
23582 
        break
23583 
      if fid == 1:
23584 
        if ftype == TType.I64:
23585 
          self.orderId = iprot.readI64();
23586 
        else:
23587 
          iprot.skip(ftype)
23588 
      else:
23589 
        iprot.skip(ftype)
23590 
      iprot.readFieldEnd()
23591 
    iprot.readStructEnd()
23592 
 
23593 
  def write(self, oprot):
23594 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
23595 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
23596 
      return
23597 
    oprot.writeStructBegin('updateOrderAsPaidToVendor_args')
23598 
    if self.orderId is not None:
23599 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
23600 
      oprot.writeI64(self.orderId)
23601 
      oprot.writeFieldEnd()
23602 
    oprot.writeFieldStop()
23603 
    oprot.writeStructEnd()
23604 
 
23605 
  def validate(self):
23606 
    return
23607 
 
23608 
 
23609 
  def __repr__(self):
23610 
    L = ['%s=%r' % (key, value)
23611 
      for key, value in self.__dict__.iteritems()]
23612 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
23613 
 
23614 
  def __eq__(self, other):
23615 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
23616 
 
23617 
  def __ne__(self, other):
23618 
    return not (self == other)
23619 
 
23620 
class updateOrderAsPaidToVendor_result:
23621 
  """
23622 
  Attributes:
23623 
   - ex
23624 
  """
23625 
 
23626 
  thrift_spec = (
23627 
    None, # 0
23628 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
23629 
  )
23630 
 
23631 
  def __init__(self, ex=None,):
23632 
    self.ex = ex
23633 
 
23634 
  def read(self, iprot):
23635 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
23636 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
23637 
      return
23638 
    iprot.readStructBegin()
23639 
    while True:
23640 
      (fname, ftype, fid) = iprot.readFieldBegin()
23641 
      if ftype == TType.STOP:
23642 
        break
23643 
      if fid == 1:
23644 
        if ftype == TType.STRUCT:
23645 
          self.ex = TransactionServiceException()
23646 
          self.ex.read(iprot)
23647 
        else:
23648 
          iprot.skip(ftype)
23649 
      else:
23650 
        iprot.skip(ftype)
23651 
      iprot.readFieldEnd()
23652 
    iprot.readStructEnd()
23653 
 
23654 
  def write(self, oprot):
23655 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
23656 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
23657 
      return
23658 
    oprot.writeStructBegin('updateOrderAsPaidToVendor_result')
23659 
    if self.ex is not None:
23660 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
23661 
      self.ex.write(oprot)
23662 
      oprot.writeFieldEnd()
23663 
    oprot.writeFieldStop()
23664 
    oprot.writeStructEnd()
23665 
 
23666 
  def validate(self):
23667 
    return
23668 
 
23669 
 
23670 
  def __repr__(self):
23671 
    L = ['%s=%r' % (key, value)
23672 
      for key, value in self.__dict__.iteritems()]
23673 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
23674 
 
23675 
  def __eq__(self, other):
23676 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
23677 
 
23678 
  def __ne__(self, other):
23679 
    return not (self == other)
5208 varun.gupt 23680 
 
5386 phani.kuma 23681 
class updateOrderOnlyAsPaidToVendor_args:
23682 
  """
23683 
  Attributes:
23684 
   - orderId
23685 
  """
23686 
 
23687 
  thrift_spec = (
23688 
    None, # 0
23689 
    (1, TType.I64, 'orderId', None, None, ), # 1
23690 
  )
23691 
 
23692 
  def __init__(self, orderId=None,):
23693 
    self.orderId = orderId
23694 
 
23695 
  def read(self, iprot):
23696 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
23697 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
23698 
      return
23699 
    iprot.readStructBegin()
23700 
    while True:
23701 
      (fname, ftype, fid) = iprot.readFieldBegin()
23702 
      if ftype == TType.STOP:
23703 
        break
23704 
      if fid == 1:
23705 
        if ftype == TType.I64:
23706 
          self.orderId = iprot.readI64();
23707 
        else:
23708 
          iprot.skip(ftype)
23709 
      else:
23710 
        iprot.skip(ftype)
23711 
      iprot.readFieldEnd()
23712 
    iprot.readStructEnd()
23713 
 
23714 
  def write(self, oprot):
23715 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
23716 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
23717 
      return
23718 
    oprot.writeStructBegin('updateOrderOnlyAsPaidToVendor_args')
23719 
    if self.orderId is not None:
23720 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
23721 
      oprot.writeI64(self.orderId)
23722 
      oprot.writeFieldEnd()
23723 
    oprot.writeFieldStop()
23724 
    oprot.writeStructEnd()
23725 
 
23726 
  def validate(self):
23727 
    return
23728 
 
23729 
 
23730 
  def __repr__(self):
23731 
    L = ['%s=%r' % (key, value)
23732 
      for key, value in self.__dict__.iteritems()]
23733 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
23734 
 
23735 
  def __eq__(self, other):
23736 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
23737 
 
23738 
  def __ne__(self, other):
23739 
    return not (self == other)
23740 
 
23741 
class updateOrderOnlyAsPaidToVendor_result:
23742 
  """
23743 
  Attributes:
23744 
   - ex
23745 
  """
23746 
 
23747 
  thrift_spec = (
23748 
    None, # 0
23749 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
23750 
  )
23751 
 
23752 
  def __init__(self, ex=None,):
23753 
    self.ex = ex
23754 
 
23755 
  def read(self, iprot):
23756 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
23757 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
23758 
      return
23759 
    iprot.readStructBegin()
23760 
    while True:
23761 
      (fname, ftype, fid) = iprot.readFieldBegin()
23762 
      if ftype == TType.STOP:
23763 
        break
23764 
      if fid == 1:
23765 
        if ftype == TType.STRUCT:
23766 
          self.ex = TransactionServiceException()
23767 
          self.ex.read(iprot)
23768 
        else:
23769 
          iprot.skip(ftype)
23770 
      else:
23771 
        iprot.skip(ftype)
23772 
      iprot.readFieldEnd()
23773 
    iprot.readStructEnd()
23774 
 
23775 
  def write(self, oprot):
23776 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
23777 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
23778 
      return
23779 
    oprot.writeStructBegin('updateOrderOnlyAsPaidToVendor_result')
23780 
    if self.ex is not None:
23781 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
23782 
      self.ex.write(oprot)
23783 
      oprot.writeFieldEnd()
23784 
    oprot.writeFieldStop()
23785 
    oprot.writeStructEnd()
23786 
 
23787 
  def validate(self):
23788 
    return
23789 
 
23790 
 
23791 
  def __repr__(self):
23792 
    L = ['%s=%r' % (key, value)
23793 
      for key, value in self.__dict__.iteritems()]
23794 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
23795 
 
23796 
  def __eq__(self, other):
23797 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
23798 
 
23799 
  def __ne__(self, other):
23800 
    return not (self == other)
23801 
 
5208 varun.gupt 23802 
class getRefundedOrdersMarkedPaid_args:
23803 
 
23804 
  thrift_spec = (
23805 
  )
23806 
 
23807 
  def read(self, iprot):
23808 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
23809 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
23810 
      return
23811 
    iprot.readStructBegin()
23812 
    while True:
23813 
      (fname, ftype, fid) = iprot.readFieldBegin()
23814 
      if ftype == TType.STOP:
23815 
        break
23816 
      else:
23817 
        iprot.skip(ftype)
23818 
      iprot.readFieldEnd()
23819 
    iprot.readStructEnd()
23820 
 
23821 
  def write(self, oprot):
23822 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
23823 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
23824 
      return
23825 
    oprot.writeStructBegin('getRefundedOrdersMarkedPaid_args')
23826 
    oprot.writeFieldStop()
23827 
    oprot.writeStructEnd()
23828 
 
23829 
  def validate(self):
23830 
    return
23831 
 
23832 
 
23833 
  def __repr__(self):
23834 
    L = ['%s=%r' % (key, value)
23835 
      for key, value in self.__dict__.iteritems()]
23836 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
23837 
 
23838 
  def __eq__(self, other):
23839 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
23840 
 
23841 
  def __ne__(self, other):
23842 
    return not (self == other)
23843 
 
23844 
class getRefundedOrdersMarkedPaid_result:
23845 
  """
23846 
  Attributes:
23847 
   - success
23848 
   - ex
23849 
  """
23850 
 
23851 
  thrift_spec = (
23852 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
23853 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
23854 
  )
23855 
 
23856 
  def __init__(self, success=None, ex=None,):
23857 
    self.success = success
23858 
    self.ex = ex
23859 
 
23860 
  def read(self, iprot):
23861 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
23862 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
23863 
      return
23864 
    iprot.readStructBegin()
23865 
    while True:
23866 
      (fname, ftype, fid) = iprot.readFieldBegin()
23867 
      if ftype == TType.STOP:
23868 
        break
23869 
      if fid == 0:
23870 
        if ftype == TType.LIST:
23871 
          self.success = []
5676 rajveer 23872 
          (_etype560, _size557) = iprot.readListBegin()
23873 
          for _i561 in xrange(_size557):
23874 
            _elem562 = Order()
23875 
            _elem562.read(iprot)
23876 
            self.success.append(_elem562)
5208 varun.gupt 23877 
          iprot.readListEnd()
23878 
        else:
23879 
          iprot.skip(ftype)
23880 
      elif fid == 1:
23881 
        if ftype == TType.STRUCT:
23882 
          self.ex = TransactionServiceException()
23883 
          self.ex.read(iprot)
23884 
        else:
23885 
          iprot.skip(ftype)
23886 
      else:
23887 
        iprot.skip(ftype)
23888 
      iprot.readFieldEnd()
23889 
    iprot.readStructEnd()
23890 
 
23891 
  def write(self, oprot):
23892 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
23893 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
23894 
      return
23895 
    oprot.writeStructBegin('getRefundedOrdersMarkedPaid_result')
23896 
    if self.success is not None:
23897 
      oprot.writeFieldBegin('success', TType.LIST, 0)
23898 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
5676 rajveer 23899 
      for iter563 in self.success:
23900 
        iter563.write(oprot)
5208 varun.gupt 23901 
      oprot.writeListEnd()
23902 
      oprot.writeFieldEnd()
23903 
    if self.ex is not None:
23904 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
23905 
      self.ex.write(oprot)
23906 
      oprot.writeFieldEnd()
23907 
    oprot.writeFieldStop()
23908 
    oprot.writeStructEnd()
23909 
 
23910 
  def validate(self):
23911 
    return
23912 
 
23913 
 
23914 
  def __repr__(self):
23915 
    L = ['%s=%r' % (key, value)
23916 
      for key, value in self.__dict__.iteritems()]
23917 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
23918 
 
23919 
  def __eq__(self, other):
23920 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
23921 
 
23922 
  def __ne__(self, other):
23923 
    return not (self == other)
5447 anupam.sin 23924 
 
23925 
class getAllVerificationAgents_args:
23926 
  """
23927 
  Attributes:
23928 
   - minOrderId
23929 
   - maxOrderId
23930 
  """
23931 
 
23932 
  thrift_spec = (
23933 
    None, # 0
23934 
    (1, TType.I64, 'minOrderId', None, None, ), # 1
23935 
    (2, TType.I64, 'maxOrderId', None, None, ), # 2
23936 
  )
23937 
 
23938 
  def __init__(self, minOrderId=None, maxOrderId=None,):
23939 
    self.minOrderId = minOrderId
23940 
    self.maxOrderId = maxOrderId
23941 
 
23942 
  def read(self, iprot):
23943 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
23944 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
23945 
      return
23946 
    iprot.readStructBegin()
23947 
    while True:
23948 
      (fname, ftype, fid) = iprot.readFieldBegin()
23949 
      if ftype == TType.STOP:
23950 
        break
23951 
      if fid == 1:
23952 
        if ftype == TType.I64:
23953 
          self.minOrderId = iprot.readI64();
23954 
        else:
23955 
          iprot.skip(ftype)
23956 
      elif fid == 2:
23957 
        if ftype == TType.I64:
23958 
          self.maxOrderId = iprot.readI64();
23959 
        else:
23960 
          iprot.skip(ftype)
23961 
      else:
23962 
        iprot.skip(ftype)
23963 
      iprot.readFieldEnd()
23964 
    iprot.readStructEnd()
23965 
 
23966 
  def write(self, oprot):
23967 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
23968 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
23969 
      return
23970 
    oprot.writeStructBegin('getAllVerificationAgents_args')
23971 
    if self.minOrderId is not None:
23972 
      oprot.writeFieldBegin('minOrderId', TType.I64, 1)
23973 
      oprot.writeI64(self.minOrderId)
23974 
      oprot.writeFieldEnd()
23975 
    if self.maxOrderId is not None:
23976 
      oprot.writeFieldBegin('maxOrderId', TType.I64, 2)
23977 
      oprot.writeI64(self.maxOrderId)
23978 
      oprot.writeFieldEnd()
23979 
    oprot.writeFieldStop()
23980 
    oprot.writeStructEnd()
23981 
 
23982 
  def validate(self):
23983 
    return
23984 
 
23985 
 
23986 
  def __repr__(self):
23987 
    L = ['%s=%r' % (key, value)
23988 
      for key, value in self.__dict__.iteritems()]
23989 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
23990 
 
23991 
  def __eq__(self, other):
23992 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
23993 
 
23994 
  def __ne__(self, other):
23995 
    return not (self == other)
23996 
 
23997 
class getAllVerificationAgents_result:
23998 
  """
23999 
  Attributes:
24000 
   - success
24001 
  """
24002 
 
24003 
  thrift_spec = (
24004 
    (0, TType.LIST, 'success', (TType.STRUCT,(CODVerificationAgent, CODVerificationAgent.thrift_spec)), None, ), # 0
24005 
  )
24006 
 
24007 
  def __init__(self, success=None,):
24008 
    self.success = success
24009 
 
24010 
  def read(self, iprot):
24011 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
24012 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
24013 
      return
24014 
    iprot.readStructBegin()
24015 
    while True:
24016 
      (fname, ftype, fid) = iprot.readFieldBegin()
24017 
      if ftype == TType.STOP:
24018 
        break
24019 
      if fid == 0:
24020 
        if ftype == TType.LIST:
24021 
          self.success = []
5676 rajveer 24022 
          (_etype567, _size564) = iprot.readListBegin()
24023 
          for _i568 in xrange(_size564):
24024 
            _elem569 = CODVerificationAgent()
24025 
            _elem569.read(iprot)
24026 
            self.success.append(_elem569)
5447 anupam.sin 24027 
          iprot.readListEnd()
24028 
        else:
24029 
          iprot.skip(ftype)
24030 
      else:
24031 
        iprot.skip(ftype)
24032 
      iprot.readFieldEnd()
24033 
    iprot.readStructEnd()
24034 
 
24035 
  def write(self, oprot):
24036 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
24037 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
24038 
      return
24039 
    oprot.writeStructBegin('getAllVerificationAgents_result')
24040 
    if self.success is not None:
24041 
      oprot.writeFieldBegin('success', TType.LIST, 0)
24042 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
5676 rajveer 24043 
      for iter570 in self.success:
24044 
        iter570.write(oprot)
5447 anupam.sin 24045 
      oprot.writeListEnd()
24046 
      oprot.writeFieldEnd()
24047 
    oprot.writeFieldStop()
24048 
    oprot.writeStructEnd()
24049 
 
24050 
  def validate(self):
24051 
    return
24052 
 
24053 
 
24054 
  def __repr__(self):
24055 
    L = ['%s=%r' % (key, value)
24056 
      for key, value in self.__dict__.iteritems()]
24057 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
24058 
 
24059 
  def __eq__(self, other):
24060 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
24061 
 
24062 
  def __ne__(self, other):
24063 
    return not (self == other)
5527 anupam.sin 24064 
 
24065 
class getAllAttributesForOrderId_args:
24066 
  """
24067 
  Attributes:
24068 
   - orderId
24069 
  """
24070 
 
24071 
  thrift_spec = (
24072 
    None, # 0
24073 
    (1, TType.I64, 'orderId', None, None, ), # 1
24074 
  )
24075 
 
24076 
  def __init__(self, orderId=None,):
24077 
    self.orderId = orderId
24078 
 
24079 
  def read(self, iprot):
24080 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
24081 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
24082 
      return
24083 
    iprot.readStructBegin()
24084 
    while True:
24085 
      (fname, ftype, fid) = iprot.readFieldBegin()
24086 
      if ftype == TType.STOP:
24087 
        break
24088 
      if fid == 1:
24089 
        if ftype == TType.I64:
24090 
          self.orderId = iprot.readI64();
24091 
        else:
24092 
          iprot.skip(ftype)
24093 
      else:
24094 
        iprot.skip(ftype)
24095 
      iprot.readFieldEnd()
24096 
    iprot.readStructEnd()
24097 
 
24098 
  def write(self, oprot):
24099 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
24100 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
24101 
      return
24102 
    oprot.writeStructBegin('getAllAttributesForOrderId_args')
24103 
    if self.orderId is not None:
24104 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
24105 
      oprot.writeI64(self.orderId)
24106 
      oprot.writeFieldEnd()
24107 
    oprot.writeFieldStop()
24108 
    oprot.writeStructEnd()
24109 
 
24110 
  def validate(self):
24111 
    return
24112 
 
24113 
 
24114 
  def __repr__(self):
24115 
    L = ['%s=%r' % (key, value)
24116 
      for key, value in self.__dict__.iteritems()]
24117 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
24118 
 
24119 
  def __eq__(self, other):
24120 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
24121 
 
24122 
  def __ne__(self, other):
24123 
    return not (self == other)
24124 
 
24125 
class getAllAttributesForOrderId_result:
24126 
  """
24127 
  Attributes:
24128 
   - success
24129 
  """
24130 
 
24131 
  thrift_spec = (
24132 
    (0, TType.LIST, 'success', (TType.STRUCT,(Attribute, Attribute.thrift_spec)), None, ), # 0
24133 
  )
24134 
 
24135 
  def __init__(self, success=None,):
24136 
    self.success = success
24137 
 
24138 
  def read(self, iprot):
24139 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
24140 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
24141 
      return
24142 
    iprot.readStructBegin()
24143 
    while True:
24144 
      (fname, ftype, fid) = iprot.readFieldBegin()
24145 
      if ftype == TType.STOP:
24146 
        break
24147 
      if fid == 0:
24148 
        if ftype == TType.LIST:
24149 
          self.success = []
5676 rajveer 24150 
          (_etype574, _size571) = iprot.readListBegin()
24151 
          for _i575 in xrange(_size571):
24152 
            _elem576 = Attribute()
24153 
            _elem576.read(iprot)
24154 
            self.success.append(_elem576)
5527 anupam.sin 24155 
          iprot.readListEnd()
24156 
        else:
24157 
          iprot.skip(ftype)
24158 
      else:
24159 
        iprot.skip(ftype)
24160 
      iprot.readFieldEnd()
24161 
    iprot.readStructEnd()
24162 
 
24163 
  def write(self, oprot):
24164 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
24165 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
24166 
      return
24167 
    oprot.writeStructBegin('getAllAttributesForOrderId_result')
24168 
    if self.success is not None:
24169 
      oprot.writeFieldBegin('success', TType.LIST, 0)
24170 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
5676 rajveer 24171 
      for iter577 in self.success:
24172 
        iter577.write(oprot)
5527 anupam.sin 24173 
      oprot.writeListEnd()
24174 
      oprot.writeFieldEnd()
24175 
    oprot.writeFieldStop()
24176 
    oprot.writeStructEnd()
24177 
 
24178 
  def validate(self):
24179 
    return
24180 
 
24181 
 
24182 
  def __repr__(self):
24183 
    L = ['%s=%r' % (key, value)
24184 
      for key, value in self.__dict__.iteritems()]
24185 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
24186 
 
24187 
  def __eq__(self, other):
24188 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
24189 
 
24190 
  def __ne__(self, other):
24191 
    return not (self == other)
24192 
 
5676 rajveer 24193 
class setOrderAttributes_args:
24194 
  """
24195 
  Attributes:
24196 
   - orderId
24197 
   - attributes
24198 
  """
24199 
 
24200 
  thrift_spec = None
24201 
  def __init__(self, orderId=None, attributes=None,):
24202 
    self.orderId = orderId
24203 
    self.attributes = attributes
24204 
 
24205 
  def read(self, iprot):
24206 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
24207 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
24208 
      return
24209 
    iprot.readStructBegin()
24210 
    while True:
24211 
      (fname, ftype, fid) = iprot.readFieldBegin()
24212 
      if ftype == TType.STOP:
24213 
        break
24214 
      if fid == 1:
24215 
        if ftype == TType.I64:
24216 
          self.orderId = iprot.readI64();
24217 
        else:
24218 
          iprot.skip(ftype)
24219 
      elif fid == -1:
24220 
        if ftype == TType.LIST:
24221 
          self.attributes = []
24222 
          (_etype581, _size578) = iprot.readListBegin()
24223 
          for _i582 in xrange(_size578):
24224 
            _elem583 = Attribute()
24225 
            _elem583.read(iprot)
24226 
            self.attributes.append(_elem583)
24227 
          iprot.readListEnd()
24228 
        else:
24229 
          iprot.skip(ftype)
24230 
      else:
24231 
        iprot.skip(ftype)
24232 
      iprot.readFieldEnd()
24233 
    iprot.readStructEnd()
24234 
 
24235 
  def write(self, oprot):
24236 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
24237 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
24238 
      return
24239 
    oprot.writeStructBegin('setOrderAttributes_args')
24240 
    if self.attributes is not None:
24241 
      oprot.writeFieldBegin('attributes', TType.LIST, -1)
24242 
      oprot.writeListBegin(TType.STRUCT, len(self.attributes))
24243 
      for iter584 in self.attributes:
24244 
        iter584.write(oprot)
24245 
      oprot.writeListEnd()
24246 
      oprot.writeFieldEnd()
24247 
    if self.orderId is not None:
24248 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
24249 
      oprot.writeI64(self.orderId)
24250 
      oprot.writeFieldEnd()
24251 
    oprot.writeFieldStop()
24252 
    oprot.writeStructEnd()
24253 
 
24254 
  def validate(self):
24255 
    return
24256 
 
24257 
 
24258 
  def __repr__(self):
24259 
    L = ['%s=%r' % (key, value)
24260 
      for key, value in self.__dict__.iteritems()]
24261 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
24262 
 
24263 
  def __eq__(self, other):
24264 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
24265 
 
24266 
  def __ne__(self, other):
24267 
    return not (self == other)
24268 
 
24269 
class setOrderAttributes_result:
24270 
 
24271 
  thrift_spec = (
24272 
  )
24273 
 
24274 
  def read(self, iprot):
24275 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
24276 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
24277 
      return
24278 
    iprot.readStructBegin()
24279 
    while True:
24280 
      (fname, ftype, fid) = iprot.readFieldBegin()
24281 
      if ftype == TType.STOP:
24282 
        break
24283 
      else:
24284 
        iprot.skip(ftype)
24285 
      iprot.readFieldEnd()
24286 
    iprot.readStructEnd()
24287 
 
24288 
  def write(self, oprot):
24289 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
24290 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
24291 
      return
24292 
    oprot.writeStructBegin('setOrderAttributes_result')
24293 
    oprot.writeFieldStop()
24294 
    oprot.writeStructEnd()
24295 
 
24296 
  def validate(self):
24297 
    return
24298 
 
24299 
 
24300 
  def __repr__(self):
24301 
    L = ['%s=%r' % (key, value)
24302 
      for key, value in self.__dict__.iteritems()]
24303 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
24304 
 
24305 
  def __eq__(self, other):
24306 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
24307 
 
24308 
  def __ne__(self, other):
24309 
    return not (self == other)
24310 
 
5527 anupam.sin 24311 
class setOrderAttributeForTransaction_args:
24312 
  """
24313 
  Attributes:
24314 
   - transactionId
24315 
   - attribute
24316 
  """
24317 
 
24318 
  thrift_spec = None
24319 
  def __init__(self, transactionId=None, attribute=None,):
24320 
    self.transactionId = transactionId
24321 
    self.attribute = attribute
24322 
 
24323 
  def read(self, iprot):
24324 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
24325 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
24326 
      return
24327 
    iprot.readStructBegin()
24328 
    while True:
24329 
      (fname, ftype, fid) = iprot.readFieldBegin()
24330 
      if ftype == TType.STOP:
24331 
        break
24332 
      if fid == 1:
24333 
        if ftype == TType.I64:
24334 
          self.transactionId = iprot.readI64();
24335 
        else:
24336 
          iprot.skip(ftype)
24337 
      elif fid == -1:
24338 
        if ftype == TType.STRUCT:
24339 
          self.attribute = Attribute()
24340 
          self.attribute.read(iprot)
24341 
        else:
24342 
          iprot.skip(ftype)
24343 
      else:
24344 
        iprot.skip(ftype)
24345 
      iprot.readFieldEnd()
24346 
    iprot.readStructEnd()
24347 
 
24348 
  def write(self, oprot):
24349 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
24350 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
24351 
      return
24352 
    oprot.writeStructBegin('setOrderAttributeForTransaction_args')
24353 
    if self.attribute is not None:
24354 
      oprot.writeFieldBegin('attribute', TType.STRUCT, -1)
24355 
      self.attribute.write(oprot)
24356 
      oprot.writeFieldEnd()
24357 
    if self.transactionId is not None:
24358 
      oprot.writeFieldBegin('transactionId', TType.I64, 1)
24359 
      oprot.writeI64(self.transactionId)
24360 
      oprot.writeFieldEnd()
24361 
    oprot.writeFieldStop()
24362 
    oprot.writeStructEnd()
24363 
 
24364 
  def validate(self):
24365 
    return
24366 
 
24367 
 
24368 
  def __repr__(self):
24369 
    L = ['%s=%r' % (key, value)
24370 
      for key, value in self.__dict__.iteritems()]
24371 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
24372 
 
24373 
  def __eq__(self, other):
24374 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
24375 
 
24376 
  def __ne__(self, other):
24377 
    return not (self == other)
24378 
 
24379 
class setOrderAttributeForTransaction_result:
24380 
 
24381 
  thrift_spec = (
24382 
  )
24383 
 
24384 
  def read(self, iprot):
24385 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
24386 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
24387 
      return
24388 
    iprot.readStructBegin()
24389 
    while True:
24390 
      (fname, ftype, fid) = iprot.readFieldBegin()
24391 
      if ftype == TType.STOP:
24392 
        break
24393 
      else:
24394 
        iprot.skip(ftype)
24395 
      iprot.readFieldEnd()
24396 
    iprot.readStructEnd()
24397 
 
24398 
  def write(self, oprot):
24399 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
24400 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
24401 
      return
24402 
    oprot.writeStructBegin('setOrderAttributeForTransaction_result')
24403 
    oprot.writeFieldStop()
24404 
    oprot.writeStructEnd()
24405 
 
24406 
  def validate(self):
24407 
    return
24408 
 
24409 
 
24410 
  def __repr__(self):
24411 
    L = ['%s=%r' % (key, value)
24412 
      for key, value in self.__dict__.iteritems()]
24413 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
24414 
 
24415 
  def __eq__(self, other):
24416 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
24417 
 
24418 
  def __ne__(self, other):
24419 
    return not (self == other)
5553 rajveer 24420 
 
24421 
class getReceivePendingOrders_args:
24422 
  """
24423 
  Attributes:
24424 
   - storeId
24425 
  """
24426 
 
24427 
  thrift_spec = (
24428 
    None, # 0
24429 
    (1, TType.I64, 'storeId', None, None, ), # 1
24430 
  )
24431 
 
24432 
  def __init__(self, storeId=None,):
24433 
    self.storeId = storeId
24434 
 
24435 
  def read(self, iprot):
24436 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
24437 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
24438 
      return
24439 
    iprot.readStructBegin()
24440 
    while True:
24441 
      (fname, ftype, fid) = iprot.readFieldBegin()
24442 
      if ftype == TType.STOP:
24443 
        break
24444 
      if fid == 1:
24445 
        if ftype == TType.I64:
24446 
          self.storeId = iprot.readI64();
24447 
        else:
24448 
          iprot.skip(ftype)
24449 
      else:
24450 
        iprot.skip(ftype)
24451 
      iprot.readFieldEnd()
24452 
    iprot.readStructEnd()
24453 
 
24454 
  def write(self, oprot):
24455 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
24456 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
24457 
      return
24458 
    oprot.writeStructBegin('getReceivePendingOrders_args')
24459 
    if self.storeId is not None:
24460 
      oprot.writeFieldBegin('storeId', TType.I64, 1)
24461 
      oprot.writeI64(self.storeId)
24462 
      oprot.writeFieldEnd()
24463 
    oprot.writeFieldStop()
24464 
    oprot.writeStructEnd()
24465 
 
24466 
  def validate(self):
24467 
    return
24468 
 
24469 
 
24470 
  def __repr__(self):
24471 
    L = ['%s=%r' % (key, value)
24472 
      for key, value in self.__dict__.iteritems()]
24473 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
24474 
 
24475 
  def __eq__(self, other):
24476 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
24477 
 
24478 
  def __ne__(self, other):
24479 
    return not (self == other)
24480 
 
24481 
class getReceivePendingOrders_result:
24482 
  """
24483 
  Attributes:
24484 
   - success
24485 
  """
24486 
 
24487 
  thrift_spec = (
24488 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
24489 
  )
24490 
 
24491 
  def __init__(self, success=None,):
24492 
    self.success = success
24493 
 
24494 
  def read(self, iprot):
24495 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
24496 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
24497 
      return
24498 
    iprot.readStructBegin()
24499 
    while True:
24500 
      (fname, ftype, fid) = iprot.readFieldBegin()
24501 
      if ftype == TType.STOP:
24502 
        break
24503 
      if fid == 0:
24504 
        if ftype == TType.LIST:
24505 
          self.success = []
5676 rajveer 24506 
          (_etype588, _size585) = iprot.readListBegin()
24507 
          for _i589 in xrange(_size585):
24508 
            _elem590 = Order()
24509 
            _elem590.read(iprot)
24510 
            self.success.append(_elem590)
5553 rajveer 24511 
          iprot.readListEnd()
24512 
        else:
24513 
          iprot.skip(ftype)
24514 
      else:
24515 
        iprot.skip(ftype)
24516 
      iprot.readFieldEnd()
24517 
    iprot.readStructEnd()
24518 
 
24519 
  def write(self, oprot):
24520 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
24521 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
24522 
      return
24523 
    oprot.writeStructBegin('getReceivePendingOrders_result')
24524 
    if self.success is not None:
24525 
      oprot.writeFieldBegin('success', TType.LIST, 0)
24526 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
5676 rajveer 24527 
      for iter591 in self.success:
24528 
        iter591.write(oprot)
5553 rajveer 24529 
      oprot.writeListEnd()
24530 
      oprot.writeFieldEnd()
24531 
    oprot.writeFieldStop()
24532 
    oprot.writeStructEnd()
24533 
 
24534 
  def validate(self):
24535 
    return
24536 
 
24537 
 
24538 
  def __repr__(self):
24539 
    L = ['%s=%r' % (key, value)
24540 
      for key, value in self.__dict__.iteritems()]
24541 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
24542 
 
24543 
  def __eq__(self, other):
24544 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
24545 
 
24546 
  def __ne__(self, other):
24547 
    return not (self == other)
24548 
 
24549 
class getReceivedAtStoreOrders_args:
24550 
  """
24551 
  Attributes:
24552 
   - storeId
24553 
  """
24554 
 
24555 
  thrift_spec = (
24556 
    None, # 0
24557 
    (1, TType.I64, 'storeId', None, None, ), # 1
24558 
  )
24559 
 
24560 
  def __init__(self, storeId=None,):
24561 
    self.storeId = storeId
24562 
 
24563 
  def read(self, iprot):
24564 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
24565 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
24566 
      return
24567 
    iprot.readStructBegin()
24568 
    while True:
24569 
      (fname, ftype, fid) = iprot.readFieldBegin()
24570 
      if ftype == TType.STOP:
24571 
        break
24572 
      if fid == 1:
24573 
        if ftype == TType.I64:
24574 
          self.storeId = iprot.readI64();
24575 
        else:
24576 
          iprot.skip(ftype)
24577 
      else:
24578 
        iprot.skip(ftype)
24579 
      iprot.readFieldEnd()
24580 
    iprot.readStructEnd()
24581 
 
24582 
  def write(self, oprot):
24583 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
24584 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
24585 
      return
24586 
    oprot.writeStructBegin('getReceivedAtStoreOrders_args')
24587 
    if self.storeId is not None:
24588 
      oprot.writeFieldBegin('storeId', TType.I64, 1)
24589 
      oprot.writeI64(self.storeId)
24590 
      oprot.writeFieldEnd()
24591 
    oprot.writeFieldStop()
24592 
    oprot.writeStructEnd()
24593 
 
24594 
  def validate(self):
24595 
    return
24596 
 
24597 
 
24598 
  def __repr__(self):
24599 
    L = ['%s=%r' % (key, value)
24600 
      for key, value in self.__dict__.iteritems()]
24601 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
24602 
 
24603 
  def __eq__(self, other):
24604 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
24605 
 
24606 
  def __ne__(self, other):
24607 
    return not (self == other)
24608 
 
24609 
class getReceivedAtStoreOrders_result:
24610 
  """
24611 
  Attributes:
24612 
   - success
24613 
  """
24614 
 
24615 
  thrift_spec = (
24616 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
24617 
  )
24618 
 
24619 
  def __init__(self, success=None,):
24620 
    self.success = success
24621 
 
24622 
  def read(self, iprot):
24623 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
24624 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
24625 
      return
24626 
    iprot.readStructBegin()
24627 
    while True:
24628 
      (fname, ftype, fid) = iprot.readFieldBegin()
24629 
      if ftype == TType.STOP:
24630 
        break
24631 
      if fid == 0:
24632 
        if ftype == TType.LIST:
24633 
          self.success = []
5676 rajveer 24634 
          (_etype595, _size592) = iprot.readListBegin()
24635 
          for _i596 in xrange(_size592):
24636 
            _elem597 = Order()
24637 
            _elem597.read(iprot)
24638 
            self.success.append(_elem597)
5553 rajveer 24639 
          iprot.readListEnd()
24640 
        else:
24641 
          iprot.skip(ftype)
24642 
      else:
24643 
        iprot.skip(ftype)
24644 
      iprot.readFieldEnd()
24645 
    iprot.readStructEnd()
24646 
 
24647 
  def write(self, oprot):
24648 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
24649 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
24650 
      return
24651 
    oprot.writeStructBegin('getReceivedAtStoreOrders_result')
24652 
    if self.success is not None:
24653 
      oprot.writeFieldBegin('success', TType.LIST, 0)
24654 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
5676 rajveer 24655 
      for iter598 in self.success:
24656 
        iter598.write(oprot)
5553 rajveer 24657 
      oprot.writeListEnd()
24658 
      oprot.writeFieldEnd()
24659 
    oprot.writeFieldStop()
24660 
    oprot.writeStructEnd()
24661 
 
24662 
  def validate(self):
24663 
    return
24664 
 
24665 
 
24666 
  def __repr__(self):
24667 
    L = ['%s=%r' % (key, value)
24668 
      for key, value in self.__dict__.iteritems()]
24669 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
24670 
 
24671 
  def __eq__(self, other):
24672 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
24673 
 
24674 
  def __ne__(self, other):
24675 
    return not (self == other)
5593 mandeep.dh 24676 
 
24677 
class acceptOrderForItem_args:
24678 
  """
24679 
  Attributes:
24680 
   - itemId
24681 
   - quantity
24682 
   - fulfilmentWarehouseId
24683 
   - billingWarehouseId
24684 
  """
24685 
 
24686 
  thrift_spec = (
24687 
    None, # 0
24688 
    (1, TType.I64, 'itemId', None, None, ), # 1
24689 
    (2, TType.I64, 'quantity', None, None, ), # 2
24690 
    (3, TType.I64, 'fulfilmentWarehouseId', None, None, ), # 3
24691 
    (4, TType.I64, 'billingWarehouseId', None, None, ), # 4
24692 
  )
24693 
 
24694 
  def __init__(self, itemId=None, quantity=None, fulfilmentWarehouseId=None, billingWarehouseId=None,):
24695 
    self.itemId = itemId
24696 
    self.quantity = quantity
24697 
    self.fulfilmentWarehouseId = fulfilmentWarehouseId
24698 
    self.billingWarehouseId = billingWarehouseId
24699 
 
24700 
  def read(self, iprot):
24701 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
24702 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
24703 
      return
24704 
    iprot.readStructBegin()
24705 
    while True:
24706 
      (fname, ftype, fid) = iprot.readFieldBegin()
24707 
      if ftype == TType.STOP:
24708 
        break
24709 
      if fid == 1:
24710 
        if ftype == TType.I64:
24711 
          self.itemId = iprot.readI64();
24712 
        else:
24713 
          iprot.skip(ftype)
24714 
      elif fid == 2:
24715 
        if ftype == TType.I64:
24716 
          self.quantity = iprot.readI64();
24717 
        else:
24718 
          iprot.skip(ftype)
24719 
      elif fid == 3:
24720 
        if ftype == TType.I64:
24721 
          self.fulfilmentWarehouseId = iprot.readI64();
24722 
        else:
24723 
          iprot.skip(ftype)
24724 
      elif fid == 4:
24725 
        if ftype == TType.I64:
24726 
          self.billingWarehouseId = iprot.readI64();
24727 
        else:
24728 
          iprot.skip(ftype)
24729 
      else:
24730 
        iprot.skip(ftype)
24731 
      iprot.readFieldEnd()
24732 
    iprot.readStructEnd()
24733 
 
24734 
  def write(self, oprot):
24735 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
24736 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
24737 
      return
24738 
    oprot.writeStructBegin('acceptOrderForItem_args')
24739 
    if self.itemId is not None:
24740 
      oprot.writeFieldBegin('itemId', TType.I64, 1)
24741 
      oprot.writeI64(self.itemId)
24742 
      oprot.writeFieldEnd()
24743 
    if self.quantity is not None:
24744 
      oprot.writeFieldBegin('quantity', TType.I64, 2)
24745 
      oprot.writeI64(self.quantity)
24746 
      oprot.writeFieldEnd()
24747 
    if self.fulfilmentWarehouseId is not None:
24748 
      oprot.writeFieldBegin('fulfilmentWarehouseId', TType.I64, 3)
24749 
      oprot.writeI64(self.fulfilmentWarehouseId)
24750 
      oprot.writeFieldEnd()
24751 
    if self.billingWarehouseId is not None:
24752 
      oprot.writeFieldBegin('billingWarehouseId', TType.I64, 4)
24753 
      oprot.writeI64(self.billingWarehouseId)
24754 
      oprot.writeFieldEnd()
24755 
    oprot.writeFieldStop()
24756 
    oprot.writeStructEnd()
24757 
 
24758 
  def validate(self):
24759 
    return
24760 
 
24761 
 
24762 
  def __repr__(self):
24763 
    L = ['%s=%r' % (key, value)
24764 
      for key, value in self.__dict__.iteritems()]
24765 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
24766 
 
24767 
  def __eq__(self, other):
24768 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
24769 
 
24770 
  def __ne__(self, other):
24771 
    return not (self == other)
24772 
 
24773 
class acceptOrderForItem_result:
24774 
 
24775 
  thrift_spec = (
24776 
  )
24777 
 
24778 
  def read(self, iprot):
24779 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
24780 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
24781 
      return
24782 
    iprot.readStructBegin()
24783 
    while True:
24784 
      (fname, ftype, fid) = iprot.readFieldBegin()
24785 
      if ftype == TType.STOP:
24786 
        break
24787 
      else:
24788 
        iprot.skip(ftype)
24789 
      iprot.readFieldEnd()
24790 
    iprot.readStructEnd()
24791 
 
24792 
  def write(self, oprot):
24793 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
24794 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
24795 
      return
24796 
    oprot.writeStructBegin('acceptOrderForItem_result')
24797 
    oprot.writeFieldStop()
24798 
    oprot.writeStructEnd()
24799 
 
24800 
  def validate(self):
24801 
    return
24802 
 
24803 
 
24804 
  def __repr__(self):
24805 
    L = ['%s=%r' % (key, value)
24806 
      for key, value in self.__dict__.iteritems()]
24807 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
24808 
 
24809 
  def __eq__(self, other):
24810 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
24811 
 
24812 
  def __ne__(self, other):
24813 
    return not (self == other)