Subversion Repositories SmartDukaan

Rev

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

Rev Author Line No. Line
94 ashish 1 
#
3431 rajveer 2 
# Autogenerated by Thrift Compiler (0.7.0)
94 ashish 3 
#
4 
# DO NOT EDIT UNLESS YOU ARE SURE THAT YOU KNOW WHAT YOU ARE DOING
5 
#
6 
 
7 
from thrift.Thrift import *
3376 rajveer 8 
import shop2020.thriftpy.generic.GenericService
94 ashish 9 
from ttypes import *
10 
from thrift.Thrift import TProcessor
11 
from thrift.transport import TTransport
3431 rajveer 12 
from thrift.protocol import TBinaryProtocol, TProtocol
94 ashish 13 
try:
14 
  from thrift.protocol import fastbinary
15 
except:
16 
  fastbinary = None
17 
 
18 
 
3376 rajveer 19 
class Iface(shop2020.thriftpy.generic.GenericService.Iface):
94 ashish 20 
  def createTransaction(self, transaction):
21 
    """
22 
    Parameters:
23 
     - transaction
24 
    """
25 
    pass
26 
 
27 
  def getTransaction(self, id):
28 
    """
29 
    Parameters:
30 
     - id
31 
    """
32 
    pass
33 
 
34 
  def getTransactionsForCustomer(self, customerId, from_date, to_date, status):
35 
    """
36 
    Parameters:
37 
     - customerId
38 
     - from_date
39 
     - to_date
40 
     - status
41 
    """
42 
    pass
43 
 
132 ashish 44 
  def getTransactionsForShoppingCartId(self, shoppingCartId):
45 
    """
46 
    Parameters:
47 
     - shoppingCartId
48 
    """
49 
    pass
50 
 
94 ashish 51 
  def getTransactionStatus(self, transactionId):
52 
    """
53 
    Parameters:
54 
     - transactionId
55 
    """
56 
    pass
57 
 
5527 anupam.sin 58 
  def changeTransactionStatus(self, transactionId, status, description, pickUp, orderType):
94 ashish 59 
    """
60 
    Parameters:
61 
     - transactionId
62 
     - status
63 
     - description
5527 anupam.sin 64 
     - pickUp
65 
     - orderType
94 ashish 66 
    """
67 
    pass
68 
 
1398 varun.gupt 69 
  def enqueueTransactionInfoEmail(self, transactionId):
1382 varun.gupt 70 
    """
71 
    Parameters:
72 
     - transactionId
73 
    """
74 
    pass
75 
 
4801 anupam.sin 76 
  def getAllOrders(self, statuses, from_date, to_date, warehouse_id):
94 ashish 77 
    """
78 
    Parameters:
4801 anupam.sin 79 
     - statuses
483 rajveer 80 
     - from_date
81 
     - to_date
82 
     - warehouse_id
94 ashish 83 
    """
84 
    pass
85 
 
4133 chandransh 86 
  def getOrdersInBatch(self, statuses, offset, limit, warehouse_id):
87 
    """
88 
    Returns at most 'limit' orders with the given statuses for the given warehouse starting from the given offset.
89 
    Pass the status as null and the limit as 0 to ignore them.
90 
 
91 
    Parameters:
92 
     - statuses
93 
     - offset
94 
     - limit
95 
     - warehouse_id
96 
    """
97 
    pass
98 
 
99 
  def getOrderCount(self, statuses, warehouseId):
100 
    """
101 
    Returns the count of orders with the given statuses assigned to the given warehouse.
102 
 
103 
    Parameters:
104 
     - statuses
105 
     - warehouseId
106 
    """
107 
    pass
108 
 
999 varun.gupt 109 
  def getOrdersByBillingDate(self, status, start_billing_date, end_billing_date, warehouse_id):
110 
    """
1132 chandransh 111 
    Returns orders within a range of their billing dates
3431 rajveer 112 
 
999 varun.gupt 113 
    Parameters:
114 
     - status
115 
     - start_billing_date
116 
     - end_billing_date
117 
     - warehouse_id
118 
    """
119 
    pass
120 
 
3451 chandransh 121 
  def getOrdersByShippingDate(self, fromShippingDate, toShippingDate, providerId, warehouseId, cod):
3427 chandransh 122 
    """
123 
    Returns orders for a particular provider and warehouse which were shipped between the given dates.
3451 chandransh 124 
    Returned orders comprise of COD orders if cod parameter is true. It comprises of prepaid orders otherwise.
125 
    Pass providerId and warehouseId as -1 to ignore both these parameters.
3431 rajveer 126 
 
3427 chandransh 127 
    Parameters:
128 
     - fromShippingDate
129 
     - toShippingDate
130 
     - providerId
131 
     - warehouseId
3451 chandransh 132 
     - cod
3427 chandransh 133 
    """
134 
    pass
135 
 
1382 varun.gupt 136 
  def getReturnableOrdersForCustomer(self, customer_id, limit):
137 
    """
138 
    Returns order ids for orders which can be returned
3431 rajveer 139 
 
1382 varun.gupt 140 
    Parameters:
141 
     - customer_id
142 
     - limit
143 
    """
144 
    pass
145 
 
146 
  def getCancellableOrdersForCustomer(self, customer_id, limit):
147 
    """
148 
    Returns order ids for orders which can be cancelled
3431 rajveer 149 
 
1382 varun.gupt 150 
    Parameters:
151 
     - customer_id
152 
     - limit
153 
    """
154 
    pass
155 
 
483 rajveer 156 
  def changeOrderStatus(self, orderId, status, description):
94 ashish 157 
    """
158 
    Parameters:
483 rajveer 159 
     - orderId
160 
     - status
161 
     - description
94 ashish 162 
    """
163 
    pass
164 
 
1528 ankur.sing 165 
  def getOrdersForTransaction(self, transactionId, customerId):
94 ashish 166 
    """
1528 ankur.sing 167 
    Returns list of orders for given transaction Id. Also filters based on customer Id so that
168 
    only user who owns the transaction can view its order details.
3431 rajveer 169 
 
94 ashish 170 
    Parameters:
171 
     - transactionId
1528 ankur.sing 172 
     - customerId
94 ashish 173 
    """
174 
    pass
175 
 
3014 chandransh 176 
  def getOrdersForCustomer(self, customerId, from_date, to_date, statuses):
94 ashish 177 
    """
3014 chandransh 178 
    Returns list of orders for the given customer created between the given dates and having the given statuses.
179 
    Pass and empty list to ignore filtering on statuses.
3431 rajveer 180 
 
94 ashish 181 
    Parameters:
483 rajveer 182 
     - customerId
183 
     - from_date
184 
     - to_date
3014 chandransh 185 
     - statuses
94 ashish 186 
    """
187 
    pass
188 
 
483 rajveer 189 
  def createOrder(self, order):
94 ashish 190 
    """
191 
    Parameters:
483 rajveer 192 
     - order
94 ashish 193 
    """
194 
    pass
195 
 
483 rajveer 196 
  def getOrder(self, id):
94 ashish 197 
    """
198 
    Parameters:
483 rajveer 199 
     - id
94 ashish 200 
    """
201 
    pass
202 
 
483 rajveer 203 
  def getLineItemsForOrder(self, orderId):
94 ashish 204 
    """
205 
    Parameters:
483 rajveer 206 
     - orderId
94 ashish 207 
    """
208 
    pass
209 
 
4999 phani.kuma 210 
  def getOrderList(self, order_ids):
211 
    """
212 
    Parameters:
213 
     - order_ids
214 
    """
215 
    pass
216 
 
5386 phani.kuma 217 
  def getOrderListForVendor(self, order_ids, vendorId):
218 
    """
219 
    Parameters:
220 
     - order_ids
221 
     - vendorId
222 
    """
223 
    pass
224 
 
1528 ankur.sing 225 
  def getOrderForCustomer(self, orderId, customerId):
226 
    """
227 
    Returns an order for the order Id. Also checks if the order belongs to the customer whose Id is passed.
228 
    Throws exception if either order Id is invalid or order does not below to the customer whose Id is passed.
3431 rajveer 229 
 
1528 ankur.sing 230 
    Parameters:
231 
     - orderId
232 
     - customerId
233 
    """
234 
    pass
235 
 
4444 rajveer 236 
  def getAlerts(self, type, warehouseId, status, timestamp):
3064 chandransh 237 
    """
238 
    Parameters:
4394 rajveer 239 
     - type
4444 rajveer 240 
     - warehouseId
4394 rajveer 241 
     - status
242 
     - timestamp
3064 chandransh 243 
    """
244 
    pass
245 
 
4444 rajveer 246 
  def addAlert(self, type, warehouseId, description):
3064 chandransh 247 
    """
248 
    Parameters:
249 
     - type
4444 rajveer 250 
     - warehouseId
4394 rajveer 251 
     - description
3064 chandransh 252 
    """
253 
    pass
254 
 
4444 rajveer 255 
  def markAlertsAsSeen(self, warehouseId):
256 
    """
257 
    Parameters:
258 
     - warehouseId
259 
    """
260 
    pass
261 
 
3064 chandransh 262 
  def getValidOrderCount(self, ):
263 
    """
264 
    Return the number of valid orders. (OrderStatus >= OrderStatus.SUBMITTED_FOR_PROCESSING)
265 
    """
266 
    pass
267 
 
268 
  def getNoOfCustomersWithSuccessfulTransaction(self, ):
269 
    """
270 
    Returns the number of distinct customers who have done successful transactions
271 
    """
272 
    pass
273 
 
274 
  def getValidOrdersAmountRange(self, ):
275 
    """
276 
    Returns the minimum and maximum amounts of a valid order. (OrderStatus >= OrderStatus.SUBMITTED_FOR_PROCESSING)
277 
    List contains two values, first minimum amount and second maximum amount.
278 
    """
279 
    pass
280 
 
5874 rajveer 281 
  def getValidOrders(self, limit, onlyStore):
3064 chandransh 282 
    """
283 
    Returns list of Orders in descending order by Order creation date. List is restricted to limit Orders.
284 
    If limit is passed as 0, then all valid Orders are returned.
3431 rajveer 285 
 
3064 chandransh 286 
    Parameters:
287 
     - limit
5874 rajveer 288 
     - onlyStore
3064 chandransh 289 
    """
290 
    pass
291 
 
1220 chandransh 292 
  def batchOrders(self, warehouseId):
293 
    """
294 
    Create a batch of all the pending orders for the given warehouse.
295 
    The returned list is orderd by created_timestamp.
296 
    If there are no pending orders, an empty list is returned.
3431 rajveer 297 
 
1220 chandransh 298 
    Parameters:
299 
     - warehouseId
300 
    """
301 
    pass
302 
 
1208 chandransh 303 
  def markOrderAsOutOfStock(self, orderId):
304 
    """
305 
    Mark the given order as out of stock. Throws an exception if the order with the given Id couldn't be found.
3431 rajveer 306 
 
1208 chandransh 307 
    Parameters:
308 
     - orderId
309 
    """
310 
    pass
311 
 
3064 chandransh 312 
  def verifyOrder(self, orderId):
759 chandransh 313 
    """
3064 chandransh 314 
    Marks the given order as SUBMITTED_FOR_PROCESSING and updates the verified
315 
    timestamp. It is intended to be used for COD orders but can be harmlessly
316 
    used for all other orders as well.
317 
    Throws an exception if no such order exists.
3431 rajveer 318 
 
759 chandransh 319 
    Parameters:
3064 chandransh 320 
     - orderId
321 
    """
322 
    pass
323 
 
324 
  def acceptOrder(self, orderId):
325 
    """
326 
    Marks the given order as ACCEPTED and updates the accepted timestamp. If the
327 
    given order is not a COD order, it also captures the payment if the same has
328 
    not been captured.
329 
    Throws an exception if no such order exists.
3431 rajveer 330 
 
3064 chandransh 331 
    Parameters:
332 
     - orderId
333 
    """
334 
    pass
335 
 
5110 mandeep.dh 336 
  def addBillingDetails(self, orderId, invoice_number, serialNumber, itemNumber, billed_by, jacketNumber, billingType, fulfilmentWarehouseId, authorize):
3064 chandransh 337 
    """
338 
    Add billing details such as the bill number and the biller to the Order.
4658 mandeep.dh 339 
    Adds jacket number, item number and Serial no. to the order. Doesn't update
3064 chandransh 340 
    the IMEI no. if a -1 is supplied.
341 
    Also, it generates an invoice number for the order, marks the order as
342 
    BILLED and sets the billing timestamp.
343 
    Returns false if it doesn't find the order with the given ID.
3431 rajveer 344 
 
3064 chandransh 345 
    Parameters:
346 
     - orderId
4283 anupam.sin 347 
     - invoice_number
4658 mandeep.dh 348 
     - serialNumber
3064 chandransh 349 
     - itemNumber
4283 anupam.sin 350 
     - billed_by
351 
     - jacketNumber
3064 chandransh 352 
     - billingType
5110 mandeep.dh 353 
     - fulfilmentWarehouseId
4763 rajveer 354 
     - authorize
3064 chandransh 355 
    """
356 
    pass
357 
 
4763 rajveer 358 
  def addInvoiceNumber(self, orderId, invoiceNumber, color):
4579 rajveer 359 
    """
360 
    Add the invoice number to the order.
361 
 
362 
    Parameters:
363 
     - orderId
364 
     - invoiceNumber
4763 rajveer 365 
     - color
4579 rajveer 366 
    """
367 
    pass
368 
 
4910 phani.kuma 369 
  def markOrdersAsShippedFromWarehouse(self, warehouseId, providerId, cod, orderIds):
3064 chandransh 370 
    """
371 
    Depending on the third parameter, marks either all prepaid or all cod orders BILLED by the
4910 phani.kuma 372 
    given warehouse and were picked up by the given provider as SHIPPED_FROM_WH.
4410 rajveer 373 
 
374 
    Parameters:
375 
     - warehouseId
376 
     - providerId
377 
     - cod
4910 phani.kuma 378 
     - orderIds
4410 rajveer 379 
    """
380 
    pass
381 
 
5713 rajveer 382 
  def markOrdersAsReturnedFromStore(self, providerId, orderIds, awbs):
5676 rajveer 383 
    """
384 
    Parameters:
385 
     - providerId
386 
     - orderIds
5713 rajveer 387 
     - awbs
5676 rajveer 388 
    """
389 
    pass
390 
 
4910 phani.kuma 391 
  def markOrdersAsPickedUp(self, providerId, pickupDetails):
4410 rajveer 392 
    """
4910 phani.kuma 393 
    Marks all SHIPPED_FROM_WH orders of the previous day for a provider as SHIPPED_TO_LOGISTICS.
394 
    Raises an exception if we encounter report for an AWB number that we did not ship.
3431 rajveer 395 
 
3064 chandransh 396 
    Parameters:
759 chandransh 397 
     - providerId
4910 phani.kuma 398 
     - pickupDetails
759 chandransh 399 
    """
400 
    pass
401 
 
4910 phani.kuma 402 
  def getOrdersNotPickedUp(self, providerId):
1113 chandransh 403 
    """
404 
    Returns a list of orders that were shipped from warehouse but did not appear in the pick-up report.
3431 rajveer 405 
 
1113 chandransh 406 
    Parameters:
407 
     - providerId
408 
    """
409 
    pass
410 
 
1132 chandransh 411 
  def markOrdersAsDelivered(self, providerId, deliveredOrders):
412 
    """
413 
    Marks all orders with AWBs in the given map as delivered. Also sets the delivery timestamp and
414 
    the name of the receiver.
415 
    Raises an exception if we encounter report for an AWB number that we did not ship.
3431 rajveer 416 
 
1132 chandransh 417 
    Parameters:
418 
     - providerId
419 
     - deliveredOrders
420 
    """
421 
    pass
422 
 
4910 phani.kuma 423 
  def markAsRTOrders(self, providerId, returnedOrders):
1135 chandransh 424 
    """
4910 phani.kuma 425 
    Mark all orders with AWBs in the given map as RTO. Also sets the delivery timestamp.
1135 chandransh 426 
    Raises an exception if we encounter report for an AWB number that we did not ship.
3431 rajveer 427 
 
1135 chandransh 428 
    Parameters:
429 
     - providerId
430 
     - returnedOrders
431 
    """
432 
    pass
433 
 
4910 phani.kuma 434 
  def getRTOrders(self, providerId):
435 
    """
436 
    Returns a list of orders that were returned by courier.
437 
 
438 
    Parameters:
439 
     - providerId
440 
    """
441 
    pass
442 
 
1246 chandransh 443 
  def updateNonDeliveryReason(self, providerId, undeliveredOrders):
444 
    """
445 
    Update the status description of orders whose AWB numbers are keys of the Map.
3431 rajveer 446 
 
1246 chandransh 447 
    Parameters:
448 
     - providerId
449 
     - undeliveredOrders
450 
    """
451 
    pass
452 
 
4910 phani.kuma 453 
  def getNonDeliveredOrdersbyCourier(self, providerId):
454 
    """
455 
    Returns a list of orders that were picked up or shipped four days ago but did not get delivered.
456 
 
457 
    Parameters:
458 
     - providerId
459 
    """
460 
    pass
461 
 
462 
  def markOrdersAsLocalConnected(self, providerId, local_connected_orders):
463 
    """
464 
    Mark all orders with AWBs in the given map as local connected. Also sets the local connected timestamp.
465 
 
466 
    Parameters:
467 
     - providerId
468 
     - local_connected_orders
469 
    """
470 
    pass
471 
 
472 
  def getOrdersNotLocalConnected(self, providerId):
473 
    """
474 
    Returns a list of orders that were picked up or shipped but pending local connection.
475 
 
476 
    Parameters:
477 
     - providerId
478 
    """
479 
    pass
480 
 
481 
  def markOrdersAsDestinationCityReached(self, providerId, destination_city_reached_orders):
482 
    """
483 
    Mark all orders with AWBs in the given map as reached destination city. Also sets the reached destination timestamp.
484 
 
485 
    Parameters:
486 
     - providerId
487 
     - destination_city_reached_orders
488 
    """
489 
    pass
490 
 
491 
  def markOrdersAsFirstDeliveryAttempted(self, providerId, first_atdl_orders):
492 
    """
493 
    Mark all orders with AWBs in the given map as first delivery attempt made. Also sets the first delivery attempted timestamp.
494 
 
495 
    Parameters:
496 
     - providerId
497 
     - first_atdl_orders
498 
    """
499 
    pass
500 
 
1408 ankur.sing 501 
  def getUndeliveredOrders(self, providerId, warehouseId):
502 
    """
503 
    Returns the list of orders whose delivery time has passed but have not been
504 
    delivered yet for the given provider and warehouse. To get a complete list of
505 
    undelivered orders, pass them as -1.
506 
    Returns an empty list if no such orders exist.
3431 rajveer 507 
 
1408 ankur.sing 508 
    Parameters:
509 
     - providerId
510 
     - warehouseId
511 
    """
512 
    pass
513 
 
4783 phani.kuma 514 
  def getUndeliveredOrdersExpectedDeliveryDateNotMet(self, ):
515 
    """
516 
    Returns the list of orders whose expected delivery date has passed but have not been
517 
    delivered yet.
518 
    Returns an empty list if no such orders exist.
519 
    """
520 
    pass
521 
 
2536 chandransh 522 
  def toggleDOAFlag(self, orderId):
523 
    """
524 
    Toggle the DOA flag of an order. This should be used to flag an order for follow-up and unflag it when the follow-up is complete.
525 
    Returns the final flag status.
526 
    Throws an exception if the order with the given id couldn't be found or if the order status is not DELVIERY_SUCCESS.
3431 rajveer 527 
 
2536 chandransh 528 
    Parameters:
529 
     - orderId
530 
    """
531 
    pass
1886 ankur.sing 532 
 
4712 rajveer 533 
  def markOrderAsDelivered(self, orderId, deliveryTimestamp, receiver):
534 
    """
535 
    Parameters:
536 
     - orderId
537 
     - deliveryTimestamp
538 
     - receiver
539 
    """
540 
    pass
541 
 
5553 rajveer 542 
  def markOrderAsReceivedAtStore(self, orderId, deliveryTimestamp):
543 
    """
544 
    Parameters:
545 
     - orderId
546 
     - deliveryTimestamp
547 
    """
548 
    pass
549 
 
4454 rajveer 550 
  def markOrderDoaRequestReceived(self, orderId):
551 
    """
552 
    Once user raise the request for a DOA, order status will be changed from DELVIERY_SUCCESS to DOA_REQUEST_RECEIVED
553 
 
554 
    Parameters:
555 
     - orderId
556 
    """
557 
    pass
558 
 
559 
  def markOrderDoaRequestAuthorized(self, orderId, isAuthorized):
560 
    """
561 
    CRM person can authorize or deny the request reised by customer. If he authorizes order will change from DOA_REQUEST_RECEIVED
562 
    to DOA_REQUEST_AUTHORIZED. If he denies, status will be changed back to DELVIERY_SUCCESS.
563 
 
564 
    Parameters:
565 
     - orderId
566 
     - isAuthorized
567 
    """
568 
    pass
569 
 
4488 rajveer 570 
  def markOrderReturnRequestReceived(self, orderId):
571 
    """
572 
    Once user raise the request for a RET, order status will be changed from DELVIERY_SUCCESS to RET_REQUEST_RECEIVED
573 
 
574 
    Parameters:
575 
     - orderId
576 
    """
577 
    pass
578 
 
579 
  def markOrderReturnRequestAuthorized(self, orderId, isAuthorized):
580 
    """
581 
    CRM person can authorize or deny the request reised by customer. If he authorizes order will change from RET_REQUEST_RECEIVED
582 
    to RET_REQUEST_AUTHORIZED. If he denies, status will be changed back to DELVIERY_SUCCESS.
583 
 
584 
    Parameters:
585 
     - orderId
586 
     - isAuthorized
587 
    """
588 
    pass
589 
 
4579 rajveer 590 
  def requestPickupNumber(self, orderId, providerId):
2536 chandransh 591 
    """
592 
    Sends out an email to the account manager of the original courier provider used to ship the order.
4452 rajveer 593 
    If the order status was DELIVERY_SUCCESS, it is changed to be DOA_PICKUP_REQUEST_RAISED.
594 
    If the order status was DOA_PICKUP_REQUEST_RAISED, it is left unchanged.
2536 chandransh 595 
    For any other status, it returns false.
596 
    Throws an exception if the order with the given id couldn't be found.
3431 rajveer 597 
 
2536 chandransh 598 
    Parameters:
599 
     - orderId
4579 rajveer 600 
     - providerId
2536 chandransh 601 
    """
602 
    pass
603 
 
4602 rajveer 604 
  def authorizePickup(self, orderId, pickupNumber, providerId):
2536 chandransh 605 
    """
4452 rajveer 606 
    If the order status is DOA_PICKUP_REQUEST_RAISED, it does the following
2536 chandransh 607 
    	1. Sends out an email to the customer with the dispatch advice that he has to print as an attachment.
608 
    	2. Changes order status to be DOA_PICKUP_AUTHORIZED.
609 
    	3. Returns true
2591 chandransh 610 
    If the order is in any other status, it returns false.
2536 chandransh 611 
    Throws an exception if the order with the given id couldn't be found.
3431 rajveer 612 
 
2536 chandransh 613 
    Parameters:
614 
     - orderId
615 
     - pickupNumber
4602 rajveer 616 
     - providerId
2536 chandransh 617 
    """
618 
    pass
619 
 
2764 chandransh 620 
  def markDoasAsPickedUp(self, providerId, pickupDetails):
621 
    """
622 
    Marks all DOA_PICKUP_AUTHORIZED orders of the previous day for a provider as DOA_RETURN_IN_TRANSIT.
3431 rajveer 623 
 
2764 chandransh 624 
    Parameters:
625 
     - providerId
626 
     - pickupDetails
627 
    """
628 
    pass
629 
 
4910 phani.kuma 630 
  def getDoasNotPickedUp(self, providerId):
631 
    """
632 
    Returns a list of orders that were authorized for pickup but did not appear in the pick-up report.
633 
 
634 
    Parameters:
635 
     - providerId
636 
    """
637 
    pass
638 
 
4741 phani.kuma 639 
  def markReturnOrdersAsPickedUp(self, providerId, pickupDetails):
640 
    """
641 
    Marks all RET_PICKUP_CONFIRMED orders of the previous day for a provider as RET_RETURN_IN_TRANSIT.
642 
 
643 
    Parameters:
644 
     - providerId
645 
     - pickupDetails
646 
    """
647 
    pass
648 
 
4910 phani.kuma 649 
  def getReturnOrdersNotPickedUp(self, providerId):
650 
    """
651 
    Returns a list of orders that were authorized for pickup but did not appear in the pick-up report.
652 
 
653 
    Parameters:
654 
     - providerId
655 
    """
656 
    pass
657 
 
4479 rajveer 658 
  def receiveReturn(self, orderId, receiveCondition):
2591 chandransh 659 
    """
4452 rajveer 660 
    If the order status is DOA_PICKUP_CONFIRMED or DOA_RETURN_IN_TRANSIT, marks the order status as DOA_RECEIVED_PRESTINE and returns true.
4484 rajveer 661 
    If the order status is RTO_IN_TRANSIT, marks the order status as RTO_RECEIVED_PRESTINE and returns true.
2591 chandransh 662 
    If the order is in any other state, it returns false.
663 
    Throws an exception if the order with the given id couldn't be found.
3431 rajveer 664 
 
2591 chandransh 665 
    Parameters:
666 
     - orderId
4479 rajveer 667 
     - receiveCondition
2591 chandransh 668 
    """
669 
    pass
2536 chandransh 670 
 
2591 chandransh 671 
  def validateDoa(self, orderId, isValid):
672 
    """
4452 rajveer 673 
    Used to validate the DOA certificate for an order in the DOA_RECEIVED_PRESTINE state. If the certificate is valid,
2616 chandransh 674 
    the order state is changed to DOA_CERT_VALID. If the certificate is invalid, the order state is changed to DOA_CERT_INVALID.
2591 chandransh 675 
    If the order is in any other state, it returns false.
676 
    Throws an exception if the order with the given id couldn't be found.
3431 rajveer 677 
 
2591 chandransh 678 
    Parameters:
679 
     - orderId
680 
     - isValid
681 
    """
682 
    pass
683 
 
4495 rajveer 684 
  def validateReturnProduct(self, orderId, isUsable):
685 
    """
686 
    Parameters:
687 
     - orderId
688 
     - isUsable
689 
    """
690 
    pass
691 
 
2616 chandransh 692 
  def reshipOrder(self, orderId):
693 
    """
4484 rajveer 694 
    If the order is in RTO_RECEIVED_PRESTINE or DOA_CERT_INVALID state, it does the following:
2616 chandransh 695 
    	1. Creates a new order for processing in the BILLED state. All billing information is saved.
4484 rajveer 696 
    	2. Marks the current order as one of the final states RTO_RESHIPPED and DOA_INVALID_RESHIPPED depending on what state the order started in.
2616 chandransh 697 
 
698 
    If the order is in DOA_CERT_VALID state, it does the following:
699 
    	1. Creates a new order for processing in the SUBMITTED_FOR_PROCESSING state.
700 
    	2. Creates a return order for the warehouse executive to return the DOA material.
4452 rajveer 701 
    	3. Marks the current order as the final DOA_VALID_RESHIPPED state.
3431 rajveer 702 
 
2616 chandransh 703 
    Returns the id of the newly created order.
3431 rajveer 704 
 
2616 chandransh 705 
    Throws an exception if the order with the given id couldn't be found.
3431 rajveer 706 
 
2616 chandransh 707 
    Parameters:
708 
     - orderId
709 
    """
710 
    pass
2591 chandransh 711 
 
3226 chandransh 712 
  def refundOrder(self, orderId, refundedBy, reason):
2616 chandransh 713 
    """
4484 rajveer 714 
    If the order is in RTO_RECEIVED_PRESTINE, DOA_CERT_VALID or DOA_CERT_INVALID state, it does the following:
2616 chandransh 715 
    	1. Creates a refund request for batch processing.
716 
    	2. Creates a return order for the warehouse executive to return the shipped material.
4484 rajveer 717 
    	3. Marks the current order as RTO_REFUNDED, DOA_VALID_REFUNDED or DOA_INVALID_REFUNDED final states.
3431 rajveer 718 
 
2616 chandransh 719 
    If the order is in SUBMITTED_FOR_PROCESSING or INVENTORY_LOW state, it does the following:
720 
    	1. Creates a refund request for batch processing.
3226 chandransh 721 
    	2. Cancels the reservation of the item in the warehouse.
722 
    	3. Marks the current order as the REFUNDED final state.
3431 rajveer 723 
 
3226 chandransh 724 
    For all COD orders, if the order is in INIT, SUBMITTED_FOR_PROCESSING or INVENTORY_LOW state, it does the following:
725 
    	1. Cancels the reservation of the item in the warehouse.
726 
    	2. Marks the current order as CANCELED.
727 
 
728 
    In all cases, it updates the reason for cancellation or refund and the person who performed the action.
729 
 
2616 chandransh 730 
    Returns True if it is successful, False otherwise.
3431 rajveer 731 
 
2616 chandransh 732 
    Throws an exception if the order with the given id couldn't be found.
3431 rajveer 733 
 
2616 chandransh 734 
    Parameters:
735 
     - orderId
3226 chandransh 736 
     - refundedBy
737 
     - reason
2616 chandransh 738 
    """
739 
    pass
740 
 
2690 chandransh 741 
  def getReturnOrders(self, warehouseId, fromDate, toDate):
742 
    """
743 
    Get all return orders created between the from and to dates for the given warehouse.
744 
    Ignores the warehouse if it is passed as -1.
3431 rajveer 745 
 
2690 chandransh 746 
    Parameters:
747 
     - warehouseId
748 
     - fromDate
749 
     - toDate
750 
    """
751 
    pass
2616 chandransh 752 
 
5481 phani.kuma 753 
  def getAllReturnOrders(self, onlyNotProcessed, fromDate, toDate):
754 
    """
755 
    Get all return orders created between the from and to dates.
756 
 
757 
    Parameters:
758 
     - onlyNotProcessed
759 
     - fromDate
760 
     - toDate
761 
    """
762 
    pass
763 
 
2700 chandransh 764 
  def getReturnOrder(self, id):
765 
    """
766 
    Returns the ReturnOrder corresponding to the given id.
767 
    Throws an exception if the return order with the given id couldn't be found.
3431 rajveer 768 
 
2700 chandransh 769 
    Parameters:
770 
     - id
771 
    """
772 
    pass
773 
 
2690 chandransh 774 
  def processReturn(self, returnOrderId):
775 
    """
776 
    Marks the return order with the given id as processed. Raises an exception if no such return order exists.
3431 rajveer 777 
 
2690 chandransh 778 
    Parameters:
779 
     - returnOrderId
780 
    """
781 
    pass
782 
 
3451 chandransh 783 
  def updateWeight(self, orderId, weight):
784 
    """
785 
    Set the weight of the given order to the provided value. Will attempt to update the weight of the item in the catalog as well.
2819 chandransh 786 
 
3451 chandransh 787 
    Parameters:
788 
     - orderId
789 
     - weight
790 
    """
791 
    pass
792 
 
3469 chandransh 793 
  def changeItem(self, orderId, itemId):
794 
    """
795 
    Change the item to be shipped for this order. Also adjusts the reservation in the inventory accordingly.
796 
    Currently, it also ensures that only a different color of the given item is shipped.
3451 chandransh 797 
 
3469 chandransh 798 
    Parameters:
799 
     - orderId
800 
     - itemId
801 
    """
802 
    pass
803 
 
804 
  def shiftToWarehouse(self, orderId, warehouseId):
805 
    """
806 
    Moves the given order to the given warehouse. Also adjusts the inventory reservations accordingly.
807 
 
808 
    Parameters:
809 
     - orderId
810 
     - warehouseId
811 
    """
812 
    pass
813 
 
4647 rajveer 814 
  def addDelayReason(self, orderId, delayReason, furtherDelay, delayReasonText):
3553 chandransh 815 
    """
816 
    Adds the given delay reason to the given order.
3986 chandransh 817 
    Increases the expected delivery time of the given order by the given no. of days.
3553 chandransh 818 
    Raises an exception if no order with the given id can be found.
3469 chandransh 819 
 
3553 chandransh 820 
    Parameters:
821 
     - orderId
822 
     - delayReason
3986 chandransh 823 
     - furtherDelay
4647 rajveer 824 
     - delayReasonText
3553 chandransh 825 
    """
826 
    pass
827 
 
3956 chandransh 828 
  def reconcileCodCollection(self, collectedAmountMap, xferBy, xferTxnId, xferDate):
829 
    """
830 
    Marks the COD orders with given AWB nos. as having been processed.
831 
    Updates the captured amount for the corresponding payment.
3553 chandransh 832 
 
3956 chandransh 833 
    Returns a map of AWBs which were not processed and the associated reason. An AWB is not processed if:
834 
    1. There is no order corresponding to an AWB number.
835 
    2. The captured amount for a payment exceeds the total payment.
836 
    3. The order corresponding to an AWB no. is in a state prior to DELIVERY_SUCCESS.
837 
 
838 
    Parameters:
839 
     - collectedAmountMap
840 
     - xferBy
841 
     - xferTxnId
842 
     - xferDate
843 
    """
844 
    pass
845 
 
4008 mandeep.dh 846 
  def getTransactionsRequiringExtraProcessing(self, category):
847 
    """
4065 mandeep.dh 848 
    Returns the list of transaction ids that require some extra processing and
4008 mandeep.dh 849 
    which belong to a particular category. This is currently used by CRM
4065 mandeep.dh 850 
    application. If no such transaction ids are present, it returns an empty list.
3956 chandransh 851 
 
4008 mandeep.dh 852 
    Parameters:
853 
     - category
854 
    """
855 
    pass
856 
 
857 
  def markTransactionAsProcessed(self, transactionId, category):
858 
    """
859 
    Marks a particular transaction as processed for a particular cateogory.
4065 mandeep.dh 860 
    It essentially deletes the transaction id record for a particular
861 
    processing type category (if present) from DB.
862 
    This is currently used by CRM application.
4008 mandeep.dh 863 
 
864 
    Parameters:
865 
     - transactionId
866 
     - category
867 
    """
868 
    pass
869 
 
4018 chandransh 870 
  def getItemWiseRiskyOrdersCount(self, ):
871 
    """
872 
    Returns a map containing the number of risky orders keyed by item id. A risky order
873 
    is defined as one whose shipping date is about to expire.
874 
    """
875 
    pass
4008 mandeep.dh 876 
 
4295 varun.gupt 877 
  def getOrdersForItemIds(self, itemIds):
878 
    """
879 
    Returns a list of all orders which have items with given id
880 
 
881 
    Parameters:
882 
     - itemIds
883 
    """
884 
    pass
885 
 
4247 rajveer 886 
  def markOrderCancellationRequestReceived(self, orderId):
887 
    """
888 
    Mark order as cancellation request received. If customer sends request of cancellation of
889 
    a particular order, this method will be called. It will just change status of the order
890 
    depending on its current status. It also records the previous status, so that we can move
891 
    back to that status if cancellation request is denied.
4018 chandransh 892 
 
4247 rajveer 893 
    Parameters:
894 
     - orderId
895 
    """
896 
    pass
897 
 
898 
  def markOrderCancellationRequestConfirmed(self, orderId):
899 
    """
900 
    If we decide to to cancel order, CRM will call this method to move the status of order to
901 
    cancellation request confirmed. After this OM will be able to cancel the order.
902 
 
903 
    Parameters:
904 
     - orderId
905 
    """
906 
    pass
907 
 
908 
  def markOrderCancellationRequestDenied(self, orderId):
909 
    """
910 
    If we decide to not to cancel order, we will move the order ro previous status.
911 
 
912 
    Parameters:
913 
     - orderId
914 
    """
915 
    pass
916 
 
4258 rajveer 917 
  def markTransactionAsPaymentFlagRemoved(self, transactionId):
4247 rajveer 918 
    """
4258 rajveer 919 
    If we and/or payment gateway has decided to accept the payment, this method needs to be called.
920 
    Changed transaction and all orders status to payment accepted.
4247 rajveer 921 
 
922 
    Parameters:
4258 rajveer 923 
     - transactionId
4247 rajveer 924 
    """
925 
    pass
926 
 
4259 anupam.sin 927 
  def refundTransaction(self, transactionId, refundedBy, reason):
928 
    """
929 
    This method is called when a flagged payment is deemed unserviceable and the corresponding orders
930 
    need to be cancelled
4247 rajveer 931 
 
4259 anupam.sin 932 
    Parameters:
933 
     - transactionId
934 
     - refundedBy
935 
     - reason
936 
    """
937 
    pass
938 
 
4324 mandeep.dh 939 
  def updateShipmentAddress(self, orderId, addressId):
940 
    """
941 
    Updates shipment address of an order. Delivery and shipping date estimates
942 
    etc. are also updated here.
943 
 
944 
    Throws TransactionServiceException in case address change is not
945 
    possible due to certain reasons such as new pincode in address is
946 
    not serviceable etc.
947 
 
948 
    Parameters:
949 
     - orderId
950 
     - addressId
951 
    """
952 
    pass
953 
 
4285 rajveer 954 
  def acceptOrdersForItemId(self, itemId, inventory):
955 
    """
956 
    Marks the orders as ACCEPTED for the given itemId and inventory. It also updates the accepted timestamp. If the
957 
    given order is not a COD order, it also captures the payment if the same has not been captured.
4259 anupam.sin 958 
 
4285 rajveer 959 
    Parameters:
960 
     - itemId
961 
     - inventory
962 
    """
963 
    pass
964 
 
4369 rajveer 965 
  def markOrdersAsPORaised(self, vendorId, itemId, quantity, estimate, isReminder):
4303 rajveer 966 
    """
967 
    Parameters:
968 
     - vendorId
969 
     - itemId
970 
     - quantity
971 
     - estimate
4369 rajveer 972 
     - isReminder
4303 rajveer 973 
    """
974 
    pass
4285 rajveer 975 
 
4369 rajveer 976 
  def markOrdersAsReversalInitiated(self, vendorId, itemId, quantity, estimate, isReminder):
4303 rajveer 977 
    """
978 
    Parameters:
979 
     - vendorId
980 
     - itemId
981 
     - quantity
982 
     - estimate
4369 rajveer 983 
     - isReminder
4303 rajveer 984 
    """
985 
    pass
986 
 
4369 rajveer 987 
  def markOrdersAsNotAvailabke(self, vendorId, itemId, quantity, estimate, isReminder):
4303 rajveer 988 
    """
989 
    Parameters:
990 
     - vendorId
991 
     - itemId
992 
     - quantity
993 
     - estimate
4369 rajveer 994 
     - isReminder
4303 rajveer 995 
    """
996 
    pass
997 
 
4369 rajveer 998 
  def markOrdersAsTimeout(self, vendorId):
999 
    """
1000 
    Parameters:
1001 
     - vendorId
1002 
    """
1003 
    pass
4303 rajveer 1004 
 
4662 rajveer 1005 
  def markOrderAsLostInTransit(self, orderId):
1006 
    """
1007 
    Mark order as LOST_IN_TRANSIT
1008 
 
1009 
    Parameters:
1010 
     - orderId
1011 
    """
1012 
    pass
1013 
 
4386 anupam.sin 1014 
  def getOrderForAwb(self, awb):
1015 
    """
1016 
    Returns the order corresponding to an AWB number
4369 rajveer 1017 
 
4386 anupam.sin 1018 
    Parameters:
1019 
     - awb
1020 
    """
1021 
    pass
1022 
 
4910 phani.kuma 1023 
  def getOrdersForProviderForStatus(self, logistics_provider_id, order_status_list):
4506 phani.kuma 1024 
    """
4910 phani.kuma 1025 
    Returns the order corresponding to a logistics provider id for a given list of order status
4386 anupam.sin 1026 
 
4506 phani.kuma 1027 
    Parameters:
1028 
     - logistics_provider_id
4910 phani.kuma 1029 
     - order_status_list
4506 phani.kuma 1030 
    """
1031 
    pass
1032 
 
4600 varun.gupt 1033 
  def getBilledOrdersForVendor(self, vendorId, billingDateFrom, billingDateTo):
1034 
    """
1035 
    Returns list of orders fullfiled from a certain vendor and billed in a given date range
4506 phani.kuma 1036 
 
4600 varun.gupt 1037 
    Parameters:
1038 
     - vendorId
1039 
     - billingDateFrom
1040 
     - billingDateTo
1041 
    """
1042 
    pass
1043 
 
4607 rajveer 1044 
  def getSlippedSippingDateOrders(self, ):
1045 
    pass
1046 
 
4709 rajveer 1047 
  def getCancelledOrders(self, cancelDateFrom, cancelDateTo):
1048 
    """
1049 
    Parameters:
1050 
     - cancelDateFrom
1051 
     - cancelDateTo
1052 
    """
1053 
    pass
1054 
 
4600 varun.gupt 1055 
  def saveBluedartSettlements(self, mapAWBAndAmount):
1056 
    """
1057 
    Parameters:
1058 
     - mapAWBAndAmount
1059 
    """
1060 
    pass
1061 
 
4905 varun.gupt 1062 
  def savePaymentSettlements(self, settlementDate, paymentGatewayId, referenceId, serviceTax, otherCharges, netCollection):
4600 varun.gupt 1063 
    """
1064 
    Parameters:
1065 
     - settlementDate
1066 
     - paymentGatewayId
4905 varun.gupt 1067 
     - referenceId
4600 varun.gupt 1068 
     - serviceTax
1069 
     - otherCharges
1070 
     - netCollection
1071 
    """
1072 
    pass
1073 
 
1074 
  def saveEBSSettlementSummary(self, settlementId, settlementDate, transactionDateFrom, transactionDateTo, amount):
1075 
    """
1076 
    Parameters:
1077 
     - settlementId
1078 
     - settlementDate
1079 
     - transactionDateFrom
1080 
     - transactionDateTo
1081 
     - amount
1082 
    """
1083 
    pass
1084 
 
5386 phani.kuma 1085 
  def getSettlementForPrepaid(self, referenceId, isRefund):
4600 varun.gupt 1086 
    """
1087 
    Parameters:
5189 varun.gupt 1088 
     - referenceId
1089 
     - isRefund
4600 varun.gupt 1090 
    """
1091 
    pass
1092 
 
5386 phani.kuma 1093 
  def getSettlementForCod(self, orderId, isRefund):
1094 
    """
1095 
    Parameters:
1096 
     - orderId
1097 
     - isRefund
1098 
    """
1099 
    pass
1100 
 
4600 varun.gupt 1101 
  def getEBSSettlementSummaries(self, ):
1102 
    pass
1103 
 
1104 
  def markEBSSettlementUploaded(self, settlementId):
1105 
    """
1106 
    Parameters:
1107 
     - settlementId
1108 
    """
1109 
    pass
1110 
 
1111 
  def getEBSSettlementDate(self, settlementId):
1112 
    """
1113 
    Parameters:
1114 
     - settlementId
1115 
    """
1116 
    pass
1117 
 
4715 varun.gupt 1118 
  def getSettlementsByDate(self, settlementDateFrom, settlementDateTo, isRefund):
1119 
    """
1120 
    Parameters:
1121 
     - settlementDateFrom
1122 
     - settlementDateTo
1123 
     - isRefund
1124 
    """
1125 
    pass
4600 varun.gupt 1126 
 
4715 varun.gupt 1127 
  def getReshippedOrderIds(self, orderIds):
1128 
    """
1129 
    Returns list of Order Ids, which belong to reshiped orders, shortlisted from a given list of Order Ids
1130 
 
1131 
    Parameters:
1132 
     - orderIds
1133 
    """
1134 
    pass
1135 
 
5481 phani.kuma 1136 
  def getBilledOrders(self, vendorId, onlyVendorNotPaid, billingDateFrom, billingDateTo):
4875 varun.gupt 1137 
    """
1138 
    Parameters:
1139 
     - vendorId
5481 phani.kuma 1140 
     - onlyVendorNotPaid
1141 
     - billingDateFrom
1142 
     - billingDateTo
4875 varun.gupt 1143 
    """
1144 
    pass
4757 mandeep.dh 1145 
 
5031 varun.gupt 1146 
  def getStatusDistributionOfOrders(self, startDate, endDate):
1147 
    """
1148 
    Parameters:
1149 
     - startDate
1150 
     - endDate
1151 
    """
1152 
    pass
4875 varun.gupt 1153 
 
5067 varun.gupt 1154 
  def getOrderIdsForStatus(self, status, startDatetime, endDatetime):
1155 
    """
1156 
    Parameters:
1157 
     - status
1158 
     - startDatetime
1159 
     - endDatetime
1160 
    """
1161 
    pass
5031 varun.gupt 1162 
 
5348 anupam.sin 1163 
  def updateCODAgent(self, agent, orderId):
1164 
    """
1165 
    Updates the agent who handled the COD verification call
1166 
 
1167 
    Parameters:
1168 
     - agent
1169 
     - orderId
1170 
    """
1171 
    pass
1172 
 
5099 varun.gupt 1173 
  def updateOrderAsPaidToVendor(self, orderId):
1174 
    """
1175 
    Parameters:
1176 
     - orderId
1177 
    """
1178 
    pass
5067 varun.gupt 1179 
 
5386 phani.kuma 1180 
  def updateOrderOnlyAsPaidToVendor(self, orderId):
1181 
    """
1182 
    Parameters:
1183 
     - orderId
1184 
    """
1185 
    pass
1186 
 
5208 varun.gupt 1187 
  def getRefundedOrdersMarkedPaid(self, ):
1188 
    pass
5099 varun.gupt 1189 
 
5447 anupam.sin 1190 
  def getAllVerificationAgents(self, minOrderId, maxOrderId):
1191 
    """
1192 
    gets all COD Verification Agents for all orderIds from a minId to maxId
5208 varun.gupt 1193 
 
5447 anupam.sin 1194 
 
1195 
    Parameters:
1196 
     - minOrderId
1197 
     - maxOrderId
1198 
    """
1199 
    pass
1200 
 
5527 anupam.sin 1201 
  def getAllAttributesForOrderId(self, orderId):
1202 
    """
1203 
    gets all attributes for a given orderId
5447 anupam.sin 1204 
 
5527 anupam.sin 1205 
    Parameters:
1206 
     - orderId
1207 
    """
1208 
    pass
1209 
 
5676 rajveer 1210 
  def setOrderAttributes(self, orderId, attributes):
1211 
    """
1212 
    sets attributes for an order
1213 
 
1214 
    Parameters:
1215 
     - orderId
1216 
     - attributes
1217 
    """
1218 
    pass
1219 
 
5527 anupam.sin 1220 
  def setOrderAttributeForTransaction(self, transactionId, attribute):
1221 
    """
1222 
    sets attributes for all orders in a transaction
1223 
 
1224 
    Parameters:
1225 
     - transactionId
1226 
     - attribute
1227 
    """
1228 
    pass
1229 
 
5553 rajveer 1230 
  def getReceivePendingOrders(self, storeId):
1231 
    """
1232 
    Parameters:
1233 
     - storeId
1234 
    """
1235 
    pass
5527 anupam.sin 1236 
 
5553 rajveer 1237 
  def getReceivedAtStoreOrders(self, storeId):
1238 
    """
1239 
    Parameters:
1240 
     - storeId
1241 
    """
1242 
    pass
1243 
 
5713 rajveer 1244 
  def getOrdersCollectionAtStore(self, storeId, fromDate, toDate, onlyCod):
1245 
    """
1246 
    Parameters:
1247 
     - storeId
1248 
     - fromDate
1249 
     - toDate
1250 
     - onlyCod
1251 
    """
1252 
    pass
1253 
 
5833 rajveer 1254 
  def getOrderAttributeValue(self, orderId, attributeName):
1255 
    """
1256 
    Parameters:
1257 
     - orderId
1258 
     - attributeName
1259 
    """
1260 
    pass
1261 
 
6019 rajveer 1262 
  def changeJacketNumber(self, orderId, jacketNumber):
1263 
    """
1264 
    Parameters:
1265 
     - orderId
1266 
     - jacketNumber
1267 
    """
1268 
    pass
1269 
 
1270 
  def markOrderAsRtoInTransit(self, orderId):
1271 
    """
1272 
    Parameters:
1273 
     - orderId
1274 
    """
1275 
    pass
1276 
 
5593 mandeep.dh 1277 
  def acceptOrderForItem(self, itemId, quantity, fulfilmentWarehouseId, billingWarehouseId):
1278 
    """
1279 
    Accepts appropriate order for an item in a given billingWarehouse. Usually
1280 
    invoked while scanning IN of items.
5553 rajveer 1281 
 
5593 mandeep.dh 1282 
    Parameters:
1283 
     - itemId
1284 
     - quantity
1285 
     - fulfilmentWarehouseId
1286 
     - billingWarehouseId
1287 
    """
1288 
    pass
1289 
 
6000 mandeep.dh 1290 
  def createRechargeOrder(self, rechargeOrder):
1291 
    """
1292 
    Parameters:
1293 
     - rechargeOrder
1294 
    """
1295 
    pass
5593 mandeep.dh 1296 
 
6000 mandeep.dh 1297 
  def updateRechargeOrderStatus(self, rechargeOrderId, rechargeOrderStatus):
1298 
    """
1299 
    Parameters:
1300 
     - rechargeOrderId
1301 
     - rechargeOrderStatus
1302 
    """
1303 
    pass
1304 
 
1305 
  def activateRechargeTxn(self, rechargeCoupons):
1306 
    """
1307 
    Parameters:
1308 
     - rechargeCoupons
1309 
    """
1310 
    pass
1311 
 
1312 
  def getRechargeOrders(self, customerId):
1313 
    """
1314 
    Parameters:
1315 
     - customerId
1316 
    """
1317 
    pass
1318 
 
1319 
  def getRechargeCoupons(self, customerId, rechargeCouponStatus):
1320 
    """
1321 
    Parameters:
1322 
     - customerId
1323 
     - rechargeCouponStatus
1324 
    """
1325 
    pass
1326 
 
1327 
 
3376 rajveer 1328 
class Client(shop2020.thriftpy.generic.GenericService.Client, Iface):
94 ashish 1329 
  def __init__(self, iprot, oprot=None):
3376 rajveer 1330 
    shop2020.thriftpy.generic.GenericService.Client.__init__(self, iprot, oprot)
94 ashish 1331 
 
1332 
  def createTransaction(self, transaction):
1333 
    """
1334 
    Parameters:
1335 
     - transaction
1336 
    """
1337 
    self.send_createTransaction(transaction)
132 ashish 1338 
    return self.recv_createTransaction()
94 ashish 1339 
 
1340 
  def send_createTransaction(self, transaction):
1341 
    self._oprot.writeMessageBegin('createTransaction', TMessageType.CALL, self._seqid)
1342 
    args = createTransaction_args()
1343 
    args.transaction = transaction
1344 
    args.write(self._oprot)
1345 
    self._oprot.writeMessageEnd()
1346 
    self._oprot.trans.flush()
1347 
 
1348 
  def recv_createTransaction(self, ):
1349 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1350 
    if mtype == TMessageType.EXCEPTION:
1351 
      x = TApplicationException()
1352 
      x.read(self._iprot)
1353 
      self._iprot.readMessageEnd()
1354 
      raise x
1355 
    result = createTransaction_result()
1356 
    result.read(self._iprot)
1357 
    self._iprot.readMessageEnd()
3431 rajveer 1358 
    if result.success is not None:
132 ashish 1359 
      return result.success
3431 rajveer 1360 
    if result.ex is not None:
94 ashish 1361 
      raise result.ex
132 ashish 1362 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "createTransaction failed: unknown result");
94 ashish 1363 
 
1364 
  def getTransaction(self, id):
1365 
    """
1366 
    Parameters:
1367 
     - id
1368 
    """
1369 
    self.send_getTransaction(id)
1370 
    return self.recv_getTransaction()
1371 
 
1372 
  def send_getTransaction(self, id):
1373 
    self._oprot.writeMessageBegin('getTransaction', TMessageType.CALL, self._seqid)
1374 
    args = getTransaction_args()
1375 
    args.id = id
1376 
    args.write(self._oprot)
1377 
    self._oprot.writeMessageEnd()
1378 
    self._oprot.trans.flush()
1379 
 
1380 
  def recv_getTransaction(self, ):
1381 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1382 
    if mtype == TMessageType.EXCEPTION:
1383 
      x = TApplicationException()
1384 
      x.read(self._iprot)
1385 
      self._iprot.readMessageEnd()
1386 
      raise x
1387 
    result = getTransaction_result()
1388 
    result.read(self._iprot)
1389 
    self._iprot.readMessageEnd()
3431 rajveer 1390 
    if result.success is not None:
94 ashish 1391 
      return result.success
3431 rajveer 1392 
    if result.ex is not None:
94 ashish 1393 
      raise result.ex
1394 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getTransaction failed: unknown result");
1395 
 
1396 
  def getTransactionsForCustomer(self, customerId, from_date, to_date, status):
1397 
    """
1398 
    Parameters:
1399 
     - customerId
1400 
     - from_date
1401 
     - to_date
1402 
     - status
1403 
    """
1404 
    self.send_getTransactionsForCustomer(customerId, from_date, to_date, status)
1405 
    return self.recv_getTransactionsForCustomer()
1406 
 
1407 
  def send_getTransactionsForCustomer(self, customerId, from_date, to_date, status):
1408 
    self._oprot.writeMessageBegin('getTransactionsForCustomer', TMessageType.CALL, self._seqid)
1409 
    args = getTransactionsForCustomer_args()
1410 
    args.customerId = customerId
1411 
    args.from_date = from_date
1412 
    args.to_date = to_date
1413 
    args.status = status
1414 
    args.write(self._oprot)
1415 
    self._oprot.writeMessageEnd()
1416 
    self._oprot.trans.flush()
1417 
 
1418 
  def recv_getTransactionsForCustomer(self, ):
1419 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1420 
    if mtype == TMessageType.EXCEPTION:
1421 
      x = TApplicationException()
1422 
      x.read(self._iprot)
1423 
      self._iprot.readMessageEnd()
1424 
      raise x
1425 
    result = getTransactionsForCustomer_result()
1426 
    result.read(self._iprot)
1427 
    self._iprot.readMessageEnd()
3431 rajveer 1428 
    if result.success is not None:
94 ashish 1429 
      return result.success
3431 rajveer 1430 
    if result.ex is not None:
94 ashish 1431 
      raise result.ex
1432 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getTransactionsForCustomer failed: unknown result");
1433 
 
132 ashish 1434 
  def getTransactionsForShoppingCartId(self, shoppingCartId):
1435 
    """
1436 
    Parameters:
1437 
     - shoppingCartId
1438 
    """
1439 
    self.send_getTransactionsForShoppingCartId(shoppingCartId)
1440 
    return self.recv_getTransactionsForShoppingCartId()
1441 
 
1442 
  def send_getTransactionsForShoppingCartId(self, shoppingCartId):
1443 
    self._oprot.writeMessageBegin('getTransactionsForShoppingCartId', TMessageType.CALL, self._seqid)
1444 
    args = getTransactionsForShoppingCartId_args()
1445 
    args.shoppingCartId = shoppingCartId
1446 
    args.write(self._oprot)
1447 
    self._oprot.writeMessageEnd()
1448 
    self._oprot.trans.flush()
1449 
 
1450 
  def recv_getTransactionsForShoppingCartId(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 = getTransactionsForShoppingCartId_result()
1458 
    result.read(self._iprot)
1459 
    self._iprot.readMessageEnd()
3431 rajveer 1460 
    if result.success is not None:
132 ashish 1461 
      return result.success
3431 rajveer 1462 
    if result.ex is not None:
132 ashish 1463 
      raise result.ex
1464 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getTransactionsForShoppingCartId failed: unknown result");
1465 
 
94 ashish 1466 
  def getTransactionStatus(self, transactionId):
1467 
    """
1468 
    Parameters:
1469 
     - transactionId
1470 
    """
1471 
    self.send_getTransactionStatus(transactionId)
1472 
    return self.recv_getTransactionStatus()
1473 
 
1474 
  def send_getTransactionStatus(self, transactionId):
1475 
    self._oprot.writeMessageBegin('getTransactionStatus', TMessageType.CALL, self._seqid)
1476 
    args = getTransactionStatus_args()
1477 
    args.transactionId = transactionId
1478 
    args.write(self._oprot)
1479 
    self._oprot.writeMessageEnd()
1480 
    self._oprot.trans.flush()
1481 
 
1482 
  def recv_getTransactionStatus(self, ):
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
1489 
    result = getTransactionStatus_result()
1490 
    result.read(self._iprot)
1491 
    self._iprot.readMessageEnd()
3431 rajveer 1492 
    if result.success is not None:
94 ashish 1493 
      return result.success
3431 rajveer 1494 
    if result.ex is not None:
94 ashish 1495 
      raise result.ex
1496 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getTransactionStatus failed: unknown result");
1497 
 
5527 anupam.sin 1498 
  def changeTransactionStatus(self, transactionId, status, description, pickUp, orderType):
94 ashish 1499 
    """
1500 
    Parameters:
1501 
     - transactionId
1502 
     - status
1503 
     - description
5527 anupam.sin 1504 
     - pickUp
1505 
     - orderType
94 ashish 1506 
    """
5527 anupam.sin 1507 
    self.send_changeTransactionStatus(transactionId, status, description, pickUp, orderType)
94 ashish 1508 
    return self.recv_changeTransactionStatus()
1509 
 
5527 anupam.sin 1510 
  def send_changeTransactionStatus(self, transactionId, status, description, pickUp, orderType):
94 ashish 1511 
    self._oprot.writeMessageBegin('changeTransactionStatus', TMessageType.CALL, self._seqid)
1512 
    args = changeTransactionStatus_args()
1513 
    args.transactionId = transactionId
1514 
    args.status = status
1515 
    args.description = description
5527 anupam.sin 1516 
    args.pickUp = pickUp
1517 
    args.orderType = orderType
94 ashish 1518 
    args.write(self._oprot)
1519 
    self._oprot.writeMessageEnd()
1520 
    self._oprot.trans.flush()
1521 
 
1522 
  def recv_changeTransactionStatus(self, ):
1523 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1524 
    if mtype == TMessageType.EXCEPTION:
1525 
      x = TApplicationException()
1526 
      x.read(self._iprot)
1527 
      self._iprot.readMessageEnd()
1528 
      raise x
1529 
    result = changeTransactionStatus_result()
1530 
    result.read(self._iprot)
1531 
    self._iprot.readMessageEnd()
3431 rajveer 1532 
    if result.success is not None:
94 ashish 1533 
      return result.success
3431 rajveer 1534 
    if result.ex is not None:
94 ashish 1535 
      raise result.ex
1536 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "changeTransactionStatus failed: unknown result");
1537 
 
1398 varun.gupt 1538 
  def enqueueTransactionInfoEmail(self, transactionId):
1382 varun.gupt 1539 
    """
1540 
    Parameters:
1541 
     - transactionId
1542 
    """
1398 varun.gupt 1543 
    self.send_enqueueTransactionInfoEmail(transactionId)
1544 
    return self.recv_enqueueTransactionInfoEmail()
1382 varun.gupt 1545 
 
1398 varun.gupt 1546 
  def send_enqueueTransactionInfoEmail(self, transactionId):
1547 
    self._oprot.writeMessageBegin('enqueueTransactionInfoEmail', TMessageType.CALL, self._seqid)
1548 
    args = enqueueTransactionInfoEmail_args()
1382 varun.gupt 1549 
    args.transactionId = transactionId
1550 
    args.write(self._oprot)
1551 
    self._oprot.writeMessageEnd()
1552 
    self._oprot.trans.flush()
1553 
 
1398 varun.gupt 1554 
  def recv_enqueueTransactionInfoEmail(self, ):
1382 varun.gupt 1555 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1556 
    if mtype == TMessageType.EXCEPTION:
1557 
      x = TApplicationException()
1558 
      x.read(self._iprot)
1559 
      self._iprot.readMessageEnd()
1560 
      raise x
1398 varun.gupt 1561 
    result = enqueueTransactionInfoEmail_result()
1382 varun.gupt 1562 
    result.read(self._iprot)
1563 
    self._iprot.readMessageEnd()
3431 rajveer 1564 
    if result.success is not None:
1382 varun.gupt 1565 
      return result.success
3431 rajveer 1566 
    if result.ex is not None:
1382 varun.gupt 1567 
      raise result.ex
1398 varun.gupt 1568 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "enqueueTransactionInfoEmail failed: unknown result");
1382 varun.gupt 1569 
 
4801 anupam.sin 1570 
  def getAllOrders(self, statuses, from_date, to_date, warehouse_id):
94 ashish 1571 
    """
1572 
    Parameters:
4801 anupam.sin 1573 
     - statuses
483 rajveer 1574 
     - from_date
1575 
     - to_date
1576 
     - warehouse_id
94 ashish 1577 
    """
4801 anupam.sin 1578 
    self.send_getAllOrders(statuses, from_date, to_date, warehouse_id)
483 rajveer 1579 
    return self.recv_getAllOrders()
94 ashish 1580 
 
4801 anupam.sin 1581 
  def send_getAllOrders(self, statuses, from_date, to_date, warehouse_id):
483 rajveer 1582 
    self._oprot.writeMessageBegin('getAllOrders', TMessageType.CALL, self._seqid)
1583 
    args = getAllOrders_args()
4801 anupam.sin 1584 
    args.statuses = statuses
483 rajveer 1585 
    args.from_date = from_date
1586 
    args.to_date = to_date
1587 
    args.warehouse_id = warehouse_id
94 ashish 1588 
    args.write(self._oprot)
1589 
    self._oprot.writeMessageEnd()
1590 
    self._oprot.trans.flush()
1591 
 
483 rajveer 1592 
  def recv_getAllOrders(self, ):
94 ashish 1593 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1594 
    if mtype == TMessageType.EXCEPTION:
1595 
      x = TApplicationException()
1596 
      x.read(self._iprot)
1597 
      self._iprot.readMessageEnd()
1598 
      raise x
483 rajveer 1599 
    result = getAllOrders_result()
94 ashish 1600 
    result.read(self._iprot)
1601 
    self._iprot.readMessageEnd()
3431 rajveer 1602 
    if result.success is not None:
94 ashish 1603 
      return result.success
3431 rajveer 1604 
    if result.ex is not None:
94 ashish 1605 
      raise result.ex
483 rajveer 1606 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAllOrders failed: unknown result");
94 ashish 1607 
 
4133 chandransh 1608 
  def getOrdersInBatch(self, statuses, offset, limit, warehouse_id):
1609 
    """
1610 
    Returns at most 'limit' orders with the given statuses for the given warehouse starting from the given offset.
1611 
    Pass the status as null and the limit as 0 to ignore them.
1612 
 
1613 
    Parameters:
1614 
     - statuses
1615 
     - offset
1616 
     - limit
1617 
     - warehouse_id
1618 
    """
1619 
    self.send_getOrdersInBatch(statuses, offset, limit, warehouse_id)
1620 
    return self.recv_getOrdersInBatch()
1621 
 
1622 
  def send_getOrdersInBatch(self, statuses, offset, limit, warehouse_id):
1623 
    self._oprot.writeMessageBegin('getOrdersInBatch', TMessageType.CALL, self._seqid)
1624 
    args = getOrdersInBatch_args()
1625 
    args.statuses = statuses
1626 
    args.offset = offset
1627 
    args.limit = limit
1628 
    args.warehouse_id = warehouse_id
1629 
    args.write(self._oprot)
1630 
    self._oprot.writeMessageEnd()
1631 
    self._oprot.trans.flush()
1632 
 
1633 
  def recv_getOrdersInBatch(self, ):
1634 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1635 
    if mtype == TMessageType.EXCEPTION:
1636 
      x = TApplicationException()
1637 
      x.read(self._iprot)
1638 
      self._iprot.readMessageEnd()
1639 
      raise x
1640 
    result = getOrdersInBatch_result()
1641 
    result.read(self._iprot)
1642 
    self._iprot.readMessageEnd()
1643 
    if result.success is not None:
1644 
      return result.success
1645 
    if result.ex is not None:
1646 
      raise result.ex
1647 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getOrdersInBatch failed: unknown result");
1648 
 
1649 
  def getOrderCount(self, statuses, warehouseId):
1650 
    """
1651 
    Returns the count of orders with the given statuses assigned to the given warehouse.
1652 
 
1653 
    Parameters:
1654 
     - statuses
1655 
     - warehouseId
1656 
    """
1657 
    self.send_getOrderCount(statuses, warehouseId)
1658 
    return self.recv_getOrderCount()
1659 
 
1660 
  def send_getOrderCount(self, statuses, warehouseId):
1661 
    self._oprot.writeMessageBegin('getOrderCount', TMessageType.CALL, self._seqid)
1662 
    args = getOrderCount_args()
1663 
    args.statuses = statuses
1664 
    args.warehouseId = warehouseId
1665 
    args.write(self._oprot)
1666 
    self._oprot.writeMessageEnd()
1667 
    self._oprot.trans.flush()
1668 
 
1669 
  def recv_getOrderCount(self, ):
1670 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1671 
    if mtype == TMessageType.EXCEPTION:
1672 
      x = TApplicationException()
1673 
      x.read(self._iprot)
1674 
      self._iprot.readMessageEnd()
1675 
      raise x
1676 
    result = getOrderCount_result()
1677 
    result.read(self._iprot)
1678 
    self._iprot.readMessageEnd()
1679 
    if result.success is not None:
1680 
      return result.success
1681 
    if result.ex is not None:
1682 
      raise result.ex
1683 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getOrderCount failed: unknown result");
1684 
 
999 varun.gupt 1685 
  def getOrdersByBillingDate(self, status, start_billing_date, end_billing_date, warehouse_id):
1686 
    """
1132 chandransh 1687 
    Returns orders within a range of their billing dates
3431 rajveer 1688 
 
999 varun.gupt 1689 
    Parameters:
1690 
     - status
1691 
     - start_billing_date
1692 
     - end_billing_date
1693 
     - warehouse_id
1694 
    """
1695 
    self.send_getOrdersByBillingDate(status, start_billing_date, end_billing_date, warehouse_id)
1696 
    return self.recv_getOrdersByBillingDate()
1697 
 
1698 
  def send_getOrdersByBillingDate(self, status, start_billing_date, end_billing_date, warehouse_id):
1699 
    self._oprot.writeMessageBegin('getOrdersByBillingDate', TMessageType.CALL, self._seqid)
1700 
    args = getOrdersByBillingDate_args()
1701 
    args.status = status
1702 
    args.start_billing_date = start_billing_date
1703 
    args.end_billing_date = end_billing_date
1704 
    args.warehouse_id = warehouse_id
1705 
    args.write(self._oprot)
1706 
    self._oprot.writeMessageEnd()
1707 
    self._oprot.trans.flush()
1708 
 
1709 
  def recv_getOrdersByBillingDate(self, ):
1710 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1711 
    if mtype == TMessageType.EXCEPTION:
1712 
      x = TApplicationException()
1713 
      x.read(self._iprot)
1714 
      self._iprot.readMessageEnd()
1715 
      raise x
1716 
    result = getOrdersByBillingDate_result()
1717 
    result.read(self._iprot)
1718 
    self._iprot.readMessageEnd()
3431 rajveer 1719 
    if result.success is not None:
999 varun.gupt 1720 
      return result.success
3431 rajveer 1721 
    if result.ex is not None:
999 varun.gupt 1722 
      raise result.ex
1723 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getOrdersByBillingDate failed: unknown result");
1724 
 
3451 chandransh 1725 
  def getOrdersByShippingDate(self, fromShippingDate, toShippingDate, providerId, warehouseId, cod):
3427 chandransh 1726 
    """
1727 
    Returns orders for a particular provider and warehouse which were shipped between the given dates.
3451 chandransh 1728 
    Returned orders comprise of COD orders if cod parameter is true. It comprises of prepaid orders otherwise.
1729 
    Pass providerId and warehouseId as -1 to ignore both these parameters.
3431 rajveer 1730 
 
3427 chandransh 1731 
    Parameters:
1732 
     - fromShippingDate
1733 
     - toShippingDate
1734 
     - providerId
1735 
     - warehouseId
3451 chandransh 1736 
     - cod
3427 chandransh 1737 
    """
3451 chandransh 1738 
    self.send_getOrdersByShippingDate(fromShippingDate, toShippingDate, providerId, warehouseId, cod)
3427 chandransh 1739 
    return self.recv_getOrdersByShippingDate()
1740 
 
3451 chandransh 1741 
  def send_getOrdersByShippingDate(self, fromShippingDate, toShippingDate, providerId, warehouseId, cod):
3427 chandransh 1742 
    self._oprot.writeMessageBegin('getOrdersByShippingDate', TMessageType.CALL, self._seqid)
1743 
    args = getOrdersByShippingDate_args()
1744 
    args.fromShippingDate = fromShippingDate
1745 
    args.toShippingDate = toShippingDate
1746 
    args.providerId = providerId
1747 
    args.warehouseId = warehouseId
3451 chandransh 1748 
    args.cod = cod
3427 chandransh 1749 
    args.write(self._oprot)
1750 
    self._oprot.writeMessageEnd()
1751 
    self._oprot.trans.flush()
1752 
 
1753 
  def recv_getOrdersByShippingDate(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 = getOrdersByShippingDate_result()
1761 
    result.read(self._iprot)
1762 
    self._iprot.readMessageEnd()
3431 rajveer 1763 
    if result.success is not None:
3427 chandransh 1764 
      return result.success
3431 rajveer 1765 
    if result.ex is not None:
3427 chandransh 1766 
      raise result.ex
1767 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getOrdersByShippingDate failed: unknown result");
1768 
 
1382 varun.gupt 1769 
  def getReturnableOrdersForCustomer(self, customer_id, limit):
1770 
    """
1771 
    Returns order ids for orders which can be returned
3431 rajveer 1772 
 
1382 varun.gupt 1773 
    Parameters:
1774 
     - customer_id
1775 
     - limit
1776 
    """
1777 
    self.send_getReturnableOrdersForCustomer(customer_id, limit)
1778 
    return self.recv_getReturnableOrdersForCustomer()
1779 
 
1780 
  def send_getReturnableOrdersForCustomer(self, customer_id, limit):
1781 
    self._oprot.writeMessageBegin('getReturnableOrdersForCustomer', TMessageType.CALL, self._seqid)
1782 
    args = getReturnableOrdersForCustomer_args()
1783 
    args.customer_id = customer_id
1784 
    args.limit = limit
1785 
    args.write(self._oprot)
1786 
    self._oprot.writeMessageEnd()
1787 
    self._oprot.trans.flush()
1788 
 
1789 
  def recv_getReturnableOrdersForCustomer(self, ):
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
1796 
    result = getReturnableOrdersForCustomer_result()
1797 
    result.read(self._iprot)
1798 
    self._iprot.readMessageEnd()
3431 rajveer 1799 
    if result.success is not None:
1382 varun.gupt 1800 
      return result.success
3431 rajveer 1801 
    if result.ex is not None:
1382 varun.gupt 1802 
      raise result.ex
1803 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getReturnableOrdersForCustomer failed: unknown result");
1804 
 
1805 
  def getCancellableOrdersForCustomer(self, customer_id, limit):
1806 
    """
1807 
    Returns order ids for orders which can be cancelled
3431 rajveer 1808 
 
1382 varun.gupt 1809 
    Parameters:
1810 
     - customer_id
1811 
     - limit
1812 
    """
1813 
    self.send_getCancellableOrdersForCustomer(customer_id, limit)
1814 
    return self.recv_getCancellableOrdersForCustomer()
1815 
 
1816 
  def send_getCancellableOrdersForCustomer(self, customer_id, limit):
1817 
    self._oprot.writeMessageBegin('getCancellableOrdersForCustomer', TMessageType.CALL, self._seqid)
1818 
    args = getCancellableOrdersForCustomer_args()
1819 
    args.customer_id = customer_id
1820 
    args.limit = limit
1821 
    args.write(self._oprot)
1822 
    self._oprot.writeMessageEnd()
1823 
    self._oprot.trans.flush()
1824 
 
1825 
  def recv_getCancellableOrdersForCustomer(self, ):
1826 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1827 
    if mtype == TMessageType.EXCEPTION:
1828 
      x = TApplicationException()
1829 
      x.read(self._iprot)
1830 
      self._iprot.readMessageEnd()
1831 
      raise x
1832 
    result = getCancellableOrdersForCustomer_result()
1833 
    result.read(self._iprot)
1834 
    self._iprot.readMessageEnd()
3431 rajveer 1835 
    if result.success is not None:
1382 varun.gupt 1836 
      return result.success
3431 rajveer 1837 
    if result.ex is not None:
1382 varun.gupt 1838 
      raise result.ex
1839 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getCancellableOrdersForCustomer failed: unknown result");
1840 
 
483 rajveer 1841 
  def changeOrderStatus(self, orderId, status, description):
94 ashish 1842 
    """
1843 
    Parameters:
483 rajveer 1844 
     - orderId
1845 
     - status
1846 
     - description
94 ashish 1847 
    """
483 rajveer 1848 
    self.send_changeOrderStatus(orderId, status, description)
1849 
    return self.recv_changeOrderStatus()
94 ashish 1850 
 
483 rajveer 1851 
  def send_changeOrderStatus(self, orderId, status, description):
1852 
    self._oprot.writeMessageBegin('changeOrderStatus', TMessageType.CALL, self._seqid)
1853 
    args = changeOrderStatus_args()
1854 
    args.orderId = orderId
1855 
    args.status = status
1856 
    args.description = description
94 ashish 1857 
    args.write(self._oprot)
1858 
    self._oprot.writeMessageEnd()
1859 
    self._oprot.trans.flush()
1860 
 
483 rajveer 1861 
  def recv_changeOrderStatus(self, ):
94 ashish 1862 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1863 
    if mtype == TMessageType.EXCEPTION:
1864 
      x = TApplicationException()
1865 
      x.read(self._iprot)
1866 
      self._iprot.readMessageEnd()
1867 
      raise x
483 rajveer 1868 
    result = changeOrderStatus_result()
94 ashish 1869 
    result.read(self._iprot)
1870 
    self._iprot.readMessageEnd()
3431 rajveer 1871 
    if result.success is not None:
94 ashish 1872 
      return result.success
3431 rajveer 1873 
    if result.ex is not None:
94 ashish 1874 
      raise result.ex
483 rajveer 1875 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "changeOrderStatus failed: unknown result");
94 ashish 1876 
 
1528 ankur.sing 1877 
  def getOrdersForTransaction(self, transactionId, customerId):
94 ashish 1878 
    """
1528 ankur.sing 1879 
    Returns list of orders for given transaction Id. Also filters based on customer Id so that
1880 
    only user who owns the transaction can view its order details.
3431 rajveer 1881 
 
94 ashish 1882 
    Parameters:
1883 
     - transactionId
1528 ankur.sing 1884 
     - customerId
94 ashish 1885 
    """
1528 ankur.sing 1886 
    self.send_getOrdersForTransaction(transactionId, customerId)
483 rajveer 1887 
    return self.recv_getOrdersForTransaction()
94 ashish 1888 
 
1528 ankur.sing 1889 
  def send_getOrdersForTransaction(self, transactionId, customerId):
483 rajveer 1890 
    self._oprot.writeMessageBegin('getOrdersForTransaction', TMessageType.CALL, self._seqid)
1891 
    args = getOrdersForTransaction_args()
94 ashish 1892 
    args.transactionId = transactionId
1528 ankur.sing 1893 
    args.customerId = customerId
94 ashish 1894 
    args.write(self._oprot)
1895 
    self._oprot.writeMessageEnd()
1896 
    self._oprot.trans.flush()
1897 
 
483 rajveer 1898 
  def recv_getOrdersForTransaction(self, ):
94 ashish 1899 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1900 
    if mtype == TMessageType.EXCEPTION:
1901 
      x = TApplicationException()
1902 
      x.read(self._iprot)
1903 
      self._iprot.readMessageEnd()
1904 
      raise x
483 rajveer 1905 
    result = getOrdersForTransaction_result()
94 ashish 1906 
    result.read(self._iprot)
1907 
    self._iprot.readMessageEnd()
3431 rajveer 1908 
    if result.success is not None:
94 ashish 1909 
      return result.success
3431 rajveer 1910 
    if result.ex is not None:
94 ashish 1911 
      raise result.ex
483 rajveer 1912 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getOrdersForTransaction failed: unknown result");
94 ashish 1913 
 
3014 chandransh 1914 
  def getOrdersForCustomer(self, customerId, from_date, to_date, statuses):
94 ashish 1915 
    """
3014 chandransh 1916 
    Returns list of orders for the given customer created between the given dates and having the given statuses.
1917 
    Pass and empty list to ignore filtering on statuses.
3431 rajveer 1918 
 
94 ashish 1919 
    Parameters:
483 rajveer 1920 
     - customerId
1921 
     - from_date
1922 
     - to_date
3014 chandransh 1923 
     - statuses
94 ashish 1924 
    """
3014 chandransh 1925 
    self.send_getOrdersForCustomer(customerId, from_date, to_date, statuses)
483 rajveer 1926 
    return self.recv_getOrdersForCustomer()
94 ashish 1927 
 
3014 chandransh 1928 
  def send_getOrdersForCustomer(self, customerId, from_date, to_date, statuses):
483 rajveer 1929 
    self._oprot.writeMessageBegin('getOrdersForCustomer', TMessageType.CALL, self._seqid)
1930 
    args = getOrdersForCustomer_args()
1931 
    args.customerId = customerId
1932 
    args.from_date = from_date
1933 
    args.to_date = to_date
3014 chandransh 1934 
    args.statuses = statuses
94 ashish 1935 
    args.write(self._oprot)
1936 
    self._oprot.writeMessageEnd()
1937 
    self._oprot.trans.flush()
1938 
 
483 rajveer 1939 
  def recv_getOrdersForCustomer(self, ):
94 ashish 1940 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1941 
    if mtype == TMessageType.EXCEPTION:
1942 
      x = TApplicationException()
1943 
      x.read(self._iprot)
1944 
      self._iprot.readMessageEnd()
1945 
      raise x
483 rajveer 1946 
    result = getOrdersForCustomer_result()
94 ashish 1947 
    result.read(self._iprot)
1948 
    self._iprot.readMessageEnd()
3431 rajveer 1949 
    if result.success is not None:
94 ashish 1950 
      return result.success
3431 rajveer 1951 
    if result.ex is not None:
94 ashish 1952 
      raise result.ex
483 rajveer 1953 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getOrdersForCustomer failed: unknown result");
94 ashish 1954 
 
483 rajveer 1955 
  def createOrder(self, order):
94 ashish 1956 
    """
1957 
    Parameters:
483 rajveer 1958 
     - order
94 ashish 1959 
    """
483 rajveer 1960 
    self.send_createOrder(order)
1961 
    return self.recv_createOrder()
94 ashish 1962 
 
483 rajveer 1963 
  def send_createOrder(self, order):
1964 
    self._oprot.writeMessageBegin('createOrder', TMessageType.CALL, self._seqid)
1965 
    args = createOrder_args()
1966 
    args.order = order
94 ashish 1967 
    args.write(self._oprot)
1968 
    self._oprot.writeMessageEnd()
1969 
    self._oprot.trans.flush()
1970 
 
483 rajveer 1971 
  def recv_createOrder(self, ):
94 ashish 1972 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1973 
    if mtype == TMessageType.EXCEPTION:
1974 
      x = TApplicationException()
1975 
      x.read(self._iprot)
1976 
      self._iprot.readMessageEnd()
1977 
      raise x
483 rajveer 1978 
    result = createOrder_result()
94 ashish 1979 
    result.read(self._iprot)
1980 
    self._iprot.readMessageEnd()
3431 rajveer 1981 
    if result.success is not None:
94 ashish 1982 
      return result.success
3431 rajveer 1983 
    if result.ex is not None:
94 ashish 1984 
      raise result.ex
483 rajveer 1985 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "createOrder failed: unknown result");
94 ashish 1986 
 
483 rajveer 1987 
  def getOrder(self, id):
94 ashish 1988 
    """
1989 
    Parameters:
483 rajveer 1990 
     - id
94 ashish 1991 
    """
483 rajveer 1992 
    self.send_getOrder(id)
1993 
    return self.recv_getOrder()
94 ashish 1994 
 
483 rajveer 1995 
  def send_getOrder(self, id):
1996 
    self._oprot.writeMessageBegin('getOrder', TMessageType.CALL, self._seqid)
1997 
    args = getOrder_args()
1998 
    args.id = id
94 ashish 1999 
    args.write(self._oprot)
2000 
    self._oprot.writeMessageEnd()
2001 
    self._oprot.trans.flush()
2002 
 
483 rajveer 2003 
  def recv_getOrder(self, ):
94 ashish 2004 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2005 
    if mtype == TMessageType.EXCEPTION:
2006 
      x = TApplicationException()
2007 
      x.read(self._iprot)
2008 
      self._iprot.readMessageEnd()
2009 
      raise x
483 rajveer 2010 
    result = getOrder_result()
94 ashish 2011 
    result.read(self._iprot)
2012 
    self._iprot.readMessageEnd()
3431 rajveer 2013 
    if result.success is not None:
94 ashish 2014 
      return result.success
3431 rajveer 2015 
    if result.ex is not None:
94 ashish 2016 
      raise result.ex
483 rajveer 2017 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getOrder failed: unknown result");
94 ashish 2018 
 
483 rajveer 2019 
  def getLineItemsForOrder(self, orderId):
94 ashish 2020 
    """
2021 
    Parameters:
483 rajveer 2022 
     - orderId
94 ashish 2023 
    """
483 rajveer 2024 
    self.send_getLineItemsForOrder(orderId)
2025 
    return self.recv_getLineItemsForOrder()
94 ashish 2026 
 
483 rajveer 2027 
  def send_getLineItemsForOrder(self, orderId):
2028 
    self._oprot.writeMessageBegin('getLineItemsForOrder', TMessageType.CALL, self._seqid)
2029 
    args = getLineItemsForOrder_args()
2030 
    args.orderId = orderId
94 ashish 2031 
    args.write(self._oprot)
2032 
    self._oprot.writeMessageEnd()
2033 
    self._oprot.trans.flush()
2034 
 
483 rajveer 2035 
  def recv_getLineItemsForOrder(self, ):
94 ashish 2036 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2037 
    if mtype == TMessageType.EXCEPTION:
2038 
      x = TApplicationException()
2039 
      x.read(self._iprot)
2040 
      self._iprot.readMessageEnd()
2041 
      raise x
483 rajveer 2042 
    result = getLineItemsForOrder_result()
94 ashish 2043 
    result.read(self._iprot)
2044 
    self._iprot.readMessageEnd()
3431 rajveer 2045 
    if result.success is not None:
94 ashish 2046 
      return result.success
3431 rajveer 2047 
    if result.ex is not None:
94 ashish 2048 
      raise result.ex
483 rajveer 2049 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getLineItemsForOrder failed: unknown result");
94 ashish 2050 
 
4999 phani.kuma 2051 
  def getOrderList(self, order_ids):
2052 
    """
2053 
    Parameters:
2054 
     - order_ids
2055 
    """
2056 
    self.send_getOrderList(order_ids)
2057 
    return self.recv_getOrderList()
2058 
 
2059 
  def send_getOrderList(self, order_ids):
2060 
    self._oprot.writeMessageBegin('getOrderList', TMessageType.CALL, self._seqid)
2061 
    args = getOrderList_args()
2062 
    args.order_ids = order_ids
2063 
    args.write(self._oprot)
2064 
    self._oprot.writeMessageEnd()
2065 
    self._oprot.trans.flush()
2066 
 
2067 
  def recv_getOrderList(self, ):
2068 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2069 
    if mtype == TMessageType.EXCEPTION:
2070 
      x = TApplicationException()
2071 
      x.read(self._iprot)
2072 
      self._iprot.readMessageEnd()
2073 
      raise x
2074 
    result = getOrderList_result()
2075 
    result.read(self._iprot)
2076 
    self._iprot.readMessageEnd()
2077 
    if result.success is not None:
2078 
      return result.success
2079 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getOrderList failed: unknown result");
2080 
 
5386 phani.kuma 2081 
  def getOrderListForVendor(self, order_ids, vendorId):
2082 
    """
2083 
    Parameters:
2084 
     - order_ids
2085 
     - vendorId
2086 
    """
2087 
    self.send_getOrderListForVendor(order_ids, vendorId)
2088 
    return self.recv_getOrderListForVendor()
2089 
 
2090 
  def send_getOrderListForVendor(self, order_ids, vendorId):
2091 
    self._oprot.writeMessageBegin('getOrderListForVendor', TMessageType.CALL, self._seqid)
2092 
    args = getOrderListForVendor_args()
2093 
    args.order_ids = order_ids
2094 
    args.vendorId = vendorId
2095 
    args.write(self._oprot)
2096 
    self._oprot.writeMessageEnd()
2097 
    self._oprot.trans.flush()
2098 
 
2099 
  def recv_getOrderListForVendor(self, ):
2100 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2101 
    if mtype == TMessageType.EXCEPTION:
2102 
      x = TApplicationException()
2103 
      x.read(self._iprot)
2104 
      self._iprot.readMessageEnd()
2105 
      raise x
2106 
    result = getOrderListForVendor_result()
2107 
    result.read(self._iprot)
2108 
    self._iprot.readMessageEnd()
2109 
    if result.success is not None:
2110 
      return result.success
2111 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getOrderListForVendor failed: unknown result");
2112 
 
1528 ankur.sing 2113 
  def getOrderForCustomer(self, orderId, customerId):
2114 
    """
2115 
    Returns an order for the order Id. Also checks if the order belongs to the customer whose Id is passed.
2116 
    Throws exception if either order Id is invalid or order does not below to the customer whose Id is passed.
3431 rajveer 2117 
 
1528 ankur.sing 2118 
    Parameters:
2119 
     - orderId
2120 
     - customerId
2121 
    """
2122 
    self.send_getOrderForCustomer(orderId, customerId)
2123 
    return self.recv_getOrderForCustomer()
2124 
 
2125 
  def send_getOrderForCustomer(self, orderId, customerId):
2126 
    self._oprot.writeMessageBegin('getOrderForCustomer', TMessageType.CALL, self._seqid)
2127 
    args = getOrderForCustomer_args()
2128 
    args.orderId = orderId
2129 
    args.customerId = customerId
2130 
    args.write(self._oprot)
2131 
    self._oprot.writeMessageEnd()
2132 
    self._oprot.trans.flush()
2133 
 
2134 
  def recv_getOrderForCustomer(self, ):
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
2141 
    result = getOrderForCustomer_result()
2142 
    result.read(self._iprot)
2143 
    self._iprot.readMessageEnd()
3431 rajveer 2144 
    if result.success is not None:
1528 ankur.sing 2145 
      return result.success
3431 rajveer 2146 
    if result.ex is not None:
1528 ankur.sing 2147 
      raise result.ex
2148 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getOrderForCustomer failed: unknown result");
2149 
 
4444 rajveer 2150 
  def getAlerts(self, type, warehouseId, status, timestamp):
3064 chandransh 2151 
    """
2152 
    Parameters:
4394 rajveer 2153 
     - type
4444 rajveer 2154 
     - warehouseId
4394 rajveer 2155 
     - status
2156 
     - timestamp
3064 chandransh 2157 
    """
4444 rajveer 2158 
    self.send_getAlerts(type, warehouseId, status, timestamp)
3064 chandransh 2159 
    return self.recv_getAlerts()
2160 
 
4444 rajveer 2161 
  def send_getAlerts(self, type, warehouseId, status, timestamp):
3064 chandransh 2162 
    self._oprot.writeMessageBegin('getAlerts', TMessageType.CALL, self._seqid)
2163 
    args = getAlerts_args()
4394 rajveer 2164 
    args.type = type
4444 rajveer 2165 
    args.warehouseId = warehouseId
4394 rajveer 2166 
    args.status = status
2167 
    args.timestamp = timestamp
3064 chandransh 2168 
    args.write(self._oprot)
2169 
    self._oprot.writeMessageEnd()
2170 
    self._oprot.trans.flush()
2171 
 
2172 
  def recv_getAlerts(self, ):
2173 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2174 
    if mtype == TMessageType.EXCEPTION:
2175 
      x = TApplicationException()
2176 
      x.read(self._iprot)
2177 
      self._iprot.readMessageEnd()
2178 
      raise x
2179 
    result = getAlerts_result()
2180 
    result.read(self._iprot)
2181 
    self._iprot.readMessageEnd()
3431 rajveer 2182 
    if result.success is not None:
3064 chandransh 2183 
      return result.success
2184 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAlerts failed: unknown result");
2185 
 
4444 rajveer 2186 
  def addAlert(self, type, warehouseId, description):
3064 chandransh 2187 
    """
2188 
    Parameters:
2189 
     - type
4444 rajveer 2190 
     - warehouseId
4394 rajveer 2191 
     - description
3064 chandransh 2192 
    """
4444 rajveer 2193 
    self.send_addAlert(type, warehouseId, description)
4394 rajveer 2194 
    self.recv_addAlert()
3064 chandransh 2195 
 
4444 rajveer 2196 
  def send_addAlert(self, type, warehouseId, description):
4394 rajveer 2197 
    self._oprot.writeMessageBegin('addAlert', TMessageType.CALL, self._seqid)
2198 
    args = addAlert_args()
3064 chandransh 2199 
    args.type = type
4444 rajveer 2200 
    args.warehouseId = warehouseId
4394 rajveer 2201 
    args.description = description
3064 chandransh 2202 
    args.write(self._oprot)
2203 
    self._oprot.writeMessageEnd()
2204 
    self._oprot.trans.flush()
2205 
 
4394 rajveer 2206 
  def recv_addAlert(self, ):
3064 chandransh 2207 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2208 
    if mtype == TMessageType.EXCEPTION:
2209 
      x = TApplicationException()
2210 
      x.read(self._iprot)
2211 
      self._iprot.readMessageEnd()
2212 
      raise x
4394 rajveer 2213 
    result = addAlert_result()
3064 chandransh 2214 
    result.read(self._iprot)
2215 
    self._iprot.readMessageEnd()
2216 
    return
2217 
 
4444 rajveer 2218 
  def markAlertsAsSeen(self, warehouseId):
2219 
    """
2220 
    Parameters:
2221 
     - warehouseId
2222 
    """
2223 
    self.send_markAlertsAsSeen(warehouseId)
2224 
    self.recv_markAlertsAsSeen()
2225 
 
2226 
  def send_markAlertsAsSeen(self, warehouseId):
2227 
    self._oprot.writeMessageBegin('markAlertsAsSeen', TMessageType.CALL, self._seqid)
2228 
    args = markAlertsAsSeen_args()
2229 
    args.warehouseId = warehouseId
2230 
    args.write(self._oprot)
2231 
    self._oprot.writeMessageEnd()
2232 
    self._oprot.trans.flush()
2233 
 
2234 
  def recv_markAlertsAsSeen(self, ):
2235 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2236 
    if mtype == TMessageType.EXCEPTION:
2237 
      x = TApplicationException()
2238 
      x.read(self._iprot)
2239 
      self._iprot.readMessageEnd()
2240 
      raise x
2241 
    result = markAlertsAsSeen_result()
2242 
    result.read(self._iprot)
2243 
    self._iprot.readMessageEnd()
2244 
    return
2245 
 
3064 chandransh 2246 
  def getValidOrderCount(self, ):
2247 
    """
2248 
    Return the number of valid orders. (OrderStatus >= OrderStatus.SUBMITTED_FOR_PROCESSING)
2249 
    """
2250 
    self.send_getValidOrderCount()
2251 
    return self.recv_getValidOrderCount()
2252 
 
2253 
  def send_getValidOrderCount(self, ):
2254 
    self._oprot.writeMessageBegin('getValidOrderCount', TMessageType.CALL, self._seqid)
2255 
    args = getValidOrderCount_args()
2256 
    args.write(self._oprot)
2257 
    self._oprot.writeMessageEnd()
2258 
    self._oprot.trans.flush()
2259 
 
2260 
  def recv_getValidOrderCount(self, ):
2261 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2262 
    if mtype == TMessageType.EXCEPTION:
2263 
      x = TApplicationException()
2264 
      x.read(self._iprot)
2265 
      self._iprot.readMessageEnd()
2266 
      raise x
2267 
    result = getValidOrderCount_result()
2268 
    result.read(self._iprot)
2269 
    self._iprot.readMessageEnd()
3431 rajveer 2270 
    if result.success is not None:
3064 chandransh 2271 
      return result.success
2272 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getValidOrderCount failed: unknown result");
2273 
 
2274 
  def getNoOfCustomersWithSuccessfulTransaction(self, ):
2275 
    """
2276 
    Returns the number of distinct customers who have done successful transactions
2277 
    """
2278 
    self.send_getNoOfCustomersWithSuccessfulTransaction()
2279 
    return self.recv_getNoOfCustomersWithSuccessfulTransaction()
2280 
 
2281 
  def send_getNoOfCustomersWithSuccessfulTransaction(self, ):
2282 
    self._oprot.writeMessageBegin('getNoOfCustomersWithSuccessfulTransaction', TMessageType.CALL, self._seqid)
2283 
    args = getNoOfCustomersWithSuccessfulTransaction_args()
2284 
    args.write(self._oprot)
2285 
    self._oprot.writeMessageEnd()
2286 
    self._oprot.trans.flush()
2287 
 
2288 
  def recv_getNoOfCustomersWithSuccessfulTransaction(self, ):
2289 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2290 
    if mtype == TMessageType.EXCEPTION:
2291 
      x = TApplicationException()
2292 
      x.read(self._iprot)
2293 
      self._iprot.readMessageEnd()
2294 
      raise x
2295 
    result = getNoOfCustomersWithSuccessfulTransaction_result()
2296 
    result.read(self._iprot)
2297 
    self._iprot.readMessageEnd()
3431 rajveer 2298 
    if result.success is not None:
3064 chandransh 2299 
      return result.success
2300 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getNoOfCustomersWithSuccessfulTransaction failed: unknown result");
2301 
 
2302 
  def getValidOrdersAmountRange(self, ):
2303 
    """
2304 
    Returns the minimum and maximum amounts of a valid order. (OrderStatus >= OrderStatus.SUBMITTED_FOR_PROCESSING)
2305 
    List contains two values, first minimum amount and second maximum amount.
2306 
    """
2307 
    self.send_getValidOrdersAmountRange()
2308 
    return self.recv_getValidOrdersAmountRange()
2309 
 
2310 
  def send_getValidOrdersAmountRange(self, ):
2311 
    self._oprot.writeMessageBegin('getValidOrdersAmountRange', TMessageType.CALL, self._seqid)
2312 
    args = getValidOrdersAmountRange_args()
2313 
    args.write(self._oprot)
2314 
    self._oprot.writeMessageEnd()
2315 
    self._oprot.trans.flush()
2316 
 
2317 
  def recv_getValidOrdersAmountRange(self, ):
2318 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2319 
    if mtype == TMessageType.EXCEPTION:
2320 
      x = TApplicationException()
2321 
      x.read(self._iprot)
2322 
      self._iprot.readMessageEnd()
2323 
      raise x
2324 
    result = getValidOrdersAmountRange_result()
2325 
    result.read(self._iprot)
2326 
    self._iprot.readMessageEnd()
3431 rajveer 2327 
    if result.success is not None:
3064 chandransh 2328 
      return result.success
2329 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getValidOrdersAmountRange failed: unknown result");
2330 
 
5874 rajveer 2331 
  def getValidOrders(self, limit, onlyStore):
3064 chandransh 2332 
    """
2333 
    Returns list of Orders in descending order by Order creation date. List is restricted to limit Orders.
2334 
    If limit is passed as 0, then all valid Orders are returned.
3431 rajveer 2335 
 
3064 chandransh 2336 
    Parameters:
2337 
     - limit
5874 rajveer 2338 
     - onlyStore
3064 chandransh 2339 
    """
5874 rajveer 2340 
    self.send_getValidOrders(limit, onlyStore)
3064 chandransh 2341 
    return self.recv_getValidOrders()
2342 
 
5874 rajveer 2343 
  def send_getValidOrders(self, limit, onlyStore):
3064 chandransh 2344 
    self._oprot.writeMessageBegin('getValidOrders', TMessageType.CALL, self._seqid)
2345 
    args = getValidOrders_args()
2346 
    args.limit = limit
5874 rajveer 2347 
    args.onlyStore = onlyStore
3064 chandransh 2348 
    args.write(self._oprot)
2349 
    self._oprot.writeMessageEnd()
2350 
    self._oprot.trans.flush()
2351 
 
2352 
  def recv_getValidOrders(self, ):
2353 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2354 
    if mtype == TMessageType.EXCEPTION:
2355 
      x = TApplicationException()
2356 
      x.read(self._iprot)
2357 
      self._iprot.readMessageEnd()
2358 
      raise x
2359 
    result = getValidOrders_result()
2360 
    result.read(self._iprot)
2361 
    self._iprot.readMessageEnd()
3431 rajveer 2362 
    if result.success is not None:
3064 chandransh 2363 
      return result.success
2364 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getValidOrders failed: unknown result");
2365 
 
1220 chandransh 2366 
  def batchOrders(self, warehouseId):
2367 
    """
2368 
    Create a batch of all the pending orders for the given warehouse.
2369 
    The returned list is orderd by created_timestamp.
2370 
    If there are no pending orders, an empty list is returned.
3431 rajveer 2371 
 
1220 chandransh 2372 
    Parameters:
2373 
     - warehouseId
2374 
    """
2375 
    self.send_batchOrders(warehouseId)
2376 
    return self.recv_batchOrders()
2377 
 
2378 
  def send_batchOrders(self, warehouseId):
2379 
    self._oprot.writeMessageBegin('batchOrders', TMessageType.CALL, self._seqid)
2380 
    args = batchOrders_args()
2381 
    args.warehouseId = warehouseId
2382 
    args.write(self._oprot)
2383 
    self._oprot.writeMessageEnd()
2384 
    self._oprot.trans.flush()
2385 
 
2386 
  def recv_batchOrders(self, ):
2387 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2388 
    if mtype == TMessageType.EXCEPTION:
2389 
      x = TApplicationException()
2390 
      x.read(self._iprot)
2391 
      self._iprot.readMessageEnd()
2392 
      raise x
2393 
    result = batchOrders_result()
2394 
    result.read(self._iprot)
2395 
    self._iprot.readMessageEnd()
3431 rajveer 2396 
    if result.success is not None:
1220 chandransh 2397 
      return result.success
3431 rajveer 2398 
    if result.ex is not None:
1220 chandransh 2399 
      raise result.ex
2400 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "batchOrders failed: unknown result");
2401 
 
1208 chandransh 2402 
  def markOrderAsOutOfStock(self, orderId):
2403 
    """
2404 
    Mark the given order as out of stock. Throws an exception if the order with the given Id couldn't be found.
3431 rajveer 2405 
 
1208 chandransh 2406 
    Parameters:
2407 
     - orderId
2408 
    """
2409 
    self.send_markOrderAsOutOfStock(orderId)
2410 
    return self.recv_markOrderAsOutOfStock()
2411 
 
2412 
  def send_markOrderAsOutOfStock(self, orderId):
2413 
    self._oprot.writeMessageBegin('markOrderAsOutOfStock', TMessageType.CALL, self._seqid)
2414 
    args = markOrderAsOutOfStock_args()
2415 
    args.orderId = orderId
2416 
    args.write(self._oprot)
2417 
    self._oprot.writeMessageEnd()
2418 
    self._oprot.trans.flush()
2419 
 
2420 
  def recv_markOrderAsOutOfStock(self, ):
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
2427 
    result = markOrderAsOutOfStock_result()
2428 
    result.read(self._iprot)
2429 
    self._iprot.readMessageEnd()
3431 rajveer 2430 
    if result.success is not None:
1208 chandransh 2431 
      return result.success
3431 rajveer 2432 
    if result.ex is not None:
1208 chandransh 2433 
      raise result.ex
2434 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "markOrderAsOutOfStock failed: unknown result");
2435 
 
3064 chandransh 2436 
  def verifyOrder(self, orderId):
759 chandransh 2437 
    """
3064 chandransh 2438 
    Marks the given order as SUBMITTED_FOR_PROCESSING and updates the verified
2439 
    timestamp. It is intended to be used for COD orders but can be harmlessly
2440 
    used for all other orders as well.
2441 
    Throws an exception if no such order exists.
3431 rajveer 2442 
 
759 chandransh 2443 
    Parameters:
3064 chandransh 2444 
     - orderId
759 chandransh 2445 
    """
3064 chandransh 2446 
    self.send_verifyOrder(orderId)
2447 
    return self.recv_verifyOrder()
759 chandransh 2448 
 
3064 chandransh 2449 
  def send_verifyOrder(self, orderId):
2450 
    self._oprot.writeMessageBegin('verifyOrder', TMessageType.CALL, self._seqid)
2451 
    args = verifyOrder_args()
2452 
    args.orderId = orderId
759 chandransh 2453 
    args.write(self._oprot)
2454 
    self._oprot.writeMessageEnd()
2455 
    self._oprot.trans.flush()
2456 
 
3064 chandransh 2457 
  def recv_verifyOrder(self, ):
759 chandransh 2458 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2459 
    if mtype == TMessageType.EXCEPTION:
2460 
      x = TApplicationException()
2461 
      x.read(self._iprot)
2462 
      self._iprot.readMessageEnd()
2463 
      raise x
3064 chandransh 2464 
    result = verifyOrder_result()
759 chandransh 2465 
    result.read(self._iprot)
2466 
    self._iprot.readMessageEnd()
3431 rajveer 2467 
    if result.success is not None:
759 chandransh 2468 
      return result.success
3431 rajveer 2469 
    if result.ex is not None:
759 chandransh 2470 
      raise result.ex
3064 chandransh 2471 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "verifyOrder failed: unknown result");
759 chandransh 2472 
 
3064 chandransh 2473 
  def acceptOrder(self, orderId):
1113 chandransh 2474 
    """
3064 chandransh 2475 
    Marks the given order as ACCEPTED and updates the accepted timestamp. If the
2476 
    given order is not a COD order, it also captures the payment if the same has
2477 
    not been captured.
2478 
    Throws an exception if no such order exists.
3431 rajveer 2479 
 
1113 chandransh 2480 
    Parameters:
3064 chandransh 2481 
     - orderId
1113 chandransh 2482 
    """
3064 chandransh 2483 
    self.send_acceptOrder(orderId)
2484 
    return self.recv_acceptOrder()
1113 chandransh 2485 
 
3064 chandransh 2486 
  def send_acceptOrder(self, orderId):
2487 
    self._oprot.writeMessageBegin('acceptOrder', TMessageType.CALL, self._seqid)
2488 
    args = acceptOrder_args()
2489 
    args.orderId = orderId
1113 chandransh 2490 
    args.write(self._oprot)
2491 
    self._oprot.writeMessageEnd()
2492 
    self._oprot.trans.flush()
2493 
 
3064 chandransh 2494 
  def recv_acceptOrder(self, ):
1113 chandransh 2495 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2496 
    if mtype == TMessageType.EXCEPTION:
2497 
      x = TApplicationException()
2498 
      x.read(self._iprot)
2499 
      self._iprot.readMessageEnd()
2500 
      raise x
3064 chandransh 2501 
    result = acceptOrder_result()
1113 chandransh 2502 
    result.read(self._iprot)
2503 
    self._iprot.readMessageEnd()
3431 rajveer 2504 
    if result.success is not None:
1113 chandransh 2505 
      return result.success
3431 rajveer 2506 
    if result.ex is not None:
1113 chandransh 2507 
      raise result.ex
3064 chandransh 2508 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "acceptOrder failed: unknown result");
1113 chandransh 2509 
 
5110 mandeep.dh 2510 
  def addBillingDetails(self, orderId, invoice_number, serialNumber, itemNumber, billed_by, jacketNumber, billingType, fulfilmentWarehouseId, authorize):
1132 chandransh 2511 
    """
3064 chandransh 2512 
    Add billing details such as the bill number and the biller to the Order.
4658 mandeep.dh 2513 
    Adds jacket number, item number and Serial no. to the order. Doesn't update
4283 anupam.sin 2514 
    the IMEI no. if a -1 is supplied.
2515 
    Also, it generates an invoice number for the order, marks the order as
2516 
    BILLED and sets the billing timestamp.
2517 
    Returns false if it doesn't find the order with the given ID.
3431 rajveer 2518 
 
1135 chandransh 2519 
    Parameters:
3064 chandransh 2520 
     - orderId
2521 
     - invoice_number
4658 mandeep.dh 2522 
     - serialNumber
4283 anupam.sin 2523 
     - itemNumber
3064 chandransh 2524 
     - billed_by
4264 rajveer 2525 
     - jacketNumber
4283 anupam.sin 2526 
     - billingType
5110 mandeep.dh 2527 
     - fulfilmentWarehouseId
4763 rajveer 2528 
     - authorize
1135 chandransh 2529 
    """
5110 mandeep.dh 2530 
    self.send_addBillingDetails(orderId, invoice_number, serialNumber, itemNumber, billed_by, jacketNumber, billingType, fulfilmentWarehouseId, authorize)
3064 chandransh 2531 
    return self.recv_addBillingDetails()
1135 chandransh 2532 
 
5110 mandeep.dh 2533 
  def send_addBillingDetails(self, orderId, invoice_number, serialNumber, itemNumber, billed_by, jacketNumber, billingType, fulfilmentWarehouseId, authorize):
3064 chandransh 2534 
    self._oprot.writeMessageBegin('addBillingDetails', TMessageType.CALL, self._seqid)
2535 
    args = addBillingDetails_args()
2536 
    args.orderId = orderId
2537 
    args.invoice_number = invoice_number
4658 mandeep.dh 2538 
    args.serialNumber = serialNumber
4283 anupam.sin 2539 
    args.itemNumber = itemNumber
3064 chandransh 2540 
    args.billed_by = billed_by
4264 rajveer 2541 
    args.jacketNumber = jacketNumber
4283 anupam.sin 2542 
    args.billingType = billingType
5110 mandeep.dh 2543 
    args.fulfilmentWarehouseId = fulfilmentWarehouseId
4763 rajveer 2544 
    args.authorize = authorize
1135 chandransh 2545 
    args.write(self._oprot)
2546 
    self._oprot.writeMessageEnd()
2547 
    self._oprot.trans.flush()
2548 
 
3064 chandransh 2549 
  def recv_addBillingDetails(self, ):
1135 chandransh 2550 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2551 
    if mtype == TMessageType.EXCEPTION:
2552 
      x = TApplicationException()
2553 
      x.read(self._iprot)
2554 
      self._iprot.readMessageEnd()
2555 
      raise x
3064 chandransh 2556 
    result = addBillingDetails_result()
1135 chandransh 2557 
    result.read(self._iprot)
2558 
    self._iprot.readMessageEnd()
3431 rajveer 2559 
    if result.success is not None:
3064 chandransh 2560 
      return result.success
3431 rajveer 2561 
    if result.ex is not None:
1135 chandransh 2562 
      raise result.ex
3064 chandransh 2563 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "addBillingDetails failed: unknown result");
1135 chandransh 2564 
 
4763 rajveer 2565 
  def addInvoiceNumber(self, orderId, invoiceNumber, color):
4579 rajveer 2566 
    """
2567 
    Add the invoice number to the order.
2568 
 
2569 
    Parameters:
2570 
     - orderId
2571 
     - invoiceNumber
4763 rajveer 2572 
     - color
4579 rajveer 2573 
    """
4763 rajveer 2574 
    self.send_addInvoiceNumber(orderId, invoiceNumber, color)
4579 rajveer 2575 
    self.recv_addInvoiceNumber()
2576 
 
4763 rajveer 2577 
  def send_addInvoiceNumber(self, orderId, invoiceNumber, color):
4579 rajveer 2578 
    self._oprot.writeMessageBegin('addInvoiceNumber', TMessageType.CALL, self._seqid)
2579 
    args = addInvoiceNumber_args()
2580 
    args.orderId = orderId
2581 
    args.invoiceNumber = invoiceNumber
4763 rajveer 2582 
    args.color = color
4579 rajveer 2583 
    args.write(self._oprot)
2584 
    self._oprot.writeMessageEnd()
2585 
    self._oprot.trans.flush()
2586 
 
2587 
  def recv_addInvoiceNumber(self, ):
2588 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2589 
    if mtype == TMessageType.EXCEPTION:
2590 
      x = TApplicationException()
2591 
      x.read(self._iprot)
2592 
      self._iprot.readMessageEnd()
2593 
      raise x
2594 
    result = addInvoiceNumber_result()
2595 
    result.read(self._iprot)
2596 
    self._iprot.readMessageEnd()
2597 
    if result.ex is not None:
2598 
      raise result.ex
2599 
    return
2600 
 
4910 phani.kuma 2601 
  def markOrdersAsShippedFromWarehouse(self, warehouseId, providerId, cod, orderIds):
1408 ankur.sing 2602 
    """
3064 chandransh 2603 
    Depending on the third parameter, marks either all prepaid or all cod orders BILLED by the
4910 phani.kuma 2604 
    given warehouse and were picked up by the given provider as SHIPPED_FROM_WH.
3431 rajveer 2605 
 
1408 ankur.sing 2606 
    Parameters:
3064 chandransh 2607 
     - warehouseId
1408 ankur.sing 2608 
     - providerId
3064 chandransh 2609 
     - cod
4910 phani.kuma 2610 
     - orderIds
1408 ankur.sing 2611 
    """
4910 phani.kuma 2612 
    self.send_markOrdersAsShippedFromWarehouse(warehouseId, providerId, cod, orderIds)
2613 
    return self.recv_markOrdersAsShippedFromWarehouse()
1408 ankur.sing 2614 
 
4910 phani.kuma 2615 
  def send_markOrdersAsShippedFromWarehouse(self, warehouseId, providerId, cod, orderIds):
2616 
    self._oprot.writeMessageBegin('markOrdersAsShippedFromWarehouse', TMessageType.CALL, self._seqid)
2617 
    args = markOrdersAsShippedFromWarehouse_args()
3064 chandransh 2618 
    args.warehouseId = warehouseId
1408 ankur.sing 2619 
    args.providerId = providerId
3064 chandransh 2620 
    args.cod = cod
4910 phani.kuma 2621 
    args.orderIds = orderIds
1408 ankur.sing 2622 
    args.write(self._oprot)
2623 
    self._oprot.writeMessageEnd()
2624 
    self._oprot.trans.flush()
2625 
 
4910 phani.kuma 2626 
  def recv_markOrdersAsShippedFromWarehouse(self, ):
1408 ankur.sing 2627 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2628 
    if mtype == TMessageType.EXCEPTION:
2629 
      x = TApplicationException()
2630 
      x.read(self._iprot)
2631 
      self._iprot.readMessageEnd()
2632 
      raise x
4910 phani.kuma 2633 
    result = markOrdersAsShippedFromWarehouse_result()
1408 ankur.sing 2634 
    result.read(self._iprot)
2635 
    self._iprot.readMessageEnd()
3431 rajveer 2636 
    if result.success is not None:
1408 ankur.sing 2637 
      return result.success
3431 rajveer 2638 
    if result.ex is not None:
3064 chandransh 2639 
      raise result.ex
4910 phani.kuma 2640 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "markOrdersAsShippedFromWarehouse failed: unknown result");
1408 ankur.sing 2641 
 
5713 rajveer 2642 
  def markOrdersAsReturnedFromStore(self, providerId, orderIds, awbs):
5676 rajveer 2643 
    """
2644 
    Parameters:
2645 
     - providerId
2646 
     - orderIds
5713 rajveer 2647 
     - awbs
5676 rajveer 2648 
    """
5713 rajveer 2649 
    self.send_markOrdersAsReturnedFromStore(providerId, orderIds, awbs)
5676 rajveer 2650 
    return self.recv_markOrdersAsReturnedFromStore()
2651 
 
5713 rajveer 2652 
  def send_markOrdersAsReturnedFromStore(self, providerId, orderIds, awbs):
5676 rajveer 2653 
    self._oprot.writeMessageBegin('markOrdersAsReturnedFromStore', TMessageType.CALL, self._seqid)
2654 
    args = markOrdersAsReturnedFromStore_args()
2655 
    args.providerId = providerId
2656 
    args.orderIds = orderIds
5713 rajveer 2657 
    args.awbs = awbs
5676 rajveer 2658 
    args.write(self._oprot)
2659 
    self._oprot.writeMessageEnd()
2660 
    self._oprot.trans.flush()
2661 
 
2662 
  def recv_markOrdersAsReturnedFromStore(self, ):
2663 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2664 
    if mtype == TMessageType.EXCEPTION:
2665 
      x = TApplicationException()
2666 
      x.read(self._iprot)
2667 
      self._iprot.readMessageEnd()
2668 
      raise x
2669 
    result = markOrdersAsReturnedFromStore_result()
2670 
    result.read(self._iprot)
2671 
    self._iprot.readMessageEnd()
2672 
    if result.success is not None:
2673 
      return result.success
2674 
    if result.ex is not None:
2675 
      raise result.ex
2676 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "markOrdersAsReturnedFromStore failed: unknown result");
2677 
 
4910 phani.kuma 2678 
  def markOrdersAsPickedUp(self, providerId, pickupDetails):
4410 rajveer 2679 
    """
4910 phani.kuma 2680 
    Marks all SHIPPED_FROM_WH orders of the previous day for a provider as SHIPPED_TO_LOGISTICS.
2681 
    Raises an exception if we encounter report for an AWB number that we did not ship.
4410 rajveer 2682 
 
2683 
    Parameters:
2684 
     - providerId
4910 phani.kuma 2685 
     - pickupDetails
4410 rajveer 2686 
    """
4910 phani.kuma 2687 
    self.send_markOrdersAsPickedUp(providerId, pickupDetails)
2688 
    self.recv_markOrdersAsPickedUp()
4410 rajveer 2689 
 
4910 phani.kuma 2690 
  def send_markOrdersAsPickedUp(self, providerId, pickupDetails):
2691 
    self._oprot.writeMessageBegin('markOrdersAsPickedUp', TMessageType.CALL, self._seqid)
2692 
    args = markOrdersAsPickedUp_args()
4410 rajveer 2693 
    args.providerId = providerId
4910 phani.kuma 2694 
    args.pickupDetails = pickupDetails
4410 rajveer 2695 
    args.write(self._oprot)
2696 
    self._oprot.writeMessageEnd()
2697 
    self._oprot.trans.flush()
2698 
 
4910 phani.kuma 2699 
  def recv_markOrdersAsPickedUp(self, ):
4410 rajveer 2700 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2701 
    if mtype == TMessageType.EXCEPTION:
2702 
      x = TApplicationException()
2703 
      x.read(self._iprot)
2704 
      self._iprot.readMessageEnd()
2705 
      raise x
4910 phani.kuma 2706 
    result = markOrdersAsPickedUp_result()
4410 rajveer 2707 
    result.read(self._iprot)
2708 
    self._iprot.readMessageEnd()
2709 
    if result.ex is not None:
2710 
      raise result.ex
4910 phani.kuma 2711 
    return
4410 rajveer 2712 
 
4910 phani.kuma 2713 
  def getOrdersNotPickedUp(self, providerId):
94 ashish 2714 
    """
3064 chandransh 2715 
    Returns a list of orders that were shipped from warehouse but did not appear in the pick-up report.
3431 rajveer 2716 
 
94 ashish 2717 
    Parameters:
3064 chandransh 2718 
     - providerId
304 ashish 2719 
    """
4910 phani.kuma 2720 
    self.send_getOrdersNotPickedUp(providerId)
2721 
    return self.recv_getOrdersNotPickedUp()
94 ashish 2722 
 
4910 phani.kuma 2723 
  def send_getOrdersNotPickedUp(self, providerId):
2724 
    self._oprot.writeMessageBegin('getOrdersNotPickedUp', TMessageType.CALL, self._seqid)
2725 
    args = getOrdersNotPickedUp_args()
3064 chandransh 2726 
    args.providerId = providerId
304 ashish 2727 
    args.write(self._oprot)
2728 
    self._oprot.writeMessageEnd()
2729 
    self._oprot.trans.flush()
2730 
 
4910 phani.kuma 2731 
  def recv_getOrdersNotPickedUp(self, ):
304 ashish 2732 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2733 
    if mtype == TMessageType.EXCEPTION:
2734 
      x = TApplicationException()
2735 
      x.read(self._iprot)
2736 
      self._iprot.readMessageEnd()
2737 
      raise x
4910 phani.kuma 2738 
    result = getOrdersNotPickedUp_result()
304 ashish 2739 
    result.read(self._iprot)
2740 
    self._iprot.readMessageEnd()
3431 rajveer 2741 
    if result.success is not None:
304 ashish 2742 
      return result.success
4910 phani.kuma 2743 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getOrdersNotPickedUp failed: unknown result");
304 ashish 2744 
 
3064 chandransh 2745 
  def markOrdersAsDelivered(self, providerId, deliveredOrders):
304 ashish 2746 
    """
3064 chandransh 2747 
    Marks all orders with AWBs in the given map as delivered. Also sets the delivery timestamp and
2748 
    the name of the receiver.
2749 
    Raises an exception if we encounter report for an AWB number that we did not ship.
3431 rajveer 2750 
 
304 ashish 2751 
    Parameters:
3064 chandransh 2752 
     - providerId
2753 
     - deliveredOrders
304 ashish 2754 
    """
3064 chandransh 2755 
    self.send_markOrdersAsDelivered(providerId, deliveredOrders)
2756 
    self.recv_markOrdersAsDelivered()
304 ashish 2757 
 
3064 chandransh 2758 
  def send_markOrdersAsDelivered(self, providerId, deliveredOrders):
2759 
    self._oprot.writeMessageBegin('markOrdersAsDelivered', TMessageType.CALL, self._seqid)
2760 
    args = markOrdersAsDelivered_args()
2761 
    args.providerId = providerId
2762 
    args.deliveredOrders = deliveredOrders
304 ashish 2763 
    args.write(self._oprot)
2764 
    self._oprot.writeMessageEnd()
2765 
    self._oprot.trans.flush()
2766 
 
3064 chandransh 2767 
  def recv_markOrdersAsDelivered(self, ):
304 ashish 2768 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2769 
    if mtype == TMessageType.EXCEPTION:
2770 
      x = TApplicationException()
2771 
      x.read(self._iprot)
2772 
      self._iprot.readMessageEnd()
2773 
      raise x
3064 chandransh 2774 
    result = markOrdersAsDelivered_result()
304 ashish 2775 
    result.read(self._iprot)
2776 
    self._iprot.readMessageEnd()
3431 rajveer 2777 
    if result.ex is not None:
3064 chandransh 2778 
      raise result.ex
304 ashish 2779 
    return
2780 
 
4910 phani.kuma 2781 
  def markAsRTOrders(self, providerId, returnedOrders):
1596 ankur.sing 2782 
    """
4910 phani.kuma 2783 
    Mark all orders with AWBs in the given map as RTO. Also sets the delivery timestamp.
3064 chandransh 2784 
    Raises an exception if we encounter report for an AWB number that we did not ship.
3431 rajveer 2785 
 
3064 chandransh 2786 
    Parameters:
2787 
     - providerId
2788 
     - returnedOrders
1596 ankur.sing 2789 
    """
4910 phani.kuma 2790 
    self.send_markAsRTOrders(providerId, returnedOrders)
2791 
    self.recv_markAsRTOrders()
304 ashish 2792 
 
4910 phani.kuma 2793 
  def send_markAsRTOrders(self, providerId, returnedOrders):
2794 
    self._oprot.writeMessageBegin('markAsRTOrders', TMessageType.CALL, self._seqid)
2795 
    args = markAsRTOrders_args()
3064 chandransh 2796 
    args.providerId = providerId
2797 
    args.returnedOrders = returnedOrders
1596 ankur.sing 2798 
    args.write(self._oprot)
2799 
    self._oprot.writeMessageEnd()
2800 
    self._oprot.trans.flush()
2801 
 
4910 phani.kuma 2802 
  def recv_markAsRTOrders(self, ):
1596 ankur.sing 2803 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2804 
    if mtype == TMessageType.EXCEPTION:
2805 
      x = TApplicationException()
2806 
      x.read(self._iprot)
2807 
      self._iprot.readMessageEnd()
2808 
      raise x
4910 phani.kuma 2809 
    result = markAsRTOrders_result()
1596 ankur.sing 2810 
    result.read(self._iprot)
2811 
    self._iprot.readMessageEnd()
3431 rajveer 2812 
    if result.ex is not None:
3064 chandransh 2813 
      raise result.ex
2814 
    return
1596 ankur.sing 2815 
 
4910 phani.kuma 2816 
  def getRTOrders(self, providerId):
2817 
    """
2818 
    Returns a list of orders that were returned by courier.
2819 
 
2820 
    Parameters:
2821 
     - providerId
2822 
    """
2823 
    self.send_getRTOrders(providerId)
2824 
    return self.recv_getRTOrders()
2825 
 
2826 
  def send_getRTOrders(self, providerId):
2827 
    self._oprot.writeMessageBegin('getRTOrders', TMessageType.CALL, self._seqid)
2828 
    args = getRTOrders_args()
2829 
    args.providerId = providerId
2830 
    args.write(self._oprot)
2831 
    self._oprot.writeMessageEnd()
2832 
    self._oprot.trans.flush()
2833 
 
2834 
  def recv_getRTOrders(self, ):
2835 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2836 
    if mtype == TMessageType.EXCEPTION:
2837 
      x = TApplicationException()
2838 
      x.read(self._iprot)
2839 
      self._iprot.readMessageEnd()
2840 
      raise x
2841 
    result = getRTOrders_result()
2842 
    result.read(self._iprot)
2843 
    self._iprot.readMessageEnd()
2844 
    if result.success is not None:
2845 
      return result.success
2846 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getRTOrders failed: unknown result");
2847 
 
3064 chandransh 2848 
  def updateNonDeliveryReason(self, providerId, undeliveredOrders):
1627 ankur.sing 2849 
    """
3064 chandransh 2850 
    Update the status description of orders whose AWB numbers are keys of the Map.
3431 rajveer 2851 
 
3064 chandransh 2852 
    Parameters:
2853 
     - providerId
2854 
     - undeliveredOrders
1627 ankur.sing 2855 
    """
3064 chandransh 2856 
    self.send_updateNonDeliveryReason(providerId, undeliveredOrders)
4910 phani.kuma 2857 
    self.recv_updateNonDeliveryReason()
1596 ankur.sing 2858 
 
3064 chandransh 2859 
  def send_updateNonDeliveryReason(self, providerId, undeliveredOrders):
2860 
    self._oprot.writeMessageBegin('updateNonDeliveryReason', TMessageType.CALL, self._seqid)
2861 
    args = updateNonDeliveryReason_args()
2862 
    args.providerId = providerId
2863 
    args.undeliveredOrders = undeliveredOrders
1627 ankur.sing 2864 
    args.write(self._oprot)
2865 
    self._oprot.writeMessageEnd()
2866 
    self._oprot.trans.flush()
2867 
 
3064 chandransh 2868 
  def recv_updateNonDeliveryReason(self, ):
1627 ankur.sing 2869 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2870 
    if mtype == TMessageType.EXCEPTION:
2871 
      x = TApplicationException()
2872 
      x.read(self._iprot)
2873 
      self._iprot.readMessageEnd()
2874 
      raise x
3064 chandransh 2875 
    result = updateNonDeliveryReason_result()
1627 ankur.sing 2876 
    result.read(self._iprot)
2877 
    self._iprot.readMessageEnd()
4910 phani.kuma 2878 
    if result.ex is not None:
2879 
      raise result.ex
2880 
    return
2881 
 
2882 
  def getNonDeliveredOrdersbyCourier(self, providerId):
2883 
    """
2884 
    Returns a list of orders that were picked up or shipped four days ago but did not get delivered.
2885 
 
2886 
    Parameters:
2887 
     - providerId
2888 
    """
2889 
    self.send_getNonDeliveredOrdersbyCourier(providerId)
2890 
    return self.recv_getNonDeliveredOrdersbyCourier()
2891 
 
2892 
  def send_getNonDeliveredOrdersbyCourier(self, providerId):
2893 
    self._oprot.writeMessageBegin('getNonDeliveredOrdersbyCourier', TMessageType.CALL, self._seqid)
2894 
    args = getNonDeliveredOrdersbyCourier_args()
2895 
    args.providerId = providerId
2896 
    args.write(self._oprot)
2897 
    self._oprot.writeMessageEnd()
2898 
    self._oprot.trans.flush()
2899 
 
2900 
  def recv_getNonDeliveredOrdersbyCourier(self, ):
2901 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2902 
    if mtype == TMessageType.EXCEPTION:
2903 
      x = TApplicationException()
2904 
      x.read(self._iprot)
2905 
      self._iprot.readMessageEnd()
2906 
      raise x
2907 
    result = getNonDeliveredOrdersbyCourier_result()
2908 
    result.read(self._iprot)
2909 
    self._iprot.readMessageEnd()
4581 phani.kuma 2910 
    if result.success is not None:
2911 
      return result.success
4910 phani.kuma 2912 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getNonDeliveredOrdersbyCourier failed: unknown result");
2913 
 
2914 
  def markOrdersAsLocalConnected(self, providerId, local_connected_orders):
2915 
    """
2916 
    Mark all orders with AWBs in the given map as local connected. Also sets the local connected timestamp.
2917 
 
2918 
    Parameters:
2919 
     - providerId
2920 
     - local_connected_orders
2921 
    """
2922 
    self.send_markOrdersAsLocalConnected(providerId, local_connected_orders)
2923 
    self.recv_markOrdersAsLocalConnected()
2924 
 
2925 
  def send_markOrdersAsLocalConnected(self, providerId, local_connected_orders):
2926 
    self._oprot.writeMessageBegin('markOrdersAsLocalConnected', TMessageType.CALL, self._seqid)
2927 
    args = markOrdersAsLocalConnected_args()
2928 
    args.providerId = providerId
2929 
    args.local_connected_orders = local_connected_orders
2930 
    args.write(self._oprot)
2931 
    self._oprot.writeMessageEnd()
2932 
    self._oprot.trans.flush()
2933 
 
2934 
  def recv_markOrdersAsLocalConnected(self, ):
2935 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2936 
    if mtype == TMessageType.EXCEPTION:
2937 
      x = TApplicationException()
2938 
      x.read(self._iprot)
2939 
      self._iprot.readMessageEnd()
2940 
      raise x
2941 
    result = markOrdersAsLocalConnected_result()
2942 
    result.read(self._iprot)
2943 
    self._iprot.readMessageEnd()
3431 rajveer 2944 
    if result.ex is not None:
3064 chandransh 2945 
      raise result.ex
4910 phani.kuma 2946 
    return
1627 ankur.sing 2947 
 
4910 phani.kuma 2948 
  def getOrdersNotLocalConnected(self, providerId):
2949 
    """
2950 
    Returns a list of orders that were picked up or shipped but pending local connection.
2951 
 
2952 
    Parameters:
2953 
     - providerId
2954 
    """
2955 
    self.send_getOrdersNotLocalConnected(providerId)
2956 
    return self.recv_getOrdersNotLocalConnected()
2957 
 
2958 
  def send_getOrdersNotLocalConnected(self, providerId):
2959 
    self._oprot.writeMessageBegin('getOrdersNotLocalConnected', TMessageType.CALL, self._seqid)
2960 
    args = getOrdersNotLocalConnected_args()
2961 
    args.providerId = providerId
2962 
    args.write(self._oprot)
2963 
    self._oprot.writeMessageEnd()
2964 
    self._oprot.trans.flush()
2965 
 
2966 
  def recv_getOrdersNotLocalConnected(self, ):
2967 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2968 
    if mtype == TMessageType.EXCEPTION:
2969 
      x = TApplicationException()
2970 
      x.read(self._iprot)
2971 
      self._iprot.readMessageEnd()
2972 
      raise x
2973 
    result = getOrdersNotLocalConnected_result()
2974 
    result.read(self._iprot)
2975 
    self._iprot.readMessageEnd()
2976 
    if result.success is not None:
2977 
      return result.success
2978 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getOrdersNotLocalConnected failed: unknown result");
2979 
 
2980 
  def markOrdersAsDestinationCityReached(self, providerId, destination_city_reached_orders):
2981 
    """
2982 
    Mark all orders with AWBs in the given map as reached destination city. Also sets the reached destination timestamp.
2983 
 
2984 
    Parameters:
2985 
     - providerId
2986 
     - destination_city_reached_orders
2987 
    """
2988 
    self.send_markOrdersAsDestinationCityReached(providerId, destination_city_reached_orders)
2989 
    self.recv_markOrdersAsDestinationCityReached()
2990 
 
2991 
  def send_markOrdersAsDestinationCityReached(self, providerId, destination_city_reached_orders):
2992 
    self._oprot.writeMessageBegin('markOrdersAsDestinationCityReached', TMessageType.CALL, self._seqid)
2993 
    args = markOrdersAsDestinationCityReached_args()
2994 
    args.providerId = providerId
2995 
    args.destination_city_reached_orders = destination_city_reached_orders
2996 
    args.write(self._oprot)
2997 
    self._oprot.writeMessageEnd()
2998 
    self._oprot.trans.flush()
2999 
 
3000 
  def recv_markOrdersAsDestinationCityReached(self, ):
3001 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3002 
    if mtype == TMessageType.EXCEPTION:
3003 
      x = TApplicationException()
3004 
      x.read(self._iprot)
3005 
      self._iprot.readMessageEnd()
3006 
      raise x
3007 
    result = markOrdersAsDestinationCityReached_result()
3008 
    result.read(self._iprot)
3009 
    self._iprot.readMessageEnd()
3010 
    if result.ex is not None:
3011 
      raise result.ex
3012 
    return
3013 
 
3014 
  def markOrdersAsFirstDeliveryAttempted(self, providerId, first_atdl_orders):
3015 
    """
3016 
    Mark all orders with AWBs in the given map as first delivery attempt made. Also sets the first delivery attempted timestamp.
3017 
 
3018 
    Parameters:
3019 
     - providerId
3020 
     - first_atdl_orders
3021 
    """
3022 
    self.send_markOrdersAsFirstDeliveryAttempted(providerId, first_atdl_orders)
3023 
    self.recv_markOrdersAsFirstDeliveryAttempted()
3024 
 
3025 
  def send_markOrdersAsFirstDeliveryAttempted(self, providerId, first_atdl_orders):
3026 
    self._oprot.writeMessageBegin('markOrdersAsFirstDeliveryAttempted', TMessageType.CALL, self._seqid)
3027 
    args = markOrdersAsFirstDeliveryAttempted_args()
3028 
    args.providerId = providerId
3029 
    args.first_atdl_orders = first_atdl_orders
3030 
    args.write(self._oprot)
3031 
    self._oprot.writeMessageEnd()
3032 
    self._oprot.trans.flush()
3033 
 
3034 
  def recv_markOrdersAsFirstDeliveryAttempted(self, ):
3035 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3036 
    if mtype == TMessageType.EXCEPTION:
3037 
      x = TApplicationException()
3038 
      x.read(self._iprot)
3039 
      self._iprot.readMessageEnd()
3040 
      raise x
3041 
    result = markOrdersAsFirstDeliveryAttempted_result()
3042 
    result.read(self._iprot)
3043 
    self._iprot.readMessageEnd()
3044 
    if result.ex is not None:
3045 
      raise result.ex
3046 
    return
3047 
 
3064 chandransh 3048 
  def getUndeliveredOrders(self, providerId, warehouseId):
1627 ankur.sing 3049 
    """
3064 chandransh 3050 
    Returns the list of orders whose delivery time has passed but have not been
3051 
    delivered yet for the given provider and warehouse. To get a complete list of
3052 
    undelivered orders, pass them as -1.
3053 
    Returns an empty list if no such orders exist.
3431 rajveer 3054 
 
1886 ankur.sing 3055 
    Parameters:
3064 chandransh 3056 
     - providerId
3057 
     - warehouseId
1886 ankur.sing 3058 
    """
3064 chandransh 3059 
    self.send_getUndeliveredOrders(providerId, warehouseId)
3060 
    return self.recv_getUndeliveredOrders()
1627 ankur.sing 3061 
 
3064 chandransh 3062 
  def send_getUndeliveredOrders(self, providerId, warehouseId):
3063 
    self._oprot.writeMessageBegin('getUndeliveredOrders', TMessageType.CALL, self._seqid)
3064 
    args = getUndeliveredOrders_args()
3065 
    args.providerId = providerId
3066 
    args.warehouseId = warehouseId
1886 ankur.sing 3067 
    args.write(self._oprot)
3068 
    self._oprot.writeMessageEnd()
3069 
    self._oprot.trans.flush()
3070 
 
3064 chandransh 3071 
  def recv_getUndeliveredOrders(self, ):
1886 ankur.sing 3072 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3073 
    if mtype == TMessageType.EXCEPTION:
3074 
      x = TApplicationException()
3075 
      x.read(self._iprot)
3076 
      self._iprot.readMessageEnd()
3077 
      raise x
3064 chandransh 3078 
    result = getUndeliveredOrders_result()
1886 ankur.sing 3079 
    result.read(self._iprot)
3080 
    self._iprot.readMessageEnd()
3431 rajveer 3081 
    if result.success is not None:
1886 ankur.sing 3082 
      return result.success
3064 chandransh 3083 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getUndeliveredOrders failed: unknown result");
1886 ankur.sing 3084 
 
4783 phani.kuma 3085 
  def getUndeliveredOrdersExpectedDeliveryDateNotMet(self, ):
3086 
    """
3087 
    Returns the list of orders whose expected delivery date has passed but have not been
3088 
    delivered yet.
3089 
    Returns an empty list if no such orders exist.
3090 
    """
3091 
    self.send_getUndeliveredOrdersExpectedDeliveryDateNotMet()
3092 
    return self.recv_getUndeliveredOrdersExpectedDeliveryDateNotMet()
3093 
 
3094 
  def send_getUndeliveredOrdersExpectedDeliveryDateNotMet(self, ):
3095 
    self._oprot.writeMessageBegin('getUndeliveredOrdersExpectedDeliveryDateNotMet', TMessageType.CALL, self._seqid)
3096 
    args = getUndeliveredOrdersExpectedDeliveryDateNotMet_args()
3097 
    args.write(self._oprot)
3098 
    self._oprot.writeMessageEnd()
3099 
    self._oprot.trans.flush()
3100 
 
3101 
  def recv_getUndeliveredOrdersExpectedDeliveryDateNotMet(self, ):
3102 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3103 
    if mtype == TMessageType.EXCEPTION:
3104 
      x = TApplicationException()
3105 
      x.read(self._iprot)
3106 
      self._iprot.readMessageEnd()
3107 
      raise x
3108 
    result = getUndeliveredOrdersExpectedDeliveryDateNotMet_result()
3109 
    result.read(self._iprot)
3110 
    self._iprot.readMessageEnd()
3111 
    if result.success is not None:
3112 
      return result.success
3113 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getUndeliveredOrdersExpectedDeliveryDateNotMet failed: unknown result");
3114 
 
2536 chandransh 3115 
  def toggleDOAFlag(self, orderId):
3116 
    """
3117 
    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.
3118 
    Returns the final flag status.
3119 
    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 3120 
 
2536 chandransh 3121 
    Parameters:
3122 
     - orderId
3123 
    """
3124 
    self.send_toggleDOAFlag(orderId)
3125 
    return self.recv_toggleDOAFlag()
1886 ankur.sing 3126 
 
2536 chandransh 3127 
  def send_toggleDOAFlag(self, orderId):
3128 
    self._oprot.writeMessageBegin('toggleDOAFlag', TMessageType.CALL, self._seqid)
3129 
    args = toggleDOAFlag_args()
3130 
    args.orderId = orderId
3131 
    args.write(self._oprot)
3132 
    self._oprot.writeMessageEnd()
3133 
    self._oprot.trans.flush()
3134 
 
3135 
  def recv_toggleDOAFlag(self, ):
3136 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3137 
    if mtype == TMessageType.EXCEPTION:
3138 
      x = TApplicationException()
3139 
      x.read(self._iprot)
3140 
      self._iprot.readMessageEnd()
3141 
      raise x
3142 
    result = toggleDOAFlag_result()
3143 
    result.read(self._iprot)
3144 
    self._iprot.readMessageEnd()
3431 rajveer 3145 
    if result.success is not None:
2536 chandransh 3146 
      return result.success
3431 rajveer 3147 
    if result.ex is not None:
2536 chandransh 3148 
      raise result.ex
3149 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "toggleDOAFlag failed: unknown result");
3150 
 
4712 rajveer 3151 
  def markOrderAsDelivered(self, orderId, deliveryTimestamp, receiver):
3152 
    """
3153 
    Parameters:
3154 
     - orderId
3155 
     - deliveryTimestamp
3156 
     - receiver
3157 
    """
3158 
    self.send_markOrderAsDelivered(orderId, deliveryTimestamp, receiver)
3159 
    self.recv_markOrderAsDelivered()
3160 
 
3161 
  def send_markOrderAsDelivered(self, orderId, deliveryTimestamp, receiver):
3162 
    self._oprot.writeMessageBegin('markOrderAsDelivered', TMessageType.CALL, self._seqid)
3163 
    args = markOrderAsDelivered_args()
3164 
    args.orderId = orderId
3165 
    args.deliveryTimestamp = deliveryTimestamp
3166 
    args.receiver = receiver
3167 
    args.write(self._oprot)
3168 
    self._oprot.writeMessageEnd()
3169 
    self._oprot.trans.flush()
3170 
 
3171 
  def recv_markOrderAsDelivered(self, ):
3172 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3173 
    if mtype == TMessageType.EXCEPTION:
3174 
      x = TApplicationException()
3175 
      x.read(self._iprot)
3176 
      self._iprot.readMessageEnd()
3177 
      raise x
3178 
    result = markOrderAsDelivered_result()
3179 
    result.read(self._iprot)
3180 
    self._iprot.readMessageEnd()
3181 
    if result.ex is not None:
3182 
      raise result.ex
3183 
    return
3184 
 
5553 rajveer 3185 
  def markOrderAsReceivedAtStore(self, orderId, deliveryTimestamp):
3186 
    """
3187 
    Parameters:
3188 
     - orderId
3189 
     - deliveryTimestamp
3190 
    """
3191 
    self.send_markOrderAsReceivedAtStore(orderId, deliveryTimestamp)
3192 
    self.recv_markOrderAsReceivedAtStore()
3193 
 
3194 
  def send_markOrderAsReceivedAtStore(self, orderId, deliveryTimestamp):
3195 
    self._oprot.writeMessageBegin('markOrderAsReceivedAtStore', TMessageType.CALL, self._seqid)
3196 
    args = markOrderAsReceivedAtStore_args()
3197 
    args.orderId = orderId
3198 
    args.deliveryTimestamp = deliveryTimestamp
3199 
    args.write(self._oprot)
3200 
    self._oprot.writeMessageEnd()
3201 
    self._oprot.trans.flush()
3202 
 
3203 
  def recv_markOrderAsReceivedAtStore(self, ):
3204 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3205 
    if mtype == TMessageType.EXCEPTION:
3206 
      x = TApplicationException()
3207 
      x.read(self._iprot)
3208 
      self._iprot.readMessageEnd()
3209 
      raise x
3210 
    result = markOrderAsReceivedAtStore_result()
3211 
    result.read(self._iprot)
3212 
    self._iprot.readMessageEnd()
3213 
    if result.ex is not None:
3214 
      raise result.ex
3215 
    return
3216 
 
4454 rajveer 3217 
  def markOrderDoaRequestReceived(self, orderId):
3218 
    """
3219 
    Once user raise the request for a DOA, order status will be changed from DELVIERY_SUCCESS to DOA_REQUEST_RECEIVED
3220 
 
3221 
    Parameters:
3222 
     - orderId
3223 
    """
3224 
    self.send_markOrderDoaRequestReceived(orderId)
3225 
    return self.recv_markOrderDoaRequestReceived()
3226 
 
3227 
  def send_markOrderDoaRequestReceived(self, orderId):
3228 
    self._oprot.writeMessageBegin('markOrderDoaRequestReceived', TMessageType.CALL, self._seqid)
3229 
    args = markOrderDoaRequestReceived_args()
3230 
    args.orderId = orderId
3231 
    args.write(self._oprot)
3232 
    self._oprot.writeMessageEnd()
3233 
    self._oprot.trans.flush()
3234 
 
3235 
  def recv_markOrderDoaRequestReceived(self, ):
3236 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3237 
    if mtype == TMessageType.EXCEPTION:
3238 
      x = TApplicationException()
3239 
      x.read(self._iprot)
3240 
      self._iprot.readMessageEnd()
3241 
      raise x
3242 
    result = markOrderDoaRequestReceived_result()
3243 
    result.read(self._iprot)
3244 
    self._iprot.readMessageEnd()
3245 
    if result.success is not None:
3246 
      return result.success
3247 
    if result.ex is not None:
3248 
      raise result.ex
3249 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "markOrderDoaRequestReceived failed: unknown result");
3250 
 
3251 
  def markOrderDoaRequestAuthorized(self, orderId, isAuthorized):
3252 
    """
3253 
    CRM person can authorize or deny the request reised by customer. If he authorizes order will change from DOA_REQUEST_RECEIVED
3254 
    to DOA_REQUEST_AUTHORIZED. If he denies, status will be changed back to DELVIERY_SUCCESS.
3255 
 
3256 
    Parameters:
3257 
     - orderId
3258 
     - isAuthorized
3259 
    """
3260 
    self.send_markOrderDoaRequestAuthorized(orderId, isAuthorized)
3261 
    return self.recv_markOrderDoaRequestAuthorized()
3262 
 
3263 
  def send_markOrderDoaRequestAuthorized(self, orderId, isAuthorized):
3264 
    self._oprot.writeMessageBegin('markOrderDoaRequestAuthorized', TMessageType.CALL, self._seqid)
3265 
    args = markOrderDoaRequestAuthorized_args()
3266 
    args.orderId = orderId
3267 
    args.isAuthorized = isAuthorized
3268 
    args.write(self._oprot)
3269 
    self._oprot.writeMessageEnd()
3270 
    self._oprot.trans.flush()
3271 
 
3272 
  def recv_markOrderDoaRequestAuthorized(self, ):
3273 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3274 
    if mtype == TMessageType.EXCEPTION:
3275 
      x = TApplicationException()
3276 
      x.read(self._iprot)
3277 
      self._iprot.readMessageEnd()
3278 
      raise x
3279 
    result = markOrderDoaRequestAuthorized_result()
3280 
    result.read(self._iprot)
3281 
    self._iprot.readMessageEnd()
3282 
    if result.success is not None:
3283 
      return result.success
3284 
    if result.ex is not None:
3285 
      raise result.ex
3286 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "markOrderDoaRequestAuthorized failed: unknown result");
3287 
 
4488 rajveer 3288 
  def markOrderReturnRequestReceived(self, orderId):
3289 
    """
3290 
    Once user raise the request for a RET, order status will be changed from DELVIERY_SUCCESS to RET_REQUEST_RECEIVED
3291 
 
3292 
    Parameters:
3293 
     - orderId
3294 
    """
3295 
    self.send_markOrderReturnRequestReceived(orderId)
3296 
    return self.recv_markOrderReturnRequestReceived()
3297 
 
3298 
  def send_markOrderReturnRequestReceived(self, orderId):
3299 
    self._oprot.writeMessageBegin('markOrderReturnRequestReceived', TMessageType.CALL, self._seqid)
3300 
    args = markOrderReturnRequestReceived_args()
3301 
    args.orderId = orderId
3302 
    args.write(self._oprot)
3303 
    self._oprot.writeMessageEnd()
3304 
    self._oprot.trans.flush()
3305 
 
3306 
  def recv_markOrderReturnRequestReceived(self, ):
3307 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3308 
    if mtype == TMessageType.EXCEPTION:
3309 
      x = TApplicationException()
3310 
      x.read(self._iprot)
3311 
      self._iprot.readMessageEnd()
3312 
      raise x
3313 
    result = markOrderReturnRequestReceived_result()
3314 
    result.read(self._iprot)
3315 
    self._iprot.readMessageEnd()
3316 
    if result.success is not None:
3317 
      return result.success
3318 
    if result.ex is not None:
3319 
      raise result.ex
3320 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "markOrderReturnRequestReceived failed: unknown result");
3321 
 
3322 
  def markOrderReturnRequestAuthorized(self, orderId, isAuthorized):
3323 
    """
3324 
    CRM person can authorize or deny the request reised by customer. If he authorizes order will change from RET_REQUEST_RECEIVED
3325 
    to RET_REQUEST_AUTHORIZED. If he denies, status will be changed back to DELVIERY_SUCCESS.
3326 
 
3327 
    Parameters:
3328 
     - orderId
3329 
     - isAuthorized
3330 
    """
3331 
    self.send_markOrderReturnRequestAuthorized(orderId, isAuthorized)
3332 
    return self.recv_markOrderReturnRequestAuthorized()
3333 
 
3334 
  def send_markOrderReturnRequestAuthorized(self, orderId, isAuthorized):
3335 
    self._oprot.writeMessageBegin('markOrderReturnRequestAuthorized', TMessageType.CALL, self._seqid)
3336 
    args = markOrderReturnRequestAuthorized_args()
3337 
    args.orderId = orderId
3338 
    args.isAuthorized = isAuthorized
3339 
    args.write(self._oprot)
3340 
    self._oprot.writeMessageEnd()
3341 
    self._oprot.trans.flush()
3342 
 
3343 
  def recv_markOrderReturnRequestAuthorized(self, ):
3344 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3345 
    if mtype == TMessageType.EXCEPTION:
3346 
      x = TApplicationException()
3347 
      x.read(self._iprot)
3348 
      self._iprot.readMessageEnd()
3349 
      raise x
3350 
    result = markOrderReturnRequestAuthorized_result()
3351 
    result.read(self._iprot)
3352 
    self._iprot.readMessageEnd()
3353 
    if result.success is not None:
3354 
      return result.success
3355 
    if result.ex is not None:
3356 
      raise result.ex
3357 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "markOrderReturnRequestAuthorized failed: unknown result");
3358 
 
4579 rajveer 3359 
  def requestPickupNumber(self, orderId, providerId):
2536 chandransh 3360 
    """
3361 
    Sends out an email to the account manager of the original courier provider used to ship the order.
4452 rajveer 3362 
    If the order status was DELIVERY_SUCCESS, it is changed to be DOA_PICKUP_REQUEST_RAISED.
3363 
    If the order status was DOA_PICKUP_REQUEST_RAISED, it is left unchanged.
2536 chandransh 3364 
    For any other status, it returns false.
3365 
    Throws an exception if the order with the given id couldn't be found.
3431 rajveer 3366 
 
2536 chandransh 3367 
    Parameters:
3368 
     - orderId
4579 rajveer 3369 
     - providerId
2536 chandransh 3370 
    """
4579 rajveer 3371 
    self.send_requestPickupNumber(orderId, providerId)
2536 chandransh 3372 
    return self.recv_requestPickupNumber()
3373 
 
4579 rajveer 3374 
  def send_requestPickupNumber(self, orderId, providerId):
2536 chandransh 3375 
    self._oprot.writeMessageBegin('requestPickupNumber', TMessageType.CALL, self._seqid)
3376 
    args = requestPickupNumber_args()
3377 
    args.orderId = orderId
4579 rajveer 3378 
    args.providerId = providerId
2536 chandransh 3379 
    args.write(self._oprot)
3380 
    self._oprot.writeMessageEnd()
3381 
    self._oprot.trans.flush()
3382 
 
3383 
  def recv_requestPickupNumber(self, ):
3384 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3385 
    if mtype == TMessageType.EXCEPTION:
3386 
      x = TApplicationException()
3387 
      x.read(self._iprot)
3388 
      self._iprot.readMessageEnd()
3389 
      raise x
3390 
    result = requestPickupNumber_result()
3391 
    result.read(self._iprot)
3392 
    self._iprot.readMessageEnd()
3431 rajveer 3393 
    if result.success is not None:
2536 chandransh 3394 
      return result.success
3431 rajveer 3395 
    if result.ex is not None:
2536 chandransh 3396 
      raise result.ex
3397 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "requestPickupNumber failed: unknown result");
3398 
 
4602 rajveer 3399 
  def authorizePickup(self, orderId, pickupNumber, providerId):
2536 chandransh 3400 
    """
4452 rajveer 3401 
    If the order status is DOA_PICKUP_REQUEST_RAISED, it does the following
2536 chandransh 3402 
    	1. Sends out an email to the customer with the dispatch advice that he has to print as an attachment.
3403 
    	2. Changes order status to be DOA_PICKUP_AUTHORIZED.
3404 
    	3. Returns true
2591 chandransh 3405 
    If the order is in any other status, it returns false.
2536 chandransh 3406 
    Throws an exception if the order with the given id couldn't be found.
3431 rajveer 3407 
 
2536 chandransh 3408 
    Parameters:
3409 
     - orderId
3410 
     - pickupNumber
4602 rajveer 3411 
     - providerId
2536 chandransh 3412 
    """
4602 rajveer 3413 
    self.send_authorizePickup(orderId, pickupNumber, providerId)
2536 chandransh 3414 
    return self.recv_authorizePickup()
3415 
 
4602 rajveer 3416 
  def send_authorizePickup(self, orderId, pickupNumber, providerId):
2536 chandransh 3417 
    self._oprot.writeMessageBegin('authorizePickup', TMessageType.CALL, self._seqid)
3418 
    args = authorizePickup_args()
3419 
    args.orderId = orderId
3420 
    args.pickupNumber = pickupNumber
4602 rajveer 3421 
    args.providerId = providerId
2536 chandransh 3422 
    args.write(self._oprot)
3423 
    self._oprot.writeMessageEnd()
3424 
    self._oprot.trans.flush()
3425 
 
3426 
  def recv_authorizePickup(self, ):
3427 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3428 
    if mtype == TMessageType.EXCEPTION:
3429 
      x = TApplicationException()
3430 
      x.read(self._iprot)
3431 
      self._iprot.readMessageEnd()
3432 
      raise x
3433 
    result = authorizePickup_result()
3434 
    result.read(self._iprot)
3435 
    self._iprot.readMessageEnd()
3431 rajveer 3436 
    if result.success is not None:
2536 chandransh 3437 
      return result.success
3431 rajveer 3438 
    if result.ex is not None:
2536 chandransh 3439 
      raise result.ex
3440 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "authorizePickup failed: unknown result");
3441 
 
2764 chandransh 3442 
  def markDoasAsPickedUp(self, providerId, pickupDetails):
3443 
    """
3444 
    Marks all DOA_PICKUP_AUTHORIZED orders of the previous day for a provider as DOA_RETURN_IN_TRANSIT.
3431 rajveer 3445 
 
2764 chandransh 3446 
    Parameters:
3447 
     - providerId
3448 
     - pickupDetails
3449 
    """
3450 
    self.send_markDoasAsPickedUp(providerId, pickupDetails)
4910 phani.kuma 3451 
    self.recv_markDoasAsPickedUp()
2764 chandransh 3452 
 
3453 
  def send_markDoasAsPickedUp(self, providerId, pickupDetails):
3454 
    self._oprot.writeMessageBegin('markDoasAsPickedUp', TMessageType.CALL, self._seqid)
3455 
    args = markDoasAsPickedUp_args()
3456 
    args.providerId = providerId
3457 
    args.pickupDetails = pickupDetails
3458 
    args.write(self._oprot)
3459 
    self._oprot.writeMessageEnd()
3460 
    self._oprot.trans.flush()
3461 
 
3462 
  def recv_markDoasAsPickedUp(self, ):
3463 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3464 
    if mtype == TMessageType.EXCEPTION:
3465 
      x = TApplicationException()
3466 
      x.read(self._iprot)
3467 
      self._iprot.readMessageEnd()
3468 
      raise x
3469 
    result = markDoasAsPickedUp_result()
3470 
    result.read(self._iprot)
3471 
    self._iprot.readMessageEnd()
4910 phani.kuma 3472 
    return
3473 
 
3474 
  def getDoasNotPickedUp(self, providerId):
3475 
    """
3476 
    Returns a list of orders that were authorized for pickup but did not appear in the pick-up report.
3477 
 
3478 
    Parameters:
3479 
     - providerId
3480 
    """
3481 
    self.send_getDoasNotPickedUp(providerId)
3482 
    return self.recv_getDoasNotPickedUp()
3483 
 
3484 
  def send_getDoasNotPickedUp(self, providerId):
3485 
    self._oprot.writeMessageBegin('getDoasNotPickedUp', TMessageType.CALL, self._seqid)
3486 
    args = getDoasNotPickedUp_args()
3487 
    args.providerId = providerId
3488 
    args.write(self._oprot)
3489 
    self._oprot.writeMessageEnd()
3490 
    self._oprot.trans.flush()
3491 
 
3492 
  def recv_getDoasNotPickedUp(self, ):
3493 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3494 
    if mtype == TMessageType.EXCEPTION:
3495 
      x = TApplicationException()
3496 
      x.read(self._iprot)
3497 
      self._iprot.readMessageEnd()
3498 
      raise x
3499 
    result = getDoasNotPickedUp_result()
3500 
    result.read(self._iprot)
3501 
    self._iprot.readMessageEnd()
3431 rajveer 3502 
    if result.success is not None:
2764 chandransh 3503 
      return result.success
4910 phani.kuma 3504 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getDoasNotPickedUp failed: unknown result");
2764 chandransh 3505 
 
4741 phani.kuma 3506 
  def markReturnOrdersAsPickedUp(self, providerId, pickupDetails):
3507 
    """
3508 
    Marks all RET_PICKUP_CONFIRMED orders of the previous day for a provider as RET_RETURN_IN_TRANSIT.
3509 
 
3510 
    Parameters:
3511 
     - providerId
3512 
     - pickupDetails
3513 
    """
3514 
    self.send_markReturnOrdersAsPickedUp(providerId, pickupDetails)
4910 phani.kuma 3515 
    self.recv_markReturnOrdersAsPickedUp()
4741 phani.kuma 3516 
 
3517 
  def send_markReturnOrdersAsPickedUp(self, providerId, pickupDetails):
3518 
    self._oprot.writeMessageBegin('markReturnOrdersAsPickedUp', TMessageType.CALL, self._seqid)
3519 
    args = markReturnOrdersAsPickedUp_args()
3520 
    args.providerId = providerId
3521 
    args.pickupDetails = pickupDetails
3522 
    args.write(self._oprot)
3523 
    self._oprot.writeMessageEnd()
3524 
    self._oprot.trans.flush()
3525 
 
3526 
  def recv_markReturnOrdersAsPickedUp(self, ):
3527 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3528 
    if mtype == TMessageType.EXCEPTION:
3529 
      x = TApplicationException()
3530 
      x.read(self._iprot)
3531 
      self._iprot.readMessageEnd()
3532 
      raise x
3533 
    result = markReturnOrdersAsPickedUp_result()
3534 
    result.read(self._iprot)
3535 
    self._iprot.readMessageEnd()
4910 phani.kuma 3536 
    return
3537 
 
3538 
  def getReturnOrdersNotPickedUp(self, providerId):
3539 
    """
3540 
    Returns a list of orders that were authorized for pickup but did not appear in the pick-up report.
3541 
 
3542 
    Parameters:
3543 
     - providerId
3544 
    """
3545 
    self.send_getReturnOrdersNotPickedUp(providerId)
3546 
    return self.recv_getReturnOrdersNotPickedUp()
3547 
 
3548 
  def send_getReturnOrdersNotPickedUp(self, providerId):
3549 
    self._oprot.writeMessageBegin('getReturnOrdersNotPickedUp', TMessageType.CALL, self._seqid)
3550 
    args = getReturnOrdersNotPickedUp_args()
3551 
    args.providerId = providerId
3552 
    args.write(self._oprot)
3553 
    self._oprot.writeMessageEnd()
3554 
    self._oprot.trans.flush()
3555 
 
3556 
  def recv_getReturnOrdersNotPickedUp(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 = getReturnOrdersNotPickedUp_result()
3564 
    result.read(self._iprot)
3565 
    self._iprot.readMessageEnd()
4741 phani.kuma 3566 
    if result.success is not None:
3567 
      return result.success
4910 phani.kuma 3568 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getReturnOrdersNotPickedUp failed: unknown result");
4741 phani.kuma 3569 
 
4479 rajveer 3570 
  def receiveReturn(self, orderId, receiveCondition):
2591 chandransh 3571 
    """
4452 rajveer 3572 
    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 3573 
    If the order status is RTO_IN_TRANSIT, marks the order status as RTO_RECEIVED_PRESTINE and returns true.
2591 chandransh 3574 
    If the order is in any other state, it returns false.
3575 
    Throws an exception if the order with the given id couldn't be found.
3431 rajveer 3576 
 
2591 chandransh 3577 
    Parameters:
3578 
     - orderId
4479 rajveer 3579 
     - receiveCondition
2591 chandransh 3580 
    """
4479 rajveer 3581 
    self.send_receiveReturn(orderId, receiveCondition)
2616 chandransh 3582 
    return self.recv_receiveReturn()
2536 chandransh 3583 
 
4479 rajveer 3584 
  def send_receiveReturn(self, orderId, receiveCondition):
2616 chandransh 3585 
    self._oprot.writeMessageBegin('receiveReturn', TMessageType.CALL, self._seqid)
3586 
    args = receiveReturn_args()
2591 chandransh 3587 
    args.orderId = orderId
4479 rajveer 3588 
    args.receiveCondition = receiveCondition
2591 chandransh 3589 
    args.write(self._oprot)
3590 
    self._oprot.writeMessageEnd()
3591 
    self._oprot.trans.flush()
3592 
 
2616 chandransh 3593 
  def recv_receiveReturn(self, ):
2591 chandransh 3594 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3595 
    if mtype == TMessageType.EXCEPTION:
3596 
      x = TApplicationException()
3597 
      x.read(self._iprot)
3598 
      self._iprot.readMessageEnd()
3599 
      raise x
2616 chandransh 3600 
    result = receiveReturn_result()
2591 chandransh 3601 
    result.read(self._iprot)
3602 
    self._iprot.readMessageEnd()
3431 rajveer 3603 
    if result.success is not None:
2591 chandransh 3604 
      return result.success
3431 rajveer 3605 
    if result.ex is not None:
2591 chandransh 3606 
      raise result.ex
2616 chandransh 3607 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "receiveReturn failed: unknown result");
2591 chandransh 3608 
 
3609 
  def validateDoa(self, orderId, isValid):
3610 
    """
4452 rajveer 3611 
    Used to validate the DOA certificate for an order in the DOA_RECEIVED_PRESTINE state. If the certificate is valid,
2616 chandransh 3612 
    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 3613 
    If the order is in any other state, it returns false.
3614 
    Throws an exception if the order with the given id couldn't be found.
3431 rajveer 3615 
 
2591 chandransh 3616 
    Parameters:
3617 
     - orderId
3618 
     - isValid
3619 
    """
3620 
    self.send_validateDoa(orderId, isValid)
3621 
    return self.recv_validateDoa()
3622 
 
3623 
  def send_validateDoa(self, orderId, isValid):
3624 
    self._oprot.writeMessageBegin('validateDoa', TMessageType.CALL, self._seqid)
3625 
    args = validateDoa_args()
3626 
    args.orderId = orderId
3627 
    args.isValid = isValid
3628 
    args.write(self._oprot)
3629 
    self._oprot.writeMessageEnd()
3630 
    self._oprot.trans.flush()
3631 
 
3632 
  def recv_validateDoa(self, ):
3633 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3634 
    if mtype == TMessageType.EXCEPTION:
3635 
      x = TApplicationException()
3636 
      x.read(self._iprot)
3637 
      self._iprot.readMessageEnd()
3638 
      raise x
3639 
    result = validateDoa_result()
3640 
    result.read(self._iprot)
3641 
    self._iprot.readMessageEnd()
3431 rajveer 3642 
    if result.success is not None:
2591 chandransh 3643 
      return result.success
3431 rajveer 3644 
    if result.ex is not None:
2591 chandransh 3645 
      raise result.ex
3646 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "validateDoa failed: unknown result");
3647 
 
4495 rajveer 3648 
  def validateReturnProduct(self, orderId, isUsable):
3649 
    """
3650 
    Parameters:
3651 
     - orderId
3652 
     - isUsable
3653 
    """
3654 
    self.send_validateReturnProduct(orderId, isUsable)
3655 
    return self.recv_validateReturnProduct()
3656 
 
3657 
  def send_validateReturnProduct(self, orderId, isUsable):
3658 
    self._oprot.writeMessageBegin('validateReturnProduct', TMessageType.CALL, self._seqid)
3659 
    args = validateReturnProduct_args()
3660 
    args.orderId = orderId
3661 
    args.isUsable = isUsable
3662 
    args.write(self._oprot)
3663 
    self._oprot.writeMessageEnd()
3664 
    self._oprot.trans.flush()
3665 
 
3666 
  def recv_validateReturnProduct(self, ):
3667 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3668 
    if mtype == TMessageType.EXCEPTION:
3669 
      x = TApplicationException()
3670 
      x.read(self._iprot)
3671 
      self._iprot.readMessageEnd()
3672 
      raise x
3673 
    result = validateReturnProduct_result()
3674 
    result.read(self._iprot)
3675 
    self._iprot.readMessageEnd()
3676 
    if result.success is not None:
3677 
      return result.success
3678 
    if result.ex is not None:
3679 
      raise result.ex
3680 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "validateReturnProduct failed: unknown result");
3681 
 
2616 chandransh 3682 
  def reshipOrder(self, orderId):
3683 
    """
4484 rajveer 3684 
    If the order is in RTO_RECEIVED_PRESTINE or DOA_CERT_INVALID state, it does the following:
2616 chandransh 3685 
    	1. Creates a new order for processing in the BILLED state. All billing information is saved.
4484 rajveer 3686 
    	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 3687 
 
3688 
    If the order is in DOA_CERT_VALID state, it does the following:
3689 
    	1. Creates a new order for processing in the SUBMITTED_FOR_PROCESSING state.
3690 
    	2. Creates a return order for the warehouse executive to return the DOA material.
4452 rajveer 3691 
    	3. Marks the current order as the final DOA_VALID_RESHIPPED state.
3431 rajveer 3692 
 
2616 chandransh 3693 
    Returns the id of the newly created order.
3431 rajveer 3694 
 
2616 chandransh 3695 
    Throws an exception if the order with the given id couldn't be found.
3431 rajveer 3696 
 
2616 chandransh 3697 
    Parameters:
3698 
     - orderId
3699 
    """
3700 
    self.send_reshipOrder(orderId)
3701 
    return self.recv_reshipOrder()
2591 chandransh 3702 
 
2616 chandransh 3703 
  def send_reshipOrder(self, orderId):
3704 
    self._oprot.writeMessageBegin('reshipOrder', TMessageType.CALL, self._seqid)
3705 
    args = reshipOrder_args()
3706 
    args.orderId = orderId
3707 
    args.write(self._oprot)
3708 
    self._oprot.writeMessageEnd()
3709 
    self._oprot.trans.flush()
3710 
 
3711 
  def recv_reshipOrder(self, ):
3712 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3713 
    if mtype == TMessageType.EXCEPTION:
3714 
      x = TApplicationException()
3715 
      x.read(self._iprot)
3716 
      self._iprot.readMessageEnd()
3717 
      raise x
3718 
    result = reshipOrder_result()
3719 
    result.read(self._iprot)
3720 
    self._iprot.readMessageEnd()
3431 rajveer 3721 
    if result.success is not None:
2616 chandransh 3722 
      return result.success
3431 rajveer 3723 
    if result.ex is not None:
2616 chandransh 3724 
      raise result.ex
3725 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "reshipOrder failed: unknown result");
3726 
 
3226 chandransh 3727 
  def refundOrder(self, orderId, refundedBy, reason):
2616 chandransh 3728 
    """
4484 rajveer 3729 
    If the order is in RTO_RECEIVED_PRESTINE, DOA_CERT_VALID or DOA_CERT_INVALID state, it does the following:
2616 chandransh 3730 
    	1. Creates a refund request for batch processing.
3731 
    	2. Creates a return order for the warehouse executive to return the shipped material.
4484 rajveer 3732 
    	3. Marks the current order as RTO_REFUNDED, DOA_VALID_REFUNDED or DOA_INVALID_REFUNDED final states.
3431 rajveer 3733 
 
2616 chandransh 3734 
    If the order is in SUBMITTED_FOR_PROCESSING or INVENTORY_LOW state, it does the following:
3735 
    	1. Creates a refund request for batch processing.
3226 chandransh 3736 
    	2. Cancels the reservation of the item in the warehouse.
3737 
    	3. Marks the current order as the REFUNDED final state.
3431 rajveer 3738 
 
3226 chandransh 3739 
    For all COD orders, if the order is in INIT, SUBMITTED_FOR_PROCESSING or INVENTORY_LOW state, it does the following:
3740 
    	1. Cancels the reservation of the item in the warehouse.
3741 
    	2. Marks the current order as CANCELED.
3742 
 
3743 
    In all cases, it updates the reason for cancellation or refund and the person who performed the action.
3744 
 
2616 chandransh 3745 
    Returns True if it is successful, False otherwise.
3431 rajveer 3746 
 
2616 chandransh 3747 
    Throws an exception if the order with the given id couldn't be found.
3431 rajveer 3748 
 
2616 chandransh 3749 
    Parameters:
3750 
     - orderId
3226 chandransh 3751 
     - refundedBy
3752 
     - reason
2616 chandransh 3753 
    """
3226 chandransh 3754 
    self.send_refundOrder(orderId, refundedBy, reason)
2616 chandransh 3755 
    return self.recv_refundOrder()
3756 
 
3226 chandransh 3757 
  def send_refundOrder(self, orderId, refundedBy, reason):
2616 chandransh 3758 
    self._oprot.writeMessageBegin('refundOrder', TMessageType.CALL, self._seqid)
3759 
    args = refundOrder_args()
3760 
    args.orderId = orderId
3226 chandransh 3761 
    args.refundedBy = refundedBy
3762 
    args.reason = reason
2616 chandransh 3763 
    args.write(self._oprot)
3764 
    self._oprot.writeMessageEnd()
3765 
    self._oprot.trans.flush()
3766 
 
3767 
  def recv_refundOrder(self, ):
3768 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3769 
    if mtype == TMessageType.EXCEPTION:
3770 
      x = TApplicationException()
3771 
      x.read(self._iprot)
3772 
      self._iprot.readMessageEnd()
3773 
      raise x
3774 
    result = refundOrder_result()
3775 
    result.read(self._iprot)
3776 
    self._iprot.readMessageEnd()
3431 rajveer 3777 
    if result.success is not None:
2616 chandransh 3778 
      return result.success
3431 rajveer 3779 
    if result.ex is not None:
2616 chandransh 3780 
      raise result.ex
3781 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "refundOrder failed: unknown result");
3782 
 
2690 chandransh 3783 
  def getReturnOrders(self, warehouseId, fromDate, toDate):
3784 
    """
3785 
    Get all return orders created between the from and to dates for the given warehouse.
3786 
    Ignores the warehouse if it is passed as -1.
3431 rajveer 3787 
 
2690 chandransh 3788 
    Parameters:
3789 
     - warehouseId
3790 
     - fromDate
3791 
     - toDate
3792 
    """
3793 
    self.send_getReturnOrders(warehouseId, fromDate, toDate)
3794 
    return self.recv_getReturnOrders()
2616 chandransh 3795 
 
2690 chandransh 3796 
  def send_getReturnOrders(self, warehouseId, fromDate, toDate):
3797 
    self._oprot.writeMessageBegin('getReturnOrders', TMessageType.CALL, self._seqid)
3798 
    args = getReturnOrders_args()
3799 
    args.warehouseId = warehouseId
3800 
    args.fromDate = fromDate
3801 
    args.toDate = toDate
3802 
    args.write(self._oprot)
3803 
    self._oprot.writeMessageEnd()
3804 
    self._oprot.trans.flush()
3805 
 
3806 
  def recv_getReturnOrders(self, ):
3807 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3808 
    if mtype == TMessageType.EXCEPTION:
3809 
      x = TApplicationException()
3810 
      x.read(self._iprot)
3811 
      self._iprot.readMessageEnd()
3812 
      raise x
3813 
    result = getReturnOrders_result()
3814 
    result.read(self._iprot)
3815 
    self._iprot.readMessageEnd()
3431 rajveer 3816 
    if result.success is not None:
2690 chandransh 3817 
      return result.success
3818 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getReturnOrders failed: unknown result");
3819 
 
5481 phani.kuma 3820 
  def getAllReturnOrders(self, onlyNotProcessed, fromDate, toDate):
3821 
    """
3822 
    Get all return orders created between the from and to dates.
3823 
 
3824 
    Parameters:
3825 
     - onlyNotProcessed
3826 
     - fromDate
3827 
     - toDate
3828 
    """
3829 
    self.send_getAllReturnOrders(onlyNotProcessed, fromDate, toDate)
3830 
    return self.recv_getAllReturnOrders()
3831 
 
3832 
  def send_getAllReturnOrders(self, onlyNotProcessed, fromDate, toDate):
3833 
    self._oprot.writeMessageBegin('getAllReturnOrders', TMessageType.CALL, self._seqid)
3834 
    args = getAllReturnOrders_args()
3835 
    args.onlyNotProcessed = onlyNotProcessed
3836 
    args.fromDate = fromDate
3837 
    args.toDate = toDate
3838 
    args.write(self._oprot)
3839 
    self._oprot.writeMessageEnd()
3840 
    self._oprot.trans.flush()
3841 
 
3842 
  def recv_getAllReturnOrders(self, ):
3843 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3844 
    if mtype == TMessageType.EXCEPTION:
3845 
      x = TApplicationException()
3846 
      x.read(self._iprot)
3847 
      self._iprot.readMessageEnd()
3848 
      raise x
3849 
    result = getAllReturnOrders_result()
3850 
    result.read(self._iprot)
3851 
    self._iprot.readMessageEnd()
3852 
    if result.success is not None:
3853 
      return result.success
3854 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAllReturnOrders failed: unknown result");
3855 
 
2700 chandransh 3856 
  def getReturnOrder(self, id):
3857 
    """
3858 
    Returns the ReturnOrder corresponding to the given id.
3859 
    Throws an exception if the return order with the given id couldn't be found.
3431 rajveer 3860 
 
2700 chandransh 3861 
    Parameters:
3862 
     - id
3863 
    """
3864 
    self.send_getReturnOrder(id)
3865 
    return self.recv_getReturnOrder()
3866 
 
3867 
  def send_getReturnOrder(self, id):
3868 
    self._oprot.writeMessageBegin('getReturnOrder', TMessageType.CALL, self._seqid)
3869 
    args = getReturnOrder_args()
3870 
    args.id = id
3871 
    args.write(self._oprot)
3872 
    self._oprot.writeMessageEnd()
3873 
    self._oprot.trans.flush()
3874 
 
3875 
  def recv_getReturnOrder(self, ):
3876 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3877 
    if mtype == TMessageType.EXCEPTION:
3878 
      x = TApplicationException()
3879 
      x.read(self._iprot)
3880 
      self._iprot.readMessageEnd()
3881 
      raise x
3882 
    result = getReturnOrder_result()
3883 
    result.read(self._iprot)
3884 
    self._iprot.readMessageEnd()
3431 rajveer 3885 
    if result.success is not None:
2700 chandransh 3886 
      return result.success
3431 rajveer 3887 
    if result.ex is not None:
2700 chandransh 3888 
      raise result.ex
3889 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getReturnOrder failed: unknown result");
3890 
 
2690 chandransh 3891 
  def processReturn(self, returnOrderId):
3892 
    """
3893 
    Marks the return order with the given id as processed. Raises an exception if no such return order exists.
3431 rajveer 3894 
 
2690 chandransh 3895 
    Parameters:
3896 
     - returnOrderId
3897 
    """
3898 
    self.send_processReturn(returnOrderId)
3899 
    self.recv_processReturn()
3900 
 
3901 
  def send_processReturn(self, returnOrderId):
3902 
    self._oprot.writeMessageBegin('processReturn', TMessageType.CALL, self._seqid)
3903 
    args = processReturn_args()
3904 
    args.returnOrderId = returnOrderId
3905 
    args.write(self._oprot)
3906 
    self._oprot.writeMessageEnd()
3907 
    self._oprot.trans.flush()
3908 
 
3909 
  def recv_processReturn(self, ):
3910 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3911 
    if mtype == TMessageType.EXCEPTION:
3912 
      x = TApplicationException()
3913 
      x.read(self._iprot)
3914 
      self._iprot.readMessageEnd()
3915 
      raise x
3916 
    result = processReturn_result()
3917 
    result.read(self._iprot)
3918 
    self._iprot.readMessageEnd()
3431 rajveer 3919 
    if result.ex is not None:
2690 chandransh 3920 
      raise result.ex
3921 
    return
3922 
 
3451 chandransh 3923 
  def updateWeight(self, orderId, weight):
3924 
    """
3925 
    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 3926 
 
3451 chandransh 3927 
    Parameters:
3928 
     - orderId
3929 
     - weight
3930 
    """
3931 
    self.send_updateWeight(orderId, weight)
3932 
    return self.recv_updateWeight()
3933 
 
3934 
  def send_updateWeight(self, orderId, weight):
3935 
    self._oprot.writeMessageBegin('updateWeight', TMessageType.CALL, self._seqid)
3936 
    args = updateWeight_args()
3937 
    args.orderId = orderId
3938 
    args.weight = weight
3939 
    args.write(self._oprot)
3940 
    self._oprot.writeMessageEnd()
3941 
    self._oprot.trans.flush()
3942 
 
3943 
  def recv_updateWeight(self, ):
3944 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3945 
    if mtype == TMessageType.EXCEPTION:
3946 
      x = TApplicationException()
3947 
      x.read(self._iprot)
3948 
      self._iprot.readMessageEnd()
3949 
      raise x
3950 
    result = updateWeight_result()
3951 
    result.read(self._iprot)
3952 
    self._iprot.readMessageEnd()
3953 
    if result.success is not None:
3954 
      return result.success
3955 
    if result.ex is not None:
3956 
      raise result.ex
3957 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "updateWeight failed: unknown result");
3958 
 
3469 chandransh 3959 
  def changeItem(self, orderId, itemId):
3960 
    """
3961 
    Change the item to be shipped for this order. Also adjusts the reservation in the inventory accordingly.
3962 
    Currently, it also ensures that only a different color of the given item is shipped.
3451 chandransh 3963 
 
3469 chandransh 3964 
    Parameters:
3965 
     - orderId
3966 
     - itemId
3967 
    """
3968 
    self.send_changeItem(orderId, itemId)
3969 
    return self.recv_changeItem()
3970 
 
3971 
  def send_changeItem(self, orderId, itemId):
3972 
    self._oprot.writeMessageBegin('changeItem', TMessageType.CALL, self._seqid)
3973 
    args = changeItem_args()
3974 
    args.orderId = orderId
3975 
    args.itemId = itemId
3976 
    args.write(self._oprot)
3977 
    self._oprot.writeMessageEnd()
3978 
    self._oprot.trans.flush()
3979 
 
3980 
  def recv_changeItem(self, ):
3981 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3982 
    if mtype == TMessageType.EXCEPTION:
3983 
      x = TApplicationException()
3984 
      x.read(self._iprot)
3985 
      self._iprot.readMessageEnd()
3986 
      raise x
3987 
    result = changeItem_result()
3988 
    result.read(self._iprot)
3989 
    self._iprot.readMessageEnd()
3990 
    if result.success is not None:
3991 
      return result.success
3992 
    if result.ex is not None:
3993 
      raise result.ex
3994 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "changeItem failed: unknown result");
3995 
 
3996 
  def shiftToWarehouse(self, orderId, warehouseId):
3997 
    """
3998 
    Moves the given order to the given warehouse. Also adjusts the inventory reservations accordingly.
3999 
 
4000 
    Parameters:
4001 
     - orderId
4002 
     - warehouseId
4003 
    """
4004 
    self.send_shiftToWarehouse(orderId, warehouseId)
4005 
    return self.recv_shiftToWarehouse()
4006 
 
4007 
  def send_shiftToWarehouse(self, orderId, warehouseId):
4008 
    self._oprot.writeMessageBegin('shiftToWarehouse', TMessageType.CALL, self._seqid)
4009 
    args = shiftToWarehouse_args()
4010 
    args.orderId = orderId
4011 
    args.warehouseId = warehouseId
4012 
    args.write(self._oprot)
4013 
    self._oprot.writeMessageEnd()
4014 
    self._oprot.trans.flush()
4015 
 
4016 
  def recv_shiftToWarehouse(self, ):
4017 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4018 
    if mtype == TMessageType.EXCEPTION:
4019 
      x = TApplicationException()
4020 
      x.read(self._iprot)
4021 
      self._iprot.readMessageEnd()
4022 
      raise x
4023 
    result = shiftToWarehouse_result()
4024 
    result.read(self._iprot)
4025 
    self._iprot.readMessageEnd()
4026 
    if result.success is not None:
4027 
      return result.success
4028 
    if result.ex is not None:
4029 
      raise result.ex
4030 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "shiftToWarehouse failed: unknown result");
4031 
 
4647 rajveer 4032 
  def addDelayReason(self, orderId, delayReason, furtherDelay, delayReasonText):
3553 chandransh 4033 
    """
4034 
    Adds the given delay reason to the given order.
3986 chandransh 4035 
    Increases the expected delivery time of the given order by the given no. of days.
3553 chandransh 4036 
    Raises an exception if no order with the given id can be found.
3469 chandransh 4037 
 
3553 chandransh 4038 
    Parameters:
4039 
     - orderId
4040 
     - delayReason
3986 chandransh 4041 
     - furtherDelay
4647 rajveer 4042 
     - delayReasonText
3553 chandransh 4043 
    """
4647 rajveer 4044 
    self.send_addDelayReason(orderId, delayReason, furtherDelay, delayReasonText)
3553 chandransh 4045 
    return self.recv_addDelayReason()
4046 
 
4647 rajveer 4047 
  def send_addDelayReason(self, orderId, delayReason, furtherDelay, delayReasonText):
3553 chandransh 4048 
    self._oprot.writeMessageBegin('addDelayReason', TMessageType.CALL, self._seqid)
4049 
    args = addDelayReason_args()
4050 
    args.orderId = orderId
4051 
    args.delayReason = delayReason
3986 chandransh 4052 
    args.furtherDelay = furtherDelay
4647 rajveer 4053 
    args.delayReasonText = delayReasonText
3553 chandransh 4054 
    args.write(self._oprot)
4055 
    self._oprot.writeMessageEnd()
4056 
    self._oprot.trans.flush()
4057 
 
4058 
  def recv_addDelayReason(self, ):
4059 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4060 
    if mtype == TMessageType.EXCEPTION:
4061 
      x = TApplicationException()
4062 
      x.read(self._iprot)
4063 
      self._iprot.readMessageEnd()
4064 
      raise x
4065 
    result = addDelayReason_result()
4066 
    result.read(self._iprot)
4067 
    self._iprot.readMessageEnd()
4068 
    if result.success is not None:
4069 
      return result.success
4070 
    if result.ex is not None:
4071 
      raise result.ex
4072 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "addDelayReason failed: unknown result");
4073 
 
3956 chandransh 4074 
  def reconcileCodCollection(self, collectedAmountMap, xferBy, xferTxnId, xferDate):
4075 
    """
4076 
    Marks the COD orders with given AWB nos. as having been processed.
4077 
    Updates the captured amount for the corresponding payment.
3553 chandransh 4078 
 
3956 chandransh 4079 
    Returns a map of AWBs which were not processed and the associated reason. An AWB is not processed if:
4080 
    1. There is no order corresponding to an AWB number.
4081 
    2. The captured amount for a payment exceeds the total payment.
4082 
    3. The order corresponding to an AWB no. is in a state prior to DELIVERY_SUCCESS.
4083 
 
4084 
    Parameters:
4085 
     - collectedAmountMap
4086 
     - xferBy
4087 
     - xferTxnId
4088 
     - xferDate
4089 
    """
4090 
    self.send_reconcileCodCollection(collectedAmountMap, xferBy, xferTxnId, xferDate)
4091 
    return self.recv_reconcileCodCollection()
4092 
 
4093 
  def send_reconcileCodCollection(self, collectedAmountMap, xferBy, xferTxnId, xferDate):
4094 
    self._oprot.writeMessageBegin('reconcileCodCollection', TMessageType.CALL, self._seqid)
4095 
    args = reconcileCodCollection_args()
4096 
    args.collectedAmountMap = collectedAmountMap
4097 
    args.xferBy = xferBy
4098 
    args.xferTxnId = xferTxnId
4099 
    args.xferDate = xferDate
4100 
    args.write(self._oprot)
4101 
    self._oprot.writeMessageEnd()
4102 
    self._oprot.trans.flush()
4103 
 
4104 
  def recv_reconcileCodCollection(self, ):
4105 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4106 
    if mtype == TMessageType.EXCEPTION:
4107 
      x = TApplicationException()
4108 
      x.read(self._iprot)
4109 
      self._iprot.readMessageEnd()
4110 
      raise x
4111 
    result = reconcileCodCollection_result()
4112 
    result.read(self._iprot)
4113 
    self._iprot.readMessageEnd()
4114 
    if result.success is not None:
4115 
      return result.success
4116 
    if result.ex is not None:
4117 
      raise result.ex
4118 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "reconcileCodCollection failed: unknown result");
4119 
 
4008 mandeep.dh 4120 
  def getTransactionsRequiringExtraProcessing(self, category):
4121 
    """
4065 mandeep.dh 4122 
    Returns the list of transaction ids that require some extra processing and
4008 mandeep.dh 4123 
    which belong to a particular category. This is currently used by CRM
4065 mandeep.dh 4124 
    application. If no such transaction ids are present, it returns an empty list.
3956 chandransh 4125 
 
4008 mandeep.dh 4126 
    Parameters:
4127 
     - category
4128 
    """
4129 
    self.send_getTransactionsRequiringExtraProcessing(category)
4130 
    return self.recv_getTransactionsRequiringExtraProcessing()
4131 
 
4132 
  def send_getTransactionsRequiringExtraProcessing(self, category):
4133 
    self._oprot.writeMessageBegin('getTransactionsRequiringExtraProcessing', TMessageType.CALL, self._seqid)
4134 
    args = getTransactionsRequiringExtraProcessing_args()
4135 
    args.category = category
4136 
    args.write(self._oprot)
4137 
    self._oprot.writeMessageEnd()
4138 
    self._oprot.trans.flush()
4139 
 
4140 
  def recv_getTransactionsRequiringExtraProcessing(self, ):
4141 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4142 
    if mtype == TMessageType.EXCEPTION:
4143 
      x = TApplicationException()
4144 
      x.read(self._iprot)
4145 
      self._iprot.readMessageEnd()
4146 
      raise x
4147 
    result = getTransactionsRequiringExtraProcessing_result()
4148 
    result.read(self._iprot)
4149 
    self._iprot.readMessageEnd()
4150 
    if result.success is not None:
4151 
      return result.success
4152 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getTransactionsRequiringExtraProcessing failed: unknown result");
4153 
 
4154 
  def markTransactionAsProcessed(self, transactionId, category):
4155 
    """
4156 
    Marks a particular transaction as processed for a particular cateogory.
4065 mandeep.dh 4157 
    It essentially deletes the transaction id record for a particular
4158 
    processing type category (if present) from DB.
4159 
    This is currently used by CRM application.
4008 mandeep.dh 4160 
 
4161 
    Parameters:
4162 
     - transactionId
4163 
     - category
4164 
    """
4165 
    self.send_markTransactionAsProcessed(transactionId, category)
4166 
    self.recv_markTransactionAsProcessed()
4167 
 
4168 
  def send_markTransactionAsProcessed(self, transactionId, category):
4169 
    self._oprot.writeMessageBegin('markTransactionAsProcessed', TMessageType.CALL, self._seqid)
4170 
    args = markTransactionAsProcessed_args()
4171 
    args.transactionId = transactionId
4172 
    args.category = category
4173 
    args.write(self._oprot)
4174 
    self._oprot.writeMessageEnd()
4175 
    self._oprot.trans.flush()
4176 
 
4177 
  def recv_markTransactionAsProcessed(self, ):
4178 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4179 
    if mtype == TMessageType.EXCEPTION:
4180 
      x = TApplicationException()
4181 
      x.read(self._iprot)
4182 
      self._iprot.readMessageEnd()
4183 
      raise x
4184 
    result = markTransactionAsProcessed_result()
4185 
    result.read(self._iprot)
4186 
    self._iprot.readMessageEnd()
4187 
    return
4188 
 
4018 chandransh 4189 
  def getItemWiseRiskyOrdersCount(self, ):
4190 
    """
4191 
    Returns a map containing the number of risky orders keyed by item id. A risky order
4192 
    is defined as one whose shipping date is about to expire.
4193 
    """
4194 
    self.send_getItemWiseRiskyOrdersCount()
4195 
    return self.recv_getItemWiseRiskyOrdersCount()
4008 mandeep.dh 4196 
 
4018 chandransh 4197 
  def send_getItemWiseRiskyOrdersCount(self, ):
4198 
    self._oprot.writeMessageBegin('getItemWiseRiskyOrdersCount', TMessageType.CALL, self._seqid)
4199 
    args = getItemWiseRiskyOrdersCount_args()
4200 
    args.write(self._oprot)
4201 
    self._oprot.writeMessageEnd()
4202 
    self._oprot.trans.flush()
4203 
 
4204 
  def recv_getItemWiseRiskyOrdersCount(self, ):
4205 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4206 
    if mtype == TMessageType.EXCEPTION:
4207 
      x = TApplicationException()
4208 
      x.read(self._iprot)
4209 
      self._iprot.readMessageEnd()
4210 
      raise x
4211 
    result = getItemWiseRiskyOrdersCount_result()
4212 
    result.read(self._iprot)
4213 
    self._iprot.readMessageEnd()
4214 
    if result.success is not None:
4215 
      return result.success
4216 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getItemWiseRiskyOrdersCount failed: unknown result");
4217 
 
4295 varun.gupt 4218 
  def getOrdersForItemIds(self, itemIds):
4219 
    """
4220 
    Returns a list of all orders which have items with given id
4221 
 
4222 
    Parameters:
4223 
     - itemIds
4224 
    """
4225 
    self.send_getOrdersForItemIds(itemIds)
4226 
    return self.recv_getOrdersForItemIds()
4227 
 
4228 
  def send_getOrdersForItemIds(self, itemIds):
4229 
    self._oprot.writeMessageBegin('getOrdersForItemIds', TMessageType.CALL, self._seqid)
4230 
    args = getOrdersForItemIds_args()
4231 
    args.itemIds = itemIds
4232 
    args.write(self._oprot)
4233 
    self._oprot.writeMessageEnd()
4234 
    self._oprot.trans.flush()
4235 
 
4236 
  def recv_getOrdersForItemIds(self, ):
4237 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4238 
    if mtype == TMessageType.EXCEPTION:
4239 
      x = TApplicationException()
4240 
      x.read(self._iprot)
4241 
      self._iprot.readMessageEnd()
4242 
      raise x
4243 
    result = getOrdersForItemIds_result()
4244 
    result.read(self._iprot)
4245 
    self._iprot.readMessageEnd()
4246 
    if result.success is not None:
4247 
      return result.success
4248 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getOrdersForItemIds failed: unknown result");
4249 
 
4247 rajveer 4250 
  def markOrderCancellationRequestReceived(self, orderId):
4251 
    """
4252 
    Mark order as cancellation request received. If customer sends request of cancellation of
4253 
    a particular order, this method will be called. It will just change status of the order
4254 
    depending on its current status. It also records the previous status, so that we can move
4255 
    back to that status if cancellation request is denied.
4018 chandransh 4256 
 
4247 rajveer 4257 
    Parameters:
4258 
     - orderId
4259 
    """
4260 
    self.send_markOrderCancellationRequestReceived(orderId)
4261 
    self.recv_markOrderCancellationRequestReceived()
4262 
 
4263 
  def send_markOrderCancellationRequestReceived(self, orderId):
4264 
    self._oprot.writeMessageBegin('markOrderCancellationRequestReceived', TMessageType.CALL, self._seqid)
4265 
    args = markOrderCancellationRequestReceived_args()
4266 
    args.orderId = orderId
4267 
    args.write(self._oprot)
4268 
    self._oprot.writeMessageEnd()
4269 
    self._oprot.trans.flush()
4270 
 
4271 
  def recv_markOrderCancellationRequestReceived(self, ):
4272 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4273 
    if mtype == TMessageType.EXCEPTION:
4274 
      x = TApplicationException()
4275 
      x.read(self._iprot)
4276 
      self._iprot.readMessageEnd()
4277 
      raise x
4278 
    result = markOrderCancellationRequestReceived_result()
4279 
    result.read(self._iprot)
4280 
    self._iprot.readMessageEnd()
4281 
    if result.ex is not None:
4282 
      raise result.ex
4283 
    return
4284 
 
4285 
  def markOrderCancellationRequestConfirmed(self, orderId):
4286 
    """
4287 
    If we decide to to cancel order, CRM will call this method to move the status of order to
4288 
    cancellation request confirmed. After this OM will be able to cancel the order.
4289 
 
4290 
    Parameters:
4291 
     - orderId
4292 
    """
4293 
    self.send_markOrderCancellationRequestConfirmed(orderId)
4294 
    self.recv_markOrderCancellationRequestConfirmed()
4295 
 
4296 
  def send_markOrderCancellationRequestConfirmed(self, orderId):
4297 
    self._oprot.writeMessageBegin('markOrderCancellationRequestConfirmed', TMessageType.CALL, self._seqid)
4298 
    args = markOrderCancellationRequestConfirmed_args()
4299 
    args.orderId = orderId
4300 
    args.write(self._oprot)
4301 
    self._oprot.writeMessageEnd()
4302 
    self._oprot.trans.flush()
4303 
 
4304 
  def recv_markOrderCancellationRequestConfirmed(self, ):
4305 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4306 
    if mtype == TMessageType.EXCEPTION:
4307 
      x = TApplicationException()
4308 
      x.read(self._iprot)
4309 
      self._iprot.readMessageEnd()
4310 
      raise x
4311 
    result = markOrderCancellationRequestConfirmed_result()
4312 
    result.read(self._iprot)
4313 
    self._iprot.readMessageEnd()
4314 
    if result.ex is not None:
4315 
      raise result.ex
4316 
    return
4317 
 
4318 
  def markOrderCancellationRequestDenied(self, orderId):
4319 
    """
4320 
    If we decide to not to cancel order, we will move the order ro previous status.
4321 
 
4322 
    Parameters:
4323 
     - orderId
4324 
    """
4325 
    self.send_markOrderCancellationRequestDenied(orderId)
4326 
    self.recv_markOrderCancellationRequestDenied()
4327 
 
4328 
  def send_markOrderCancellationRequestDenied(self, orderId):
4329 
    self._oprot.writeMessageBegin('markOrderCancellationRequestDenied', TMessageType.CALL, self._seqid)
4330 
    args = markOrderCancellationRequestDenied_args()
4331 
    args.orderId = orderId
4332 
    args.write(self._oprot)
4333 
    self._oprot.writeMessageEnd()
4334 
    self._oprot.trans.flush()
4335 
 
4336 
  def recv_markOrderCancellationRequestDenied(self, ):
4337 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4338 
    if mtype == TMessageType.EXCEPTION:
4339 
      x = TApplicationException()
4340 
      x.read(self._iprot)
4341 
      self._iprot.readMessageEnd()
4342 
      raise x
4343 
    result = markOrderCancellationRequestDenied_result()
4344 
    result.read(self._iprot)
4345 
    self._iprot.readMessageEnd()
4346 
    if result.ex is not None:
4347 
      raise result.ex
4348 
    return
4349 
 
4258 rajveer 4350 
  def markTransactionAsPaymentFlagRemoved(self, transactionId):
4247 rajveer 4351 
    """
4258 rajveer 4352 
    If we and/or payment gateway has decided to accept the payment, this method needs to be called.
4353 
    Changed transaction and all orders status to payment accepted.
4247 rajveer 4354 
 
4355 
    Parameters:
4258 rajveer 4356 
     - transactionId
4247 rajveer 4357 
    """
4258 rajveer 4358 
    self.send_markTransactionAsPaymentFlagRemoved(transactionId)
4359 
    self.recv_markTransactionAsPaymentFlagRemoved()
4247 rajveer 4360 
 
4258 rajveer 4361 
  def send_markTransactionAsPaymentFlagRemoved(self, transactionId):
4362 
    self._oprot.writeMessageBegin('markTransactionAsPaymentFlagRemoved', TMessageType.CALL, self._seqid)
4363 
    args = markTransactionAsPaymentFlagRemoved_args()
4364 
    args.transactionId = transactionId
4247 rajveer 4365 
    args.write(self._oprot)
4366 
    self._oprot.writeMessageEnd()
4367 
    self._oprot.trans.flush()
4368 
 
4258 rajveer 4369 
  def recv_markTransactionAsPaymentFlagRemoved(self, ):
4247 rajveer 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
4258 rajveer 4376 
    result = markTransactionAsPaymentFlagRemoved_result()
4247 rajveer 4377 
    result.read(self._iprot)
4378 
    self._iprot.readMessageEnd()
4379 
    if result.ex is not None:
4380 
      raise result.ex
4381 
    return
4382 
 
4259 anupam.sin 4383 
  def refundTransaction(self, transactionId, refundedBy, reason):
4384 
    """
4385 
    This method is called when a flagged payment is deemed unserviceable and the corresponding orders
4386 
    need to be cancelled
4247 rajveer 4387 
 
4259 anupam.sin 4388 
    Parameters:
4389 
     - transactionId
4390 
     - refundedBy
4391 
     - reason
4392 
    """
4393 
    self.send_refundTransaction(transactionId, refundedBy, reason)
4394 
    self.recv_refundTransaction()
4395 
 
4396 
  def send_refundTransaction(self, transactionId, refundedBy, reason):
4397 
    self._oprot.writeMessageBegin('refundTransaction', TMessageType.CALL, self._seqid)
4398 
    args = refundTransaction_args()
4399 
    args.transactionId = transactionId
4400 
    args.refundedBy = refundedBy
4401 
    args.reason = reason
4402 
    args.write(self._oprot)
4403 
    self._oprot.writeMessageEnd()
4404 
    self._oprot.trans.flush()
4405 
 
4406 
  def recv_refundTransaction(self, ):
4407 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4408 
    if mtype == TMessageType.EXCEPTION:
4409 
      x = TApplicationException()
4410 
      x.read(self._iprot)
4411 
      self._iprot.readMessageEnd()
4412 
      raise x
4413 
    result = refundTransaction_result()
4414 
    result.read(self._iprot)
4415 
    self._iprot.readMessageEnd()
4416 
    if result.ex is not None:
4417 
      raise result.ex
4418 
    return
4419 
 
4324 mandeep.dh 4420 
  def updateShipmentAddress(self, orderId, addressId):
4421 
    """
4422 
    Updates shipment address of an order. Delivery and shipping date estimates
4423 
    etc. are also updated here.
4424 
 
4425 
    Throws TransactionServiceException in case address change is not
4426 
    possible due to certain reasons such as new pincode in address is
4427 
    not serviceable etc.
4428 
 
4429 
    Parameters:
4430 
     - orderId
4431 
     - addressId
4432 
    """
4433 
    self.send_updateShipmentAddress(orderId, addressId)
4434 
    self.recv_updateShipmentAddress()
4435 
 
4436 
  def send_updateShipmentAddress(self, orderId, addressId):
4437 
    self._oprot.writeMessageBegin('updateShipmentAddress', TMessageType.CALL, self._seqid)
4438 
    args = updateShipmentAddress_args()
4439 
    args.orderId = orderId
4440 
    args.addressId = addressId
4441 
    args.write(self._oprot)
4442 
    self._oprot.writeMessageEnd()
4443 
    self._oprot.trans.flush()
4444 
 
4445 
  def recv_updateShipmentAddress(self, ):
4446 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4447 
    if mtype == TMessageType.EXCEPTION:
4448 
      x = TApplicationException()
4449 
      x.read(self._iprot)
4450 
      self._iprot.readMessageEnd()
4451 
      raise x
4452 
    result = updateShipmentAddress_result()
4453 
    result.read(self._iprot)
4454 
    self._iprot.readMessageEnd()
4455 
    if result.ex is not None:
4456 
      raise result.ex
4457 
    return
4458 
 
4285 rajveer 4459 
  def acceptOrdersForItemId(self, itemId, inventory):
4460 
    """
4461 
    Marks the orders as ACCEPTED for the given itemId and inventory. It also updates the accepted timestamp. If the
4462 
    given order is not a COD order, it also captures the payment if the same has not been captured.
4259 anupam.sin 4463 
 
4285 rajveer 4464 
    Parameters:
4465 
     - itemId
4466 
     - inventory
4467 
    """
4468 
    self.send_acceptOrdersForItemId(itemId, inventory)
4469 
    return self.recv_acceptOrdersForItemId()
4470 
 
4471 
  def send_acceptOrdersForItemId(self, itemId, inventory):
4472 
    self._oprot.writeMessageBegin('acceptOrdersForItemId', TMessageType.CALL, self._seqid)
4473 
    args = acceptOrdersForItemId_args()
4474 
    args.itemId = itemId
4475 
    args.inventory = inventory
4476 
    args.write(self._oprot)
4477 
    self._oprot.writeMessageEnd()
4478 
    self._oprot.trans.flush()
4479 
 
4480 
  def recv_acceptOrdersForItemId(self, ):
4481 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4482 
    if mtype == TMessageType.EXCEPTION:
4483 
      x = TApplicationException()
4484 
      x.read(self._iprot)
4485 
      self._iprot.readMessageEnd()
4486 
      raise x
4487 
    result = acceptOrdersForItemId_result()
4488 
    result.read(self._iprot)
4489 
    self._iprot.readMessageEnd()
4490 
    if result.success is not None:
4491 
      return result.success
4492 
    if result.ex is not None:
4493 
      raise result.ex
4494 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "acceptOrdersForItemId failed: unknown result");
4495 
 
4369 rajveer 4496 
  def markOrdersAsPORaised(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_markOrdersAsPORaised(vendorId, itemId, quantity, estimate, isReminder)
4303 rajveer 4506 
    self.recv_markOrdersAsPORaised()
4285 rajveer 4507 
 
4369 rajveer 4508 
  def send_markOrdersAsPORaised(self, vendorId, itemId, quantity, estimate, isReminder):
4303 rajveer 4509 
    self._oprot.writeMessageBegin('markOrdersAsPORaised', TMessageType.CALL, self._seqid)
4510 
    args = markOrdersAsPORaised_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_markOrdersAsPORaised(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 = markOrdersAsPORaised_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 markOrdersAsReversalInitiated(self, vendorId, itemId, quantity, estimate, isReminder):
4303 rajveer 4535 
    """
4536 
    Parameters:
4537 
     - vendorId
4538 
     - itemId
4539 
     - quantity
4540 
     - estimate
4369 rajveer 4541 
     - isReminder
4303 rajveer 4542 
    """
4369 rajveer 4543 
    self.send_markOrdersAsReversalInitiated(vendorId, itemId, quantity, estimate, isReminder)
4303 rajveer 4544 
    self.recv_markOrdersAsReversalInitiated()
4545 
 
4369 rajveer 4546 
  def send_markOrdersAsReversalInitiated(self, vendorId, itemId, quantity, estimate, isReminder):
4303 rajveer 4547 
    self._oprot.writeMessageBegin('markOrdersAsReversalInitiated', TMessageType.CALL, self._seqid)
4548 
    args = markOrdersAsReversalInitiated_args()
4549 
    args.vendorId = vendorId
4550 
    args.itemId = itemId
4551 
    args.quantity = quantity
4552 
    args.estimate = estimate
4369 rajveer 4553 
    args.isReminder = isReminder
4303 rajveer 4554 
    args.write(self._oprot)
4555 
    self._oprot.writeMessageEnd()
4556 
    self._oprot.trans.flush()
4557 
 
4558 
  def recv_markOrdersAsReversalInitiated(self, ):
4559 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4560 
    if mtype == TMessageType.EXCEPTION:
4561 
      x = TApplicationException()
4562 
      x.read(self._iprot)
4563 
      self._iprot.readMessageEnd()
4564 
      raise x
4565 
    result = markOrdersAsReversalInitiated_result()
4566 
    result.read(self._iprot)
4567 
    self._iprot.readMessageEnd()
4568 
    if result.ex is not None:
4569 
      raise result.ex
4570 
    return
4571 
 
4369 rajveer 4572 
  def markOrdersAsNotAvailabke(self, vendorId, itemId, quantity, estimate, isReminder):
4303 rajveer 4573 
    """
4574 
    Parameters:
4575 
     - vendorId
4576 
     - itemId
4577 
     - quantity
4578 
     - estimate
4369 rajveer 4579 
     - isReminder
4303 rajveer 4580 
    """
4369 rajveer 4581 
    self.send_markOrdersAsNotAvailabke(vendorId, itemId, quantity, estimate, isReminder)
4303 rajveer 4582 
    self.recv_markOrdersAsNotAvailabke()
4583 
 
4369 rajveer 4584 
  def send_markOrdersAsNotAvailabke(self, vendorId, itemId, quantity, estimate, isReminder):
4303 rajveer 4585 
    self._oprot.writeMessageBegin('markOrdersAsNotAvailabke', TMessageType.CALL, self._seqid)
4586 
    args = markOrdersAsNotAvailabke_args()
4587 
    args.vendorId = vendorId
4588 
    args.itemId = itemId
4589 
    args.quantity = quantity
4590 
    args.estimate = estimate
4369 rajveer 4591 
    args.isReminder = isReminder
4303 rajveer 4592 
    args.write(self._oprot)
4593 
    self._oprot.writeMessageEnd()
4594 
    self._oprot.trans.flush()
4595 
 
4596 
  def recv_markOrdersAsNotAvailabke(self, ):
4597 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4598 
    if mtype == TMessageType.EXCEPTION:
4599 
      x = TApplicationException()
4600 
      x.read(self._iprot)
4601 
      self._iprot.readMessageEnd()
4602 
      raise x
4603 
    result = markOrdersAsNotAvailabke_result()
4604 
    result.read(self._iprot)
4605 
    self._iprot.readMessageEnd()
4606 
    if result.ex is not None:
4607 
      raise result.ex
4608 
    return
4609 
 
4369 rajveer 4610 
  def markOrdersAsTimeout(self, vendorId):
4611 
    """
4612 
    Parameters:
4613 
     - vendorId
4614 
    """
4615 
    self.send_markOrdersAsTimeout(vendorId)
4616 
    return self.recv_markOrdersAsTimeout()
4303 rajveer 4617 
 
4369 rajveer 4618 
  def send_markOrdersAsTimeout(self, vendorId):
4619 
    self._oprot.writeMessageBegin('markOrdersAsTimeout', TMessageType.CALL, self._seqid)
4620 
    args = markOrdersAsTimeout_args()
4621 
    args.vendorId = vendorId
4622 
    args.write(self._oprot)
4623 
    self._oprot.writeMessageEnd()
4624 
    self._oprot.trans.flush()
4625 
 
4626 
  def recv_markOrdersAsTimeout(self, ):
4627 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4628 
    if mtype == TMessageType.EXCEPTION:
4629 
      x = TApplicationException()
4630 
      x.read(self._iprot)
4631 
      self._iprot.readMessageEnd()
4632 
      raise x
4633 
    result = markOrdersAsTimeout_result()
4634 
    result.read(self._iprot)
4635 
    self._iprot.readMessageEnd()
4636 
    if result.success is not None:
4637 
      return result.success
4638 
    if result.ex is not None:
4639 
      raise result.ex
4640 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "markOrdersAsTimeout failed: unknown result");
4641 
 
4662 rajveer 4642 
  def markOrderAsLostInTransit(self, orderId):
4643 
    """
4644 
    Mark order as LOST_IN_TRANSIT
4645 
 
4646 
    Parameters:
4647 
     - orderId
4648 
    """
4649 
    self.send_markOrderAsLostInTransit(orderId)
4650 
    return self.recv_markOrderAsLostInTransit()
4651 
 
4652 
  def send_markOrderAsLostInTransit(self, orderId):
4653 
    self._oprot.writeMessageBegin('markOrderAsLostInTransit', TMessageType.CALL, self._seqid)
4654 
    args = markOrderAsLostInTransit_args()
4655 
    args.orderId = orderId
4656 
    args.write(self._oprot)
4657 
    self._oprot.writeMessageEnd()
4658 
    self._oprot.trans.flush()
4659 
 
4660 
  def recv_markOrderAsLostInTransit(self, ):
4661 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4662 
    if mtype == TMessageType.EXCEPTION:
4663 
      x = TApplicationException()
4664 
      x.read(self._iprot)
4665 
      self._iprot.readMessageEnd()
4666 
      raise x
4667 
    result = markOrderAsLostInTransit_result()
4668 
    result.read(self._iprot)
4669 
    self._iprot.readMessageEnd()
4670 
    if result.success is not None:
4671 
      return result.success
4672 
    if result.ex is not None:
4673 
      raise result.ex
4674 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "markOrderAsLostInTransit failed: unknown result");
4675 
 
4386 anupam.sin 4676 
  def getOrderForAwb(self, awb):
4677 
    """
4678 
    Returns the order corresponding to an AWB number
4369 rajveer 4679 
 
4386 anupam.sin 4680 
    Parameters:
4681 
     - awb
4682 
    """
4683 
    self.send_getOrderForAwb(awb)
4684 
    return self.recv_getOrderForAwb()
4685 
 
4686 
  def send_getOrderForAwb(self, awb):
4687 
    self._oprot.writeMessageBegin('getOrderForAwb', TMessageType.CALL, self._seqid)
4688 
    args = getOrderForAwb_args()
4689 
    args.awb = awb
4690 
    args.write(self._oprot)
4691 
    self._oprot.writeMessageEnd()
4692 
    self._oprot.trans.flush()
4693 
 
4694 
  def recv_getOrderForAwb(self, ):
4695 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4696 
    if mtype == TMessageType.EXCEPTION:
4697 
      x = TApplicationException()
4698 
      x.read(self._iprot)
4699 
      self._iprot.readMessageEnd()
4700 
      raise x
4701 
    result = getOrderForAwb_result()
4702 
    result.read(self._iprot)
4703 
    self._iprot.readMessageEnd()
4704 
    if result.success is not None:
4705 
      return result.success
4706 
    if result.ex is not None:
4707 
      raise result.ex
4708 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getOrderForAwb failed: unknown result");
4709 
 
4910 phani.kuma 4710 
  def getOrdersForProviderForStatus(self, logistics_provider_id, order_status_list):
4506 phani.kuma 4711 
    """
4910 phani.kuma 4712 
    Returns the order corresponding to a logistics provider id for a given list of order status
4386 anupam.sin 4713 
 
4506 phani.kuma 4714 
    Parameters:
4715 
     - logistics_provider_id
4910 phani.kuma 4716 
     - order_status_list
4506 phani.kuma 4717 
    """
4910 phani.kuma 4718 
    self.send_getOrdersForProviderForStatus(logistics_provider_id, order_status_list)
4506 phani.kuma 4719 
    return self.recv_getOrdersForProviderForStatus()
4720 
 
4910 phani.kuma 4721 
  def send_getOrdersForProviderForStatus(self, logistics_provider_id, order_status_list):
4506 phani.kuma 4722 
    self._oprot.writeMessageBegin('getOrdersForProviderForStatus', TMessageType.CALL, self._seqid)
4723 
    args = getOrdersForProviderForStatus_args()
4724 
    args.logistics_provider_id = logistics_provider_id
4910 phani.kuma 4725 
    args.order_status_list = order_status_list
4506 phani.kuma 4726 
    args.write(self._oprot)
4727 
    self._oprot.writeMessageEnd()
4728 
    self._oprot.trans.flush()
4729 
 
4730 
  def recv_getOrdersForProviderForStatus(self, ):
4731 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4732 
    if mtype == TMessageType.EXCEPTION:
4733 
      x = TApplicationException()
4734 
      x.read(self._iprot)
4735 
      self._iprot.readMessageEnd()
4736 
      raise x
4737 
    result = getOrdersForProviderForStatus_result()
4738 
    result.read(self._iprot)
4739 
    self._iprot.readMessageEnd()
4740 
    if result.success is not None:
4741 
      return result.success
4742 
    if result.ex is not None:
4743 
      raise result.ex
4744 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getOrdersForProviderForStatus failed: unknown result");
4745 
 
4600 varun.gupt 4746 
  def getBilledOrdersForVendor(self, vendorId, billingDateFrom, billingDateTo):
4747 
    """
4748 
    Returns list of orders fullfiled from a certain vendor and billed in a given date range
4506 phani.kuma 4749 
 
4600 varun.gupt 4750 
    Parameters:
4751 
     - vendorId
4752 
     - billingDateFrom
4753 
     - billingDateTo
4754 
    """
4755 
    self.send_getBilledOrdersForVendor(vendorId, billingDateFrom, billingDateTo)
4756 
    return self.recv_getBilledOrdersForVendor()
4757 
 
4758 
  def send_getBilledOrdersForVendor(self, vendorId, billingDateFrom, billingDateTo):
4759 
    self._oprot.writeMessageBegin('getBilledOrdersForVendor', TMessageType.CALL, self._seqid)
4760 
    args = getBilledOrdersForVendor_args()
4761 
    args.vendorId = vendorId
4762 
    args.billingDateFrom = billingDateFrom
4763 
    args.billingDateTo = billingDateTo
4764 
    args.write(self._oprot)
4765 
    self._oprot.writeMessageEnd()
4766 
    self._oprot.trans.flush()
4767 
 
4768 
  def recv_getBilledOrdersForVendor(self, ):
4769 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4770 
    if mtype == TMessageType.EXCEPTION:
4771 
      x = TApplicationException()
4772 
      x.read(self._iprot)
4773 
      self._iprot.readMessageEnd()
4774 
      raise x
4775 
    result = getBilledOrdersForVendor_result()
4776 
    result.read(self._iprot)
4777 
    self._iprot.readMessageEnd()
4778 
    if result.success is not None:
4779 
      return result.success
4780 
    if result.ex is not None:
4781 
      raise result.ex
4782 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getBilledOrdersForVendor failed: unknown result");
4783 
 
4607 rajveer 4784 
  def getSlippedSippingDateOrders(self, ):
4785 
    self.send_getSlippedSippingDateOrders()
4786 
    return self.recv_getSlippedSippingDateOrders()
4787 
 
4788 
  def send_getSlippedSippingDateOrders(self, ):
4789 
    self._oprot.writeMessageBegin('getSlippedSippingDateOrders', TMessageType.CALL, self._seqid)
4790 
    args = getSlippedSippingDateOrders_args()
4791 
    args.write(self._oprot)
4792 
    self._oprot.writeMessageEnd()
4793 
    self._oprot.trans.flush()
4794 
 
4795 
  def recv_getSlippedSippingDateOrders(self, ):
4796 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4797 
    if mtype == TMessageType.EXCEPTION:
4798 
      x = TApplicationException()
4799 
      x.read(self._iprot)
4800 
      self._iprot.readMessageEnd()
4801 
      raise x
4802 
    result = getSlippedSippingDateOrders_result()
4803 
    result.read(self._iprot)
4804 
    self._iprot.readMessageEnd()
4805 
    if result.success is not None:
4806 
      return result.success
4807 
    if result.ex is not None:
4808 
      raise result.ex
4809 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getSlippedSippingDateOrders failed: unknown result");
4810 
 
4709 rajveer 4811 
  def getCancelledOrders(self, cancelDateFrom, cancelDateTo):
4812 
    """
4813 
    Parameters:
4814 
     - cancelDateFrom
4815 
     - cancelDateTo
4816 
    """
4817 
    self.send_getCancelledOrders(cancelDateFrom, cancelDateTo)
4818 
    return self.recv_getCancelledOrders()
4819 
 
4820 
  def send_getCancelledOrders(self, cancelDateFrom, cancelDateTo):
4821 
    self._oprot.writeMessageBegin('getCancelledOrders', TMessageType.CALL, self._seqid)
4822 
    args = getCancelledOrders_args()
4823 
    args.cancelDateFrom = cancelDateFrom
4824 
    args.cancelDateTo = cancelDateTo
4825 
    args.write(self._oprot)
4826 
    self._oprot.writeMessageEnd()
4827 
    self._oprot.trans.flush()
4828 
 
4829 
  def recv_getCancelledOrders(self, ):
4830 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4831 
    if mtype == TMessageType.EXCEPTION:
4832 
      x = TApplicationException()
4833 
      x.read(self._iprot)
4834 
      self._iprot.readMessageEnd()
4835 
      raise x
4836 
    result = getCancelledOrders_result()
4837 
    result.read(self._iprot)
4838 
    self._iprot.readMessageEnd()
4839 
    if result.success is not None:
4840 
      return result.success
4841 
    if result.ex is not None:
4842 
      raise result.ex
4843 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getCancelledOrders failed: unknown result");
4844 
 
4600 varun.gupt 4845 
  def saveBluedartSettlements(self, mapAWBAndAmount):
4846 
    """
4847 
    Parameters:
4848 
     - mapAWBAndAmount
4849 
    """
4850 
    self.send_saveBluedartSettlements(mapAWBAndAmount)
4851 
    self.recv_saveBluedartSettlements()
4852 
 
4853 
  def send_saveBluedartSettlements(self, mapAWBAndAmount):
4854 
    self._oprot.writeMessageBegin('saveBluedartSettlements', TMessageType.CALL, self._seqid)
4855 
    args = saveBluedartSettlements_args()
4856 
    args.mapAWBAndAmount = mapAWBAndAmount
4857 
    args.write(self._oprot)
4858 
    self._oprot.writeMessageEnd()
4859 
    self._oprot.trans.flush()
4860 
 
4861 
  def recv_saveBluedartSettlements(self, ):
4862 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4863 
    if mtype == TMessageType.EXCEPTION:
4864 
      x = TApplicationException()
4865 
      x.read(self._iprot)
4866 
      self._iprot.readMessageEnd()
4867 
      raise x
4868 
    result = saveBluedartSettlements_result()
4869 
    result.read(self._iprot)
4870 
    self._iprot.readMessageEnd()
4871 
    if result.ex is not None:
4872 
      raise result.ex
4873 
    return
4874 
 
4905 varun.gupt 4875 
  def savePaymentSettlements(self, settlementDate, paymentGatewayId, referenceId, serviceTax, otherCharges, netCollection):
4600 varun.gupt 4876 
    """
4877 
    Parameters:
4878 
     - settlementDate
4879 
     - paymentGatewayId
4905 varun.gupt 4880 
     - referenceId
4600 varun.gupt 4881 
     - serviceTax
4882 
     - otherCharges
4883 
     - netCollection
4884 
    """
4905 varun.gupt 4885 
    self.send_savePaymentSettlements(settlementDate, paymentGatewayId, referenceId, serviceTax, otherCharges, netCollection)
4600 varun.gupt 4886 
    self.recv_savePaymentSettlements()
4887 
 
4905 varun.gupt 4888 
  def send_savePaymentSettlements(self, settlementDate, paymentGatewayId, referenceId, serviceTax, otherCharges, netCollection):
4600 varun.gupt 4889 
    self._oprot.writeMessageBegin('savePaymentSettlements', TMessageType.CALL, self._seqid)
4890 
    args = savePaymentSettlements_args()
4891 
    args.settlementDate = settlementDate
4892 
    args.paymentGatewayId = paymentGatewayId
4905 varun.gupt 4893 
    args.referenceId = referenceId
4600 varun.gupt 4894 
    args.serviceTax = serviceTax
4895 
    args.otherCharges = otherCharges
4896 
    args.netCollection = netCollection
4897 
    args.write(self._oprot)
4898 
    self._oprot.writeMessageEnd()
4899 
    self._oprot.trans.flush()
4900 
 
4901 
  def recv_savePaymentSettlements(self, ):
4902 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4903 
    if mtype == TMessageType.EXCEPTION:
4904 
      x = TApplicationException()
4905 
      x.read(self._iprot)
4906 
      self._iprot.readMessageEnd()
4907 
      raise x
4908 
    result = savePaymentSettlements_result()
4909 
    result.read(self._iprot)
4910 
    self._iprot.readMessageEnd()
4911 
    if result.ex is not None:
4912 
      raise result.ex
4913 
    return
4914 
 
4915 
  def saveEBSSettlementSummary(self, settlementId, settlementDate, transactionDateFrom, transactionDateTo, amount):
4916 
    """
4917 
    Parameters:
4918 
     - settlementId
4919 
     - settlementDate
4920 
     - transactionDateFrom
4921 
     - transactionDateTo
4922 
     - amount
4923 
    """
4924 
    self.send_saveEBSSettlementSummary(settlementId, settlementDate, transactionDateFrom, transactionDateTo, amount)
4925 
    self.recv_saveEBSSettlementSummary()
4926 
 
4927 
  def send_saveEBSSettlementSummary(self, settlementId, settlementDate, transactionDateFrom, transactionDateTo, amount):
4928 
    self._oprot.writeMessageBegin('saveEBSSettlementSummary', TMessageType.CALL, self._seqid)
4929 
    args = saveEBSSettlementSummary_args()
4930 
    args.settlementId = settlementId
4931 
    args.settlementDate = settlementDate
4932 
    args.transactionDateFrom = transactionDateFrom
4933 
    args.transactionDateTo = transactionDateTo
4934 
    args.amount = amount
4935 
    args.write(self._oprot)
4936 
    self._oprot.writeMessageEnd()
4937 
    self._oprot.trans.flush()
4938 
 
4939 
  def recv_saveEBSSettlementSummary(self, ):
4940 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4941 
    if mtype == TMessageType.EXCEPTION:
4942 
      x = TApplicationException()
4943 
      x.read(self._iprot)
4944 
      self._iprot.readMessageEnd()
4945 
      raise x
4946 
    result = saveEBSSettlementSummary_result()
4947 
    result.read(self._iprot)
4948 
    self._iprot.readMessageEnd()
4949 
    if result.ex is not None:
4950 
      raise result.ex
4951 
    return
4952 
 
5386 phani.kuma 4953 
  def getSettlementForPrepaid(self, referenceId, isRefund):
4600 varun.gupt 4954 
    """
4955 
    Parameters:
5189 varun.gupt 4956 
     - referenceId
4957 
     - isRefund
4600 varun.gupt 4958 
    """
5386 phani.kuma 4959 
    self.send_getSettlementForPrepaid(referenceId, isRefund)
4960 
    return self.recv_getSettlementForPrepaid()
4600 varun.gupt 4961 
 
5386 phani.kuma 4962 
  def send_getSettlementForPrepaid(self, referenceId, isRefund):
4963 
    self._oprot.writeMessageBegin('getSettlementForPrepaid', TMessageType.CALL, self._seqid)
4964 
    args = getSettlementForPrepaid_args()
5189 varun.gupt 4965 
    args.referenceId = referenceId
4966 
    args.isRefund = isRefund
4600 varun.gupt 4967 
    args.write(self._oprot)
4968 
    self._oprot.writeMessageEnd()
4969 
    self._oprot.trans.flush()
4970 
 
5386 phani.kuma 4971 
  def recv_getSettlementForPrepaid(self, ):
4600 varun.gupt 4972 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4973 
    if mtype == TMessageType.EXCEPTION:
4974 
      x = TApplicationException()
4975 
      x.read(self._iprot)
4976 
      self._iprot.readMessageEnd()
4977 
      raise x
5386 phani.kuma 4978 
    result = getSettlementForPrepaid_result()
4600 varun.gupt 4979 
    result.read(self._iprot)
4980 
    self._iprot.readMessageEnd()
4981 
    if result.success is not None:
4982 
      return result.success
4983 
    if result.ex is not None:
4984 
      raise result.ex
5386 phani.kuma 4985 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getSettlementForPrepaid failed: unknown result");
4600 varun.gupt 4986 
 
5386 phani.kuma 4987 
  def getSettlementForCod(self, orderId, isRefund):
4988 
    """
4989 
    Parameters:
4990 
     - orderId
4991 
     - isRefund
4992 
    """
4993 
    self.send_getSettlementForCod(orderId, isRefund)
4994 
    return self.recv_getSettlementForCod()
4995 
 
4996 
  def send_getSettlementForCod(self, orderId, isRefund):
4997 
    self._oprot.writeMessageBegin('getSettlementForCod', TMessageType.CALL, self._seqid)
4998 
    args = getSettlementForCod_args()
4999 
    args.orderId = orderId
5000 
    args.isRefund = isRefund
5001 
    args.write(self._oprot)
5002 
    self._oprot.writeMessageEnd()
5003 
    self._oprot.trans.flush()
5004 
 
5005 
  def recv_getSettlementForCod(self, ):
5006 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
5007 
    if mtype == TMessageType.EXCEPTION:
5008 
      x = TApplicationException()
5009 
      x.read(self._iprot)
5010 
      self._iprot.readMessageEnd()
5011 
      raise x
5012 
    result = getSettlementForCod_result()
5013 
    result.read(self._iprot)
5014 
    self._iprot.readMessageEnd()
5015 
    if result.success is not None:
5016 
      return result.success
5017 
    if result.ex is not None:
5018 
      raise result.ex
5019 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getSettlementForCod failed: unknown result");
5020 
 
4600 varun.gupt 5021 
  def getEBSSettlementSummaries(self, ):
5022 
    self.send_getEBSSettlementSummaries()
5023 
    return self.recv_getEBSSettlementSummaries()
5024 
 
5025 
  def send_getEBSSettlementSummaries(self, ):
5026 
    self._oprot.writeMessageBegin('getEBSSettlementSummaries', TMessageType.CALL, self._seqid)
5027 
    args = getEBSSettlementSummaries_args()
5028 
    args.write(self._oprot)
5029 
    self._oprot.writeMessageEnd()
5030 
    self._oprot.trans.flush()
5031 
 
5032 
  def recv_getEBSSettlementSummaries(self, ):
5033 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
5034 
    if mtype == TMessageType.EXCEPTION:
5035 
      x = TApplicationException()
5036 
      x.read(self._iprot)
5037 
      self._iprot.readMessageEnd()
5038 
      raise x
5039 
    result = getEBSSettlementSummaries_result()
5040 
    result.read(self._iprot)
5041 
    self._iprot.readMessageEnd()
5042 
    if result.success is not None:
5043 
      return result.success
5044 
    if result.ex is not None:
5045 
      raise result.ex
5046 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getEBSSettlementSummaries failed: unknown result");
5047 
 
5048 
  def markEBSSettlementUploaded(self, settlementId):
5049 
    """
5050 
    Parameters:
5051 
     - settlementId
5052 
    """
5053 
    self.send_markEBSSettlementUploaded(settlementId)
5054 
    self.recv_markEBSSettlementUploaded()
5055 
 
5056 
  def send_markEBSSettlementUploaded(self, settlementId):
5057 
    self._oprot.writeMessageBegin('markEBSSettlementUploaded', TMessageType.CALL, self._seqid)
5058 
    args = markEBSSettlementUploaded_args()
5059 
    args.settlementId = settlementId
5060 
    args.write(self._oprot)
5061 
    self._oprot.writeMessageEnd()
5062 
    self._oprot.trans.flush()
5063 
 
5064 
  def recv_markEBSSettlementUploaded(self, ):
5065 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
5066 
    if mtype == TMessageType.EXCEPTION:
5067 
      x = TApplicationException()
5068 
      x.read(self._iprot)
5069 
      self._iprot.readMessageEnd()
5070 
      raise x
5071 
    result = markEBSSettlementUploaded_result()
5072 
    result.read(self._iprot)
5073 
    self._iprot.readMessageEnd()
5074 
    if result.ex is not None:
5075 
      raise result.ex
5076 
    return
5077 
 
5078 
  def getEBSSettlementDate(self, settlementId):
5079 
    """
5080 
    Parameters:
5081 
     - settlementId
5082 
    """
5083 
    self.send_getEBSSettlementDate(settlementId)
5084 
    return self.recv_getEBSSettlementDate()
5085 
 
5086 
  def send_getEBSSettlementDate(self, settlementId):
5087 
    self._oprot.writeMessageBegin('getEBSSettlementDate', TMessageType.CALL, self._seqid)
5088 
    args = getEBSSettlementDate_args()
5089 
    args.settlementId = settlementId
5090 
    args.write(self._oprot)
5091 
    self._oprot.writeMessageEnd()
5092 
    self._oprot.trans.flush()
5093 
 
5094 
  def recv_getEBSSettlementDate(self, ):
5095 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
5096 
    if mtype == TMessageType.EXCEPTION:
5097 
      x = TApplicationException()
5098 
      x.read(self._iprot)
5099 
      self._iprot.readMessageEnd()
5100 
      raise x
5101 
    result = getEBSSettlementDate_result()
5102 
    result.read(self._iprot)
5103 
    self._iprot.readMessageEnd()
5104 
    if result.success is not None:
5105 
      return result.success
5106 
    if result.ex is not None:
5107 
      raise result.ex
5108 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getEBSSettlementDate failed: unknown result");
5109 
 
4715 varun.gupt 5110 
  def getSettlementsByDate(self, settlementDateFrom, settlementDateTo, isRefund):
5111 
    """
5112 
    Parameters:
5113 
     - settlementDateFrom
5114 
     - settlementDateTo
5115 
     - isRefund
5116 
    """
5117 
    self.send_getSettlementsByDate(settlementDateFrom, settlementDateTo, isRefund)
5118 
    return self.recv_getSettlementsByDate()
4600 varun.gupt 5119 
 
4715 varun.gupt 5120 
  def send_getSettlementsByDate(self, settlementDateFrom, settlementDateTo, isRefund):
5121 
    self._oprot.writeMessageBegin('getSettlementsByDate', TMessageType.CALL, self._seqid)
5122 
    args = getSettlementsByDate_args()
5123 
    args.settlementDateFrom = settlementDateFrom
5124 
    args.settlementDateTo = settlementDateTo
5125 
    args.isRefund = isRefund
5126 
    args.write(self._oprot)
5127 
    self._oprot.writeMessageEnd()
5128 
    self._oprot.trans.flush()
5129 
 
5130 
  def recv_getSettlementsByDate(self, ):
5131 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
5132 
    if mtype == TMessageType.EXCEPTION:
5133 
      x = TApplicationException()
5134 
      x.read(self._iprot)
5135 
      self._iprot.readMessageEnd()
5136 
      raise x
5137 
    result = getSettlementsByDate_result()
5138 
    result.read(self._iprot)
5139 
    self._iprot.readMessageEnd()
5140 
    if result.success is not None:
5141 
      return result.success
5142 
    if result.ex is not None:
5143 
      raise result.ex
5144 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getSettlementsByDate failed: unknown result");
5145 
 
5146 
  def getReshippedOrderIds(self, orderIds):
5147 
    """
5148 
    Returns list of Order Ids, which belong to reshiped orders, shortlisted from a given list of Order Ids
5149 
 
5150 
    Parameters:
5151 
     - orderIds
5152 
    """
5153 
    self.send_getReshippedOrderIds(orderIds)
5154 
    return self.recv_getReshippedOrderIds()
5155 
 
5156 
  def send_getReshippedOrderIds(self, orderIds):
5157 
    self._oprot.writeMessageBegin('getReshippedOrderIds', TMessageType.CALL, self._seqid)
5158 
    args = getReshippedOrderIds_args()
5159 
    args.orderIds = orderIds
5160 
    args.write(self._oprot)
5161 
    self._oprot.writeMessageEnd()
5162 
    self._oprot.trans.flush()
5163 
 
5164 
  def recv_getReshippedOrderIds(self, ):
5165 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
5166 
    if mtype == TMessageType.EXCEPTION:
5167 
      x = TApplicationException()
5168 
      x.read(self._iprot)
5169 
      self._iprot.readMessageEnd()
5170 
      raise x
5171 
    result = getReshippedOrderIds_result()
5172 
    result.read(self._iprot)
5173 
    self._iprot.readMessageEnd()
5174 
    if result.success is not None:
5175 
      return result.success
5176 
    if result.ex is not None:
5177 
      raise result.ex
5178 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getReshippedOrderIds failed: unknown result");
5179 
 
5481 phani.kuma 5180 
  def getBilledOrders(self, vendorId, onlyVendorNotPaid, billingDateFrom, billingDateTo):
4875 varun.gupt 5181 
    """
5182 
    Parameters:
5183 
     - vendorId
5481 phani.kuma 5184 
     - onlyVendorNotPaid
5185 
     - billingDateFrom
5186 
     - billingDateTo
4875 varun.gupt 5187 
    """
5481 phani.kuma 5188 
    self.send_getBilledOrders(vendorId, onlyVendorNotPaid, billingDateFrom, billingDateTo)
5189 
    return self.recv_getBilledOrders()
4757 mandeep.dh 5190 
 
5481 phani.kuma 5191 
  def send_getBilledOrders(self, vendorId, onlyVendorNotPaid, billingDateFrom, billingDateTo):
5192 
    self._oprot.writeMessageBegin('getBilledOrders', TMessageType.CALL, self._seqid)
5193 
    args = getBilledOrders_args()
4875 varun.gupt 5194 
    args.vendorId = vendorId
5481 phani.kuma 5195 
    args.onlyVendorNotPaid = onlyVendorNotPaid
5196 
    args.billingDateFrom = billingDateFrom
5197 
    args.billingDateTo = billingDateTo
4875 varun.gupt 5198 
    args.write(self._oprot)
5199 
    self._oprot.writeMessageEnd()
5200 
    self._oprot.trans.flush()
5201 
 
5481 phani.kuma 5202 
  def recv_getBilledOrders(self, ):
4875 varun.gupt 5203 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
5204 
    if mtype == TMessageType.EXCEPTION:
5205 
      x = TApplicationException()
5206 
      x.read(self._iprot)
5207 
      self._iprot.readMessageEnd()
5208 
      raise x
5481 phani.kuma 5209 
    result = getBilledOrders_result()
4875 varun.gupt 5210 
    result.read(self._iprot)
5211 
    self._iprot.readMessageEnd()
5212 
    if result.success is not None:
5213 
      return result.success
5214 
    if result.ex is not None:
5215 
      raise result.ex
5481 phani.kuma 5216 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getBilledOrders failed: unknown result");
4875 varun.gupt 5217 
 
5031 varun.gupt 5218 
  def getStatusDistributionOfOrders(self, startDate, endDate):
5219 
    """
5220 
    Parameters:
5221 
     - startDate
5222 
     - endDate
5223 
    """
5224 
    self.send_getStatusDistributionOfOrders(startDate, endDate)
5225 
    return self.recv_getStatusDistributionOfOrders()
4875 varun.gupt 5226 
 
5031 varun.gupt 5227 
  def send_getStatusDistributionOfOrders(self, startDate, endDate):
5228 
    self._oprot.writeMessageBegin('getStatusDistributionOfOrders', TMessageType.CALL, self._seqid)
5229 
    args = getStatusDistributionOfOrders_args()
5230 
    args.startDate = startDate
5231 
    args.endDate = endDate
5232 
    args.write(self._oprot)
5233 
    self._oprot.writeMessageEnd()
5234 
    self._oprot.trans.flush()
5235 
 
5236 
  def recv_getStatusDistributionOfOrders(self, ):
5237 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
5238 
    if mtype == TMessageType.EXCEPTION:
5239 
      x = TApplicationException()
5240 
      x.read(self._iprot)
5241 
      self._iprot.readMessageEnd()
5242 
      raise x
5243 
    result = getStatusDistributionOfOrders_result()
5244 
    result.read(self._iprot)
5245 
    self._iprot.readMessageEnd()
5246 
    if result.success is not None:
5247 
      return result.success
5248 
    if result.ex is not None:
5249 
      raise result.ex
5250 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getStatusDistributionOfOrders failed: unknown result");
5251 
 
5067 varun.gupt 5252 
  def getOrderIdsForStatus(self, status, startDatetime, endDatetime):
5253 
    """
5254 
    Parameters:
5255 
     - status
5256 
     - startDatetime
5257 
     - endDatetime
5258 
    """
5259 
    self.send_getOrderIdsForStatus(status, startDatetime, endDatetime)
5260 
    return self.recv_getOrderIdsForStatus()
5031 varun.gupt 5261 
 
5067 varun.gupt 5262 
  def send_getOrderIdsForStatus(self, status, startDatetime, endDatetime):
5263 
    self._oprot.writeMessageBegin('getOrderIdsForStatus', TMessageType.CALL, self._seqid)
5264 
    args = getOrderIdsForStatus_args()
5265 
    args.status = status
5266 
    args.startDatetime = startDatetime
5267 
    args.endDatetime = endDatetime
5268 
    args.write(self._oprot)
5269 
    self._oprot.writeMessageEnd()
5270 
    self._oprot.trans.flush()
5271 
 
5272 
  def recv_getOrderIdsForStatus(self, ):
5273 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
5274 
    if mtype == TMessageType.EXCEPTION:
5275 
      x = TApplicationException()
5276 
      x.read(self._iprot)
5277 
      self._iprot.readMessageEnd()
5278 
      raise x
5279 
    result = getOrderIdsForStatus_result()
5280 
    result.read(self._iprot)
5281 
    self._iprot.readMessageEnd()
5282 
    if result.success is not None:
5283 
      return result.success
5284 
    if result.ex is not None:
5285 
      raise result.ex
5286 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getOrderIdsForStatus failed: unknown result");
5287 
 
5348 anupam.sin 5288 
  def updateCODAgent(self, agent, orderId):
5289 
    """
5290 
    Updates the agent who handled the COD verification call
5291 
 
5292 
    Parameters:
5293 
     - agent
5294 
     - orderId
5295 
    """
5296 
    self.send_updateCODAgent(agent, orderId)
5297 
    self.recv_updateCODAgent()
5298 
 
5299 
  def send_updateCODAgent(self, agent, orderId):
5300 
    self._oprot.writeMessageBegin('updateCODAgent', TMessageType.CALL, self._seqid)
5301 
    args = updateCODAgent_args()
5302 
    args.agent = agent
5303 
    args.orderId = orderId
5304 
    args.write(self._oprot)
5305 
    self._oprot.writeMessageEnd()
5306 
    self._oprot.trans.flush()
5307 
 
5308 
  def recv_updateCODAgent(self, ):
5309 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
5310 
    if mtype == TMessageType.EXCEPTION:
5311 
      x = TApplicationException()
5312 
      x.read(self._iprot)
5313 
      self._iprot.readMessageEnd()
5314 
      raise x
5315 
    result = updateCODAgent_result()
5316 
    result.read(self._iprot)
5317 
    self._iprot.readMessageEnd()
5318 
    if result.ex is not None:
5319 
      raise result.ex
5320 
    return
5321 
 
5099 varun.gupt 5322 
  def updateOrderAsPaidToVendor(self, orderId):
5323 
    """
5324 
    Parameters:
5325 
     - orderId
5326 
    """
5327 
    self.send_updateOrderAsPaidToVendor(orderId)
5328 
    self.recv_updateOrderAsPaidToVendor()
5067 varun.gupt 5329 
 
5099 varun.gupt 5330 
  def send_updateOrderAsPaidToVendor(self, orderId):
5331 
    self._oprot.writeMessageBegin('updateOrderAsPaidToVendor', TMessageType.CALL, self._seqid)
5332 
    args = updateOrderAsPaidToVendor_args()
5333 
    args.orderId = orderId
5334 
    args.write(self._oprot)
5335 
    self._oprot.writeMessageEnd()
5336 
    self._oprot.trans.flush()
5337 
 
5338 
  def recv_updateOrderAsPaidToVendor(self, ):
5339 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
5340 
    if mtype == TMessageType.EXCEPTION:
5341 
      x = TApplicationException()
5342 
      x.read(self._iprot)
5343 
      self._iprot.readMessageEnd()
5344 
      raise x
5345 
    result = updateOrderAsPaidToVendor_result()
5346 
    result.read(self._iprot)
5347 
    self._iprot.readMessageEnd()
5348 
    if result.ex is not None:
5349 
      raise result.ex
5350 
    return
5351 
 
5386 phani.kuma 5352 
  def updateOrderOnlyAsPaidToVendor(self, orderId):
5353 
    """
5354 
    Parameters:
5355 
     - orderId
5356 
    """
5357 
    self.send_updateOrderOnlyAsPaidToVendor(orderId)
5358 
    self.recv_updateOrderOnlyAsPaidToVendor()
5359 
 
5360 
  def send_updateOrderOnlyAsPaidToVendor(self, orderId):
5361 
    self._oprot.writeMessageBegin('updateOrderOnlyAsPaidToVendor', TMessageType.CALL, self._seqid)
5362 
    args = updateOrderOnlyAsPaidToVendor_args()
5363 
    args.orderId = orderId
5364 
    args.write(self._oprot)
5365 
    self._oprot.writeMessageEnd()
5366 
    self._oprot.trans.flush()
5367 
 
5368 
  def recv_updateOrderOnlyAsPaidToVendor(self, ):
5369 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
5370 
    if mtype == TMessageType.EXCEPTION:
5371 
      x = TApplicationException()
5372 
      x.read(self._iprot)
5373 
      self._iprot.readMessageEnd()
5374 
      raise x
5375 
    result = updateOrderOnlyAsPaidToVendor_result()
5376 
    result.read(self._iprot)
5377 
    self._iprot.readMessageEnd()
5378 
    if result.ex is not None:
5379 
      raise result.ex
5380 
    return
5381 
 
5208 varun.gupt 5382 
  def getRefundedOrdersMarkedPaid(self, ):
5383 
    self.send_getRefundedOrdersMarkedPaid()
5384 
    return self.recv_getRefundedOrdersMarkedPaid()
5099 varun.gupt 5385 
 
5208 varun.gupt 5386 
  def send_getRefundedOrdersMarkedPaid(self, ):
5387 
    self._oprot.writeMessageBegin('getRefundedOrdersMarkedPaid', TMessageType.CALL, self._seqid)
5388 
    args = getRefundedOrdersMarkedPaid_args()
5389 
    args.write(self._oprot)
5390 
    self._oprot.writeMessageEnd()
5391 
    self._oprot.trans.flush()
5392 
 
5393 
  def recv_getRefundedOrdersMarkedPaid(self, ):
5394 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
5395 
    if mtype == TMessageType.EXCEPTION:
5396 
      x = TApplicationException()
5397 
      x.read(self._iprot)
5398 
      self._iprot.readMessageEnd()
5399 
      raise x
5400 
    result = getRefundedOrdersMarkedPaid_result()
5401 
    result.read(self._iprot)
5402 
    self._iprot.readMessageEnd()
5403 
    if result.success is not None:
5404 
      return result.success
5405 
    if result.ex is not None:
5406 
      raise result.ex
5407 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getRefundedOrdersMarkedPaid failed: unknown result");
5408 
 
5447 anupam.sin 5409 
  def getAllVerificationAgents(self, minOrderId, maxOrderId):
5410 
    """
5411 
    gets all COD Verification Agents for all orderIds from a minId to maxId
5208 varun.gupt 5412 
 
5447 anupam.sin 5413 
 
5414 
    Parameters:
5415 
     - minOrderId
5416 
     - maxOrderId
5417 
    """
5418 
    self.send_getAllVerificationAgents(minOrderId, maxOrderId)
5419 
    return self.recv_getAllVerificationAgents()
5420 
 
5421 
  def send_getAllVerificationAgents(self, minOrderId, maxOrderId):
5422 
    self._oprot.writeMessageBegin('getAllVerificationAgents', TMessageType.CALL, self._seqid)
5423 
    args = getAllVerificationAgents_args()
5424 
    args.minOrderId = minOrderId
5425 
    args.maxOrderId = maxOrderId
5426 
    args.write(self._oprot)
5427 
    self._oprot.writeMessageEnd()
5428 
    self._oprot.trans.flush()
5429 
 
5430 
  def recv_getAllVerificationAgents(self, ):
5431 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
5432 
    if mtype == TMessageType.EXCEPTION:
5433 
      x = TApplicationException()
5434 
      x.read(self._iprot)
5435 
      self._iprot.readMessageEnd()
5436 
      raise x
5437 
    result = getAllVerificationAgents_result()
5438 
    result.read(self._iprot)
5439 
    self._iprot.readMessageEnd()
5440 
    if result.success is not None:
5441 
      return result.success
5442 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAllVerificationAgents failed: unknown result");
5443 
 
5527 anupam.sin 5444 
  def getAllAttributesForOrderId(self, orderId):
5445 
    """
5446 
    gets all attributes for a given orderId
5447 anupam.sin 5447 
 
5527 anupam.sin 5448 
    Parameters:
5449 
     - orderId
5450 
    """
5451 
    self.send_getAllAttributesForOrderId(orderId)
5452 
    return self.recv_getAllAttributesForOrderId()
5453 
 
5454 
  def send_getAllAttributesForOrderId(self, orderId):
5455 
    self._oprot.writeMessageBegin('getAllAttributesForOrderId', TMessageType.CALL, self._seqid)
5456 
    args = getAllAttributesForOrderId_args()
5457 
    args.orderId = orderId
5458 
    args.write(self._oprot)
5459 
    self._oprot.writeMessageEnd()
5460 
    self._oprot.trans.flush()
5461 
 
5462 
  def recv_getAllAttributesForOrderId(self, ):
5463 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
5464 
    if mtype == TMessageType.EXCEPTION:
5465 
      x = TApplicationException()
5466 
      x.read(self._iprot)
5467 
      self._iprot.readMessageEnd()
5468 
      raise x
5469 
    result = getAllAttributesForOrderId_result()
5470 
    result.read(self._iprot)
5471 
    self._iprot.readMessageEnd()
5472 
    if result.success is not None:
5473 
      return result.success
5474 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAllAttributesForOrderId failed: unknown result");
5475 
 
5676 rajveer 5476 
  def setOrderAttributes(self, orderId, attributes):
5477 
    """
5478 
    sets attributes for an order
5479 
 
5480 
    Parameters:
5481 
     - orderId
5482 
     - attributes
5483 
    """
5484 
    self.send_setOrderAttributes(orderId, attributes)
5485 
    self.recv_setOrderAttributes()
5486 
 
5487 
  def send_setOrderAttributes(self, orderId, attributes):
5488 
    self._oprot.writeMessageBegin('setOrderAttributes', TMessageType.CALL, self._seqid)
5489 
    args = setOrderAttributes_args()
5490 
    args.orderId = orderId
5491 
    args.attributes = attributes
5492 
    args.write(self._oprot)
5493 
    self._oprot.writeMessageEnd()
5494 
    self._oprot.trans.flush()
5495 
 
5496 
  def recv_setOrderAttributes(self, ):
5497 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
5498 
    if mtype == TMessageType.EXCEPTION:
5499 
      x = TApplicationException()
5500 
      x.read(self._iprot)
5501 
      self._iprot.readMessageEnd()
5502 
      raise x
5503 
    result = setOrderAttributes_result()
5504 
    result.read(self._iprot)
5505 
    self._iprot.readMessageEnd()
5506 
    return
5507 
 
5527 anupam.sin 5508 
  def setOrderAttributeForTransaction(self, transactionId, attribute):
5509 
    """
5510 
    sets attributes for all orders in a transaction
5511 
 
5512 
    Parameters:
5513 
     - transactionId
5514 
     - attribute
5515 
    """
5516 
    self.send_setOrderAttributeForTransaction(transactionId, attribute)
5517 
    self.recv_setOrderAttributeForTransaction()
5518 
 
5519 
  def send_setOrderAttributeForTransaction(self, transactionId, attribute):
5520 
    self._oprot.writeMessageBegin('setOrderAttributeForTransaction', TMessageType.CALL, self._seqid)
5521 
    args = setOrderAttributeForTransaction_args()
5522 
    args.transactionId = transactionId
5523 
    args.attribute = attribute
5524 
    args.write(self._oprot)
5525 
    self._oprot.writeMessageEnd()
5526 
    self._oprot.trans.flush()
5527 
 
5528 
  def recv_setOrderAttributeForTransaction(self, ):
5529 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
5530 
    if mtype == TMessageType.EXCEPTION:
5531 
      x = TApplicationException()
5532 
      x.read(self._iprot)
5533 
      self._iprot.readMessageEnd()
5534 
      raise x
5535 
    result = setOrderAttributeForTransaction_result()
5536 
    result.read(self._iprot)
5537 
    self._iprot.readMessageEnd()
5538 
    return
5539 
 
5553 rajveer 5540 
  def getReceivePendingOrders(self, storeId):
5541 
    """
5542 
    Parameters:
5543 
     - storeId
5544 
    """
5545 
    self.send_getReceivePendingOrders(storeId)
5546 
    return self.recv_getReceivePendingOrders()
5527 anupam.sin 5547 
 
5553 rajveer 5548 
  def send_getReceivePendingOrders(self, storeId):
5549 
    self._oprot.writeMessageBegin('getReceivePendingOrders', TMessageType.CALL, self._seqid)
5550 
    args = getReceivePendingOrders_args()
5551 
    args.storeId = storeId
5552 
    args.write(self._oprot)
5553 
    self._oprot.writeMessageEnd()
5554 
    self._oprot.trans.flush()
5555 
 
5556 
  def recv_getReceivePendingOrders(self, ):
5557 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
5558 
    if mtype == TMessageType.EXCEPTION:
5559 
      x = TApplicationException()
5560 
      x.read(self._iprot)
5561 
      self._iprot.readMessageEnd()
5562 
      raise x
5563 
    result = getReceivePendingOrders_result()
5564 
    result.read(self._iprot)
5565 
    self._iprot.readMessageEnd()
5566 
    if result.success is not None:
5567 
      return result.success
5568 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getReceivePendingOrders failed: unknown result");
5569 
 
5570 
  def getReceivedAtStoreOrders(self, storeId):
5571 
    """
5572 
    Parameters:
5573 
     - storeId
5574 
    """
5575 
    self.send_getReceivedAtStoreOrders(storeId)
5576 
    return self.recv_getReceivedAtStoreOrders()
5577 
 
5578 
  def send_getReceivedAtStoreOrders(self, storeId):
5579 
    self._oprot.writeMessageBegin('getReceivedAtStoreOrders', TMessageType.CALL, self._seqid)
5580 
    args = getReceivedAtStoreOrders_args()
5581 
    args.storeId = storeId
5582 
    args.write(self._oprot)
5583 
    self._oprot.writeMessageEnd()
5584 
    self._oprot.trans.flush()
5585 
 
5586 
  def recv_getReceivedAtStoreOrders(self, ):
5587 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
5588 
    if mtype == TMessageType.EXCEPTION:
5589 
      x = TApplicationException()
5590 
      x.read(self._iprot)
5591 
      self._iprot.readMessageEnd()
5592 
      raise x
5593 
    result = getReceivedAtStoreOrders_result()
5594 
    result.read(self._iprot)
5595 
    self._iprot.readMessageEnd()
5596 
    if result.success is not None:
5597 
      return result.success
5598 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getReceivedAtStoreOrders failed: unknown result");
5599 
 
5713 rajveer 5600 
  def getOrdersCollectionAtStore(self, storeId, fromDate, toDate, onlyCod):
5601 
    """
5602 
    Parameters:
5603 
     - storeId
5604 
     - fromDate
5605 
     - toDate
5606 
     - onlyCod
5607 
    """
5608 
    self.send_getOrdersCollectionAtStore(storeId, fromDate, toDate, onlyCod)
5609 
    return self.recv_getOrdersCollectionAtStore()
5610 
 
5611 
  def send_getOrdersCollectionAtStore(self, storeId, fromDate, toDate, onlyCod):
5612 
    self._oprot.writeMessageBegin('getOrdersCollectionAtStore', TMessageType.CALL, self._seqid)
5613 
    args = getOrdersCollectionAtStore_args()
5614 
    args.storeId = storeId
5615 
    args.fromDate = fromDate
5616 
    args.toDate = toDate
5617 
    args.onlyCod = onlyCod
5618 
    args.write(self._oprot)
5619 
    self._oprot.writeMessageEnd()
5620 
    self._oprot.trans.flush()
5621 
 
5622 
  def recv_getOrdersCollectionAtStore(self, ):
5623 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
5624 
    if mtype == TMessageType.EXCEPTION:
5625 
      x = TApplicationException()
5626 
      x.read(self._iprot)
5627 
      self._iprot.readMessageEnd()
5628 
      raise x
5629 
    result = getOrdersCollectionAtStore_result()
5630 
    result.read(self._iprot)
5631 
    self._iprot.readMessageEnd()
5632 
    if result.success is not None:
5633 
      return result.success
5634 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getOrdersCollectionAtStore failed: unknown result");
5635 
 
5833 rajveer 5636 
  def getOrderAttributeValue(self, orderId, attributeName):
5637 
    """
5638 
    Parameters:
5639 
     - orderId
5640 
     - attributeName
5641 
    """
5642 
    self.send_getOrderAttributeValue(orderId, attributeName)
5643 
    return self.recv_getOrderAttributeValue()
5644 
 
5645 
  def send_getOrderAttributeValue(self, orderId, attributeName):
5646 
    self._oprot.writeMessageBegin('getOrderAttributeValue', TMessageType.CALL, self._seqid)
5647 
    args = getOrderAttributeValue_args()
5648 
    args.orderId = orderId
5649 
    args.attributeName = attributeName
5650 
    args.write(self._oprot)
5651 
    self._oprot.writeMessageEnd()
5652 
    self._oprot.trans.flush()
5653 
 
5654 
  def recv_getOrderAttributeValue(self, ):
5655 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
5656 
    if mtype == TMessageType.EXCEPTION:
5657 
      x = TApplicationException()
5658 
      x.read(self._iprot)
5659 
      self._iprot.readMessageEnd()
5660 
      raise x
5661 
    result = getOrderAttributeValue_result()
5662 
    result.read(self._iprot)
5663 
    self._iprot.readMessageEnd()
5664 
    if result.success is not None:
5665 
      return result.success
5666 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getOrderAttributeValue failed: unknown result");
5667 
 
6019 rajveer 5668 
  def changeJacketNumber(self, orderId, jacketNumber):
5669 
    """
5670 
    Parameters:
5671 
     - orderId
5672 
     - jacketNumber
5673 
    """
5674 
    self.send_changeJacketNumber(orderId, jacketNumber)
5675 
    return self.recv_changeJacketNumber()
5676 
 
5677 
  def send_changeJacketNumber(self, orderId, jacketNumber):
5678 
    self._oprot.writeMessageBegin('changeJacketNumber', TMessageType.CALL, self._seqid)
5679 
    args = changeJacketNumber_args()
5680 
    args.orderId = orderId
5681 
    args.jacketNumber = jacketNumber
5682 
    args.write(self._oprot)
5683 
    self._oprot.writeMessageEnd()
5684 
    self._oprot.trans.flush()
5685 
 
5686 
  def recv_changeJacketNumber(self, ):
5687 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
5688 
    if mtype == TMessageType.EXCEPTION:
5689 
      x = TApplicationException()
5690 
      x.read(self._iprot)
5691 
      self._iprot.readMessageEnd()
5692 
      raise x
5693 
    result = changeJacketNumber_result()
5694 
    result.read(self._iprot)
5695 
    self._iprot.readMessageEnd()
5696 
    if result.success is not None:
5697 
      return result.success
5698 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "changeJacketNumber failed: unknown result");
5699 
 
5700 
  def markOrderAsRtoInTransit(self, orderId):
5701 
    """
5702 
    Parameters:
5703 
     - orderId
5704 
    """
5705 
    self.send_markOrderAsRtoInTransit(orderId)
5706 
    return self.recv_markOrderAsRtoInTransit()
5707 
 
5708 
  def send_markOrderAsRtoInTransit(self, orderId):
5709 
    self._oprot.writeMessageBegin('markOrderAsRtoInTransit', TMessageType.CALL, self._seqid)
5710 
    args = markOrderAsRtoInTransit_args()
5711 
    args.orderId = orderId
5712 
    args.write(self._oprot)
5713 
    self._oprot.writeMessageEnd()
5714 
    self._oprot.trans.flush()
5715 
 
5716 
  def recv_markOrderAsRtoInTransit(self, ):
5717 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
5718 
    if mtype == TMessageType.EXCEPTION:
5719 
      x = TApplicationException()
5720 
      x.read(self._iprot)
5721 
      self._iprot.readMessageEnd()
5722 
      raise x
5723 
    result = markOrderAsRtoInTransit_result()
5724 
    result.read(self._iprot)
5725 
    self._iprot.readMessageEnd()
5726 
    if result.success is not None:
5727 
      return result.success
5728 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "markOrderAsRtoInTransit failed: unknown result");
5729 
 
5593 mandeep.dh 5730 
  def acceptOrderForItem(self, itemId, quantity, fulfilmentWarehouseId, billingWarehouseId):
5731 
    """
5732 
    Accepts appropriate order for an item in a given billingWarehouse. Usually
5733 
    invoked while scanning IN of items.
5553 rajveer 5734 
 
5593 mandeep.dh 5735 
    Parameters:
5736 
     - itemId
5737 
     - quantity
5738 
     - fulfilmentWarehouseId
5739 
     - billingWarehouseId
5740 
    """
5741 
    self.send_acceptOrderForItem(itemId, quantity, fulfilmentWarehouseId, billingWarehouseId)
5742 
    self.recv_acceptOrderForItem()
5743 
 
5744 
  def send_acceptOrderForItem(self, itemId, quantity, fulfilmentWarehouseId, billingWarehouseId):
5745 
    self._oprot.writeMessageBegin('acceptOrderForItem', TMessageType.CALL, self._seqid)
5746 
    args = acceptOrderForItem_args()
5747 
    args.itemId = itemId
5748 
    args.quantity = quantity
5749 
    args.fulfilmentWarehouseId = fulfilmentWarehouseId
5750 
    args.billingWarehouseId = billingWarehouseId
5751 
    args.write(self._oprot)
5752 
    self._oprot.writeMessageEnd()
5753 
    self._oprot.trans.flush()
5754 
 
5755 
  def recv_acceptOrderForItem(self, ):
5756 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
5757 
    if mtype == TMessageType.EXCEPTION:
5758 
      x = TApplicationException()
5759 
      x.read(self._iprot)
5760 
      self._iprot.readMessageEnd()
5761 
      raise x
5762 
    result = acceptOrderForItem_result()
5763 
    result.read(self._iprot)
5764 
    self._iprot.readMessageEnd()
5765 
    return
5766 
 
6000 mandeep.dh 5767 
  def createRechargeOrder(self, rechargeOrder):
5768 
    """
5769 
    Parameters:
5770 
     - rechargeOrder
5771 
    """
5772 
    self.send_createRechargeOrder(rechargeOrder)
5773 
    return self.recv_createRechargeOrder()
5593 mandeep.dh 5774 
 
6000 mandeep.dh 5775 
  def send_createRechargeOrder(self, rechargeOrder):
5776 
    self._oprot.writeMessageBegin('createRechargeOrder', TMessageType.CALL, self._seqid)
5777 
    args = createRechargeOrder_args()
5778 
    args.rechargeOrder = rechargeOrder
5779 
    args.write(self._oprot)
5780 
    self._oprot.writeMessageEnd()
5781 
    self._oprot.trans.flush()
5782 
 
5783 
  def recv_createRechargeOrder(self, ):
5784 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
5785 
    if mtype == TMessageType.EXCEPTION:
5786 
      x = TApplicationException()
5787 
      x.read(self._iprot)
5788 
      self._iprot.readMessageEnd()
5789 
      raise x
5790 
    result = createRechargeOrder_result()
5791 
    result.read(self._iprot)
5792 
    self._iprot.readMessageEnd()
5793 
    if result.success is not None:
5794 
      return result.success
5795 
    if result.ex is not None:
5796 
      raise result.ex
5797 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "createRechargeOrder failed: unknown result");
5798 
 
5799 
  def updateRechargeOrderStatus(self, rechargeOrderId, rechargeOrderStatus):
5800 
    """
5801 
    Parameters:
5802 
     - rechargeOrderId
5803 
     - rechargeOrderStatus
5804 
    """
5805 
    self.send_updateRechargeOrderStatus(rechargeOrderId, rechargeOrderStatus)
5806 
    self.recv_updateRechargeOrderStatus()
5807 
 
5808 
  def send_updateRechargeOrderStatus(self, rechargeOrderId, rechargeOrderStatus):
5809 
    self._oprot.writeMessageBegin('updateRechargeOrderStatus', TMessageType.CALL, self._seqid)
5810 
    args = updateRechargeOrderStatus_args()
5811 
    args.rechargeOrderId = rechargeOrderId
5812 
    args.rechargeOrderStatus = rechargeOrderStatus
5813 
    args.write(self._oprot)
5814 
    self._oprot.writeMessageEnd()
5815 
    self._oprot.trans.flush()
5816 
 
5817 
  def recv_updateRechargeOrderStatus(self, ):
5818 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
5819 
    if mtype == TMessageType.EXCEPTION:
5820 
      x = TApplicationException()
5821 
      x.read(self._iprot)
5822 
      self._iprot.readMessageEnd()
5823 
      raise x
5824 
    result = updateRechargeOrderStatus_result()
5825 
    result.read(self._iprot)
5826 
    self._iprot.readMessageEnd()
5827 
    if result.ex is not None:
5828 
      raise result.ex
5829 
    return
5830 
 
5831 
  def activateRechargeTxn(self, rechargeCoupons):
5832 
    """
5833 
    Parameters:
5834 
     - rechargeCoupons
5835 
    """
5836 
    self.send_activateRechargeTxn(rechargeCoupons)
5837 
    return self.recv_activateRechargeTxn()
5838 
 
5839 
  def send_activateRechargeTxn(self, rechargeCoupons):
5840 
    self._oprot.writeMessageBegin('activateRechargeTxn', TMessageType.CALL, self._seqid)
5841 
    args = activateRechargeTxn_args()
5842 
    args.rechargeCoupons = rechargeCoupons
5843 
    args.write(self._oprot)
5844 
    self._oprot.writeMessageEnd()
5845 
    self._oprot.trans.flush()
5846 
 
5847 
  def recv_activateRechargeTxn(self, ):
5848 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
5849 
    if mtype == TMessageType.EXCEPTION:
5850 
      x = TApplicationException()
5851 
      x.read(self._iprot)
5852 
      self._iprot.readMessageEnd()
5853 
      raise x
5854 
    result = activateRechargeTxn_result()
5855 
    result.read(self._iprot)
5856 
    self._iprot.readMessageEnd()
5857 
    if result.success is not None:
5858 
      return result.success
5859 
    if result.ex is not None:
5860 
      raise result.ex
5861 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "activateRechargeTxn failed: unknown result");
5862 
 
5863 
  def getRechargeOrders(self, customerId):
5864 
    """
5865 
    Parameters:
5866 
     - customerId
5867 
    """
5868 
    self.send_getRechargeOrders(customerId)
5869 
    return self.recv_getRechargeOrders()
5870 
 
5871 
  def send_getRechargeOrders(self, customerId):
5872 
    self._oprot.writeMessageBegin('getRechargeOrders', TMessageType.CALL, self._seqid)
5873 
    args = getRechargeOrders_args()
5874 
    args.customerId = customerId
5875 
    args.write(self._oprot)
5876 
    self._oprot.writeMessageEnd()
5877 
    self._oprot.trans.flush()
5878 
 
5879 
  def recv_getRechargeOrders(self, ):
5880 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
5881 
    if mtype == TMessageType.EXCEPTION:
5882 
      x = TApplicationException()
5883 
      x.read(self._iprot)
5884 
      self._iprot.readMessageEnd()
5885 
      raise x
5886 
    result = getRechargeOrders_result()
5887 
    result.read(self._iprot)
5888 
    self._iprot.readMessageEnd()
5889 
    if result.success is not None:
5890 
      return result.success
5891 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getRechargeOrders failed: unknown result");
5892 
 
5893 
  def getRechargeCoupons(self, customerId, rechargeCouponStatus):
5894 
    """
5895 
    Parameters:
5896 
     - customerId
5897 
     - rechargeCouponStatus
5898 
    """
5899 
    self.send_getRechargeCoupons(customerId, rechargeCouponStatus)
5900 
    return self.recv_getRechargeCoupons()
5901 
 
5902 
  def send_getRechargeCoupons(self, customerId, rechargeCouponStatus):
5903 
    self._oprot.writeMessageBegin('getRechargeCoupons', TMessageType.CALL, self._seqid)
5904 
    args = getRechargeCoupons_args()
5905 
    args.customerId = customerId
5906 
    args.rechargeCouponStatus = rechargeCouponStatus
5907 
    args.write(self._oprot)
5908 
    self._oprot.writeMessageEnd()
5909 
    self._oprot.trans.flush()
5910 
 
5911 
  def recv_getRechargeCoupons(self, ):
5912 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
5913 
    if mtype == TMessageType.EXCEPTION:
5914 
      x = TApplicationException()
5915 
      x.read(self._iprot)
5916 
      self._iprot.readMessageEnd()
5917 
      raise x
5918 
    result = getRechargeCoupons_result()
5919 
    result.read(self._iprot)
5920 
    self._iprot.readMessageEnd()
5921 
    if result.success is not None:
5922 
      return result.success
5923 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getRechargeCoupons failed: unknown result");
5924 
 
5925 
 
3376 rajveer 5926 
class Processor(shop2020.thriftpy.generic.GenericService.Processor, Iface, TProcessor):
94 ashish 5927 
  def __init__(self, handler):
3376 rajveer 5928 
    shop2020.thriftpy.generic.GenericService.Processor.__init__(self, handler)
94 ashish 5929 
    self._processMap["createTransaction"] = Processor.process_createTransaction
5930 
    self._processMap["getTransaction"] = Processor.process_getTransaction
5931 
    self._processMap["getTransactionsForCustomer"] = Processor.process_getTransactionsForCustomer
132 ashish 5932 
    self._processMap["getTransactionsForShoppingCartId"] = Processor.process_getTransactionsForShoppingCartId
94 ashish 5933 
    self._processMap["getTransactionStatus"] = Processor.process_getTransactionStatus
5934 
    self._processMap["changeTransactionStatus"] = Processor.process_changeTransactionStatus
1398 varun.gupt 5935 
    self._processMap["enqueueTransactionInfoEmail"] = Processor.process_enqueueTransactionInfoEmail
483 rajveer 5936 
    self._processMap["getAllOrders"] = Processor.process_getAllOrders
4133 chandransh 5937 
    self._processMap["getOrdersInBatch"] = Processor.process_getOrdersInBatch
5938 
    self._processMap["getOrderCount"] = Processor.process_getOrderCount
999 varun.gupt 5939 
    self._processMap["getOrdersByBillingDate"] = Processor.process_getOrdersByBillingDate
3427 chandransh 5940 
    self._processMap["getOrdersByShippingDate"] = Processor.process_getOrdersByShippingDate
1382 varun.gupt 5941 
    self._processMap["getReturnableOrdersForCustomer"] = Processor.process_getReturnableOrdersForCustomer
5942 
    self._processMap["getCancellableOrdersForCustomer"] = Processor.process_getCancellableOrdersForCustomer
483 rajveer 5943 
    self._processMap["changeOrderStatus"] = Processor.process_changeOrderStatus
5944 
    self._processMap["getOrdersForTransaction"] = Processor.process_getOrdersForTransaction
5945 
    self._processMap["getOrdersForCustomer"] = Processor.process_getOrdersForCustomer
5946 
    self._processMap["createOrder"] = Processor.process_createOrder
5947 
    self._processMap["getOrder"] = Processor.process_getOrder
5948 
    self._processMap["getLineItemsForOrder"] = Processor.process_getLineItemsForOrder
4999 phani.kuma 5949 
    self._processMap["getOrderList"] = Processor.process_getOrderList
5386 phani.kuma 5950 
    self._processMap["getOrderListForVendor"] = Processor.process_getOrderListForVendor
1528 ankur.sing 5951 
    self._processMap["getOrderForCustomer"] = Processor.process_getOrderForCustomer
3064 chandransh 5952 
    self._processMap["getAlerts"] = Processor.process_getAlerts
4394 rajveer 5953 
    self._processMap["addAlert"] = Processor.process_addAlert
4444 rajveer 5954 
    self._processMap["markAlertsAsSeen"] = Processor.process_markAlertsAsSeen
3064 chandransh 5955 
    self._processMap["getValidOrderCount"] = Processor.process_getValidOrderCount
5956 
    self._processMap["getNoOfCustomersWithSuccessfulTransaction"] = Processor.process_getNoOfCustomersWithSuccessfulTransaction
5957 
    self._processMap["getValidOrdersAmountRange"] = Processor.process_getValidOrdersAmountRange
5958 
    self._processMap["getValidOrders"] = Processor.process_getValidOrders
1220 chandransh 5959 
    self._processMap["batchOrders"] = Processor.process_batchOrders
1208 chandransh 5960 
    self._processMap["markOrderAsOutOfStock"] = Processor.process_markOrderAsOutOfStock
3064 chandransh 5961 
    self._processMap["verifyOrder"] = Processor.process_verifyOrder
5962 
    self._processMap["acceptOrder"] = Processor.process_acceptOrder
5963 
    self._processMap["addBillingDetails"] = Processor.process_addBillingDetails
4579 rajveer 5964 
    self._processMap["addInvoiceNumber"] = Processor.process_addInvoiceNumber
4410 rajveer 5965 
    self._processMap["markOrdersAsShippedFromWarehouse"] = Processor.process_markOrdersAsShippedFromWarehouse
5676 rajveer 5966 
    self._processMap["markOrdersAsReturnedFromStore"] = Processor.process_markOrdersAsReturnedFromStore
1113 chandransh 5967 
    self._processMap["markOrdersAsPickedUp"] = Processor.process_markOrdersAsPickedUp
4910 phani.kuma 5968 
    self._processMap["getOrdersNotPickedUp"] = Processor.process_getOrdersNotPickedUp
1132 chandransh 5969 
    self._processMap["markOrdersAsDelivered"] = Processor.process_markOrdersAsDelivered
4910 phani.kuma 5970 
    self._processMap["markAsRTOrders"] = Processor.process_markAsRTOrders
5971 
    self._processMap["getRTOrders"] = Processor.process_getRTOrders
1246 chandransh 5972 
    self._processMap["updateNonDeliveryReason"] = Processor.process_updateNonDeliveryReason
4910 phani.kuma 5973 
    self._processMap["getNonDeliveredOrdersbyCourier"] = Processor.process_getNonDeliveredOrdersbyCourier
5974 
    self._processMap["markOrdersAsLocalConnected"] = Processor.process_markOrdersAsLocalConnected
5975 
    self._processMap["getOrdersNotLocalConnected"] = Processor.process_getOrdersNotLocalConnected
5976 
    self._processMap["markOrdersAsDestinationCityReached"] = Processor.process_markOrdersAsDestinationCityReached
5977 
    self._processMap["markOrdersAsFirstDeliveryAttempted"] = Processor.process_markOrdersAsFirstDeliveryAttempted
1408 ankur.sing 5978 
    self._processMap["getUndeliveredOrders"] = Processor.process_getUndeliveredOrders
4783 phani.kuma 5979 
    self._processMap["getUndeliveredOrdersExpectedDeliveryDateNotMet"] = Processor.process_getUndeliveredOrdersExpectedDeliveryDateNotMet
2536 chandransh 5980 
    self._processMap["toggleDOAFlag"] = Processor.process_toggleDOAFlag
4712 rajveer 5981 
    self._processMap["markOrderAsDelivered"] = Processor.process_markOrderAsDelivered
5553 rajveer 5982 
    self._processMap["markOrderAsReceivedAtStore"] = Processor.process_markOrderAsReceivedAtStore
4454 rajveer 5983 
    self._processMap["markOrderDoaRequestReceived"] = Processor.process_markOrderDoaRequestReceived
5984 
    self._processMap["markOrderDoaRequestAuthorized"] = Processor.process_markOrderDoaRequestAuthorized
4488 rajveer 5985 
    self._processMap["markOrderReturnRequestReceived"] = Processor.process_markOrderReturnRequestReceived
5986 
    self._processMap["markOrderReturnRequestAuthorized"] = Processor.process_markOrderReturnRequestAuthorized
2536 chandransh 5987 
    self._processMap["requestPickupNumber"] = Processor.process_requestPickupNumber
5988 
    self._processMap["authorizePickup"] = Processor.process_authorizePickup
2764 chandransh 5989 
    self._processMap["markDoasAsPickedUp"] = Processor.process_markDoasAsPickedUp
4910 phani.kuma 5990 
    self._processMap["getDoasNotPickedUp"] = Processor.process_getDoasNotPickedUp
4741 phani.kuma 5991 
    self._processMap["markReturnOrdersAsPickedUp"] = Processor.process_markReturnOrdersAsPickedUp
4910 phani.kuma 5992 
    self._processMap["getReturnOrdersNotPickedUp"] = Processor.process_getReturnOrdersNotPickedUp
2616 chandransh 5993 
    self._processMap["receiveReturn"] = Processor.process_receiveReturn
2591 chandransh 5994 
    self._processMap["validateDoa"] = Processor.process_validateDoa
4495 rajveer 5995 
    self._processMap["validateReturnProduct"] = Processor.process_validateReturnProduct
2616 chandransh 5996 
    self._processMap["reshipOrder"] = Processor.process_reshipOrder
5997 
    self._processMap["refundOrder"] = Processor.process_refundOrder
2690 chandransh 5998 
    self._processMap["getReturnOrders"] = Processor.process_getReturnOrders
5481 phani.kuma 5999 
    self._processMap["getAllReturnOrders"] = Processor.process_getAllReturnOrders
2700 chandransh 6000 
    self._processMap["getReturnOrder"] = Processor.process_getReturnOrder
2690 chandransh 6001 
    self._processMap["processReturn"] = Processor.process_processReturn
3451 chandransh 6002 
    self._processMap["updateWeight"] = Processor.process_updateWeight
3469 chandransh 6003 
    self._processMap["changeItem"] = Processor.process_changeItem
6004 
    self._processMap["shiftToWarehouse"] = Processor.process_shiftToWarehouse
3553 chandransh 6005 
    self._processMap["addDelayReason"] = Processor.process_addDelayReason
3956 chandransh 6006 
    self._processMap["reconcileCodCollection"] = Processor.process_reconcileCodCollection
4008 mandeep.dh 6007 
    self._processMap["getTransactionsRequiringExtraProcessing"] = Processor.process_getTransactionsRequiringExtraProcessing
6008 
    self._processMap["markTransactionAsProcessed"] = Processor.process_markTransactionAsProcessed
4018 chandransh 6009 
    self._processMap["getItemWiseRiskyOrdersCount"] = Processor.process_getItemWiseRiskyOrdersCount
4295 varun.gupt 6010 
    self._processMap["getOrdersForItemIds"] = Processor.process_getOrdersForItemIds
4247 rajveer 6011 
    self._processMap["markOrderCancellationRequestReceived"] = Processor.process_markOrderCancellationRequestReceived
6012 
    self._processMap["markOrderCancellationRequestConfirmed"] = Processor.process_markOrderCancellationRequestConfirmed
6013 
    self._processMap["markOrderCancellationRequestDenied"] = Processor.process_markOrderCancellationRequestDenied
4258 rajveer 6014 
    self._processMap["markTransactionAsPaymentFlagRemoved"] = Processor.process_markTransactionAsPaymentFlagRemoved
4259 anupam.sin 6015 
    self._processMap["refundTransaction"] = Processor.process_refundTransaction
4324 mandeep.dh 6016 
    self._processMap["updateShipmentAddress"] = Processor.process_updateShipmentAddress
4285 rajveer 6017 
    self._processMap["acceptOrdersForItemId"] = Processor.process_acceptOrdersForItemId
4303 rajveer 6018 
    self._processMap["markOrdersAsPORaised"] = Processor.process_markOrdersAsPORaised
6019 
    self._processMap["markOrdersAsReversalInitiated"] = Processor.process_markOrdersAsReversalInitiated
6020 
    self._processMap["markOrdersAsNotAvailabke"] = Processor.process_markOrdersAsNotAvailabke
4369 rajveer 6021 
    self._processMap["markOrdersAsTimeout"] = Processor.process_markOrdersAsTimeout
4662 rajveer 6022 
    self._processMap["markOrderAsLostInTransit"] = Processor.process_markOrderAsLostInTransit
4386 anupam.sin 6023 
    self._processMap["getOrderForAwb"] = Processor.process_getOrderForAwb
4506 phani.kuma 6024 
    self._processMap["getOrdersForProviderForStatus"] = Processor.process_getOrdersForProviderForStatus
4600 varun.gupt 6025 
    self._processMap["getBilledOrdersForVendor"] = Processor.process_getBilledOrdersForVendor
4607 rajveer 6026 
    self._processMap["getSlippedSippingDateOrders"] = Processor.process_getSlippedSippingDateOrders
4709 rajveer 6027 
    self._processMap["getCancelledOrders"] = Processor.process_getCancelledOrders
4600 varun.gupt 6028 
    self._processMap["saveBluedartSettlements"] = Processor.process_saveBluedartSettlements
6029 
    self._processMap["savePaymentSettlements"] = Processor.process_savePaymentSettlements
6030 
    self._processMap["saveEBSSettlementSummary"] = Processor.process_saveEBSSettlementSummary
5386 phani.kuma 6031 
    self._processMap["getSettlementForPrepaid"] = Processor.process_getSettlementForPrepaid
6032 
    self._processMap["getSettlementForCod"] = Processor.process_getSettlementForCod
4600 varun.gupt 6033 
    self._processMap["getEBSSettlementSummaries"] = Processor.process_getEBSSettlementSummaries
6034 
    self._processMap["markEBSSettlementUploaded"] = Processor.process_markEBSSettlementUploaded
6035 
    self._processMap["getEBSSettlementDate"] = Processor.process_getEBSSettlementDate
4715 varun.gupt 6036 
    self._processMap["getSettlementsByDate"] = Processor.process_getSettlementsByDate
6037 
    self._processMap["getReshippedOrderIds"] = Processor.process_getReshippedOrderIds
5481 phani.kuma 6038 
    self._processMap["getBilledOrders"] = Processor.process_getBilledOrders
5031 varun.gupt 6039 
    self._processMap["getStatusDistributionOfOrders"] = Processor.process_getStatusDistributionOfOrders
5067 varun.gupt 6040 
    self._processMap["getOrderIdsForStatus"] = Processor.process_getOrderIdsForStatus
5348 anupam.sin 6041 
    self._processMap["updateCODAgent"] = Processor.process_updateCODAgent
5099 varun.gupt 6042 
    self._processMap["updateOrderAsPaidToVendor"] = Processor.process_updateOrderAsPaidToVendor
5386 phani.kuma 6043 
    self._processMap["updateOrderOnlyAsPaidToVendor"] = Processor.process_updateOrderOnlyAsPaidToVendor
5208 varun.gupt 6044 
    self._processMap["getRefundedOrdersMarkedPaid"] = Processor.process_getRefundedOrdersMarkedPaid
5447 anupam.sin 6045 
    self._processMap["getAllVerificationAgents"] = Processor.process_getAllVerificationAgents
5527 anupam.sin 6046 
    self._processMap["getAllAttributesForOrderId"] = Processor.process_getAllAttributesForOrderId
5676 rajveer 6047 
    self._processMap["setOrderAttributes"] = Processor.process_setOrderAttributes
5527 anupam.sin 6048 
    self._processMap["setOrderAttributeForTransaction"] = Processor.process_setOrderAttributeForTransaction
5553 rajveer 6049 
    self._processMap["getReceivePendingOrders"] = Processor.process_getReceivePendingOrders
6050 
    self._processMap["getReceivedAtStoreOrders"] = Processor.process_getReceivedAtStoreOrders
5713 rajveer 6051 
    self._processMap["getOrdersCollectionAtStore"] = Processor.process_getOrdersCollectionAtStore
5833 rajveer 6052 
    self._processMap["getOrderAttributeValue"] = Processor.process_getOrderAttributeValue
6019 rajveer 6053 
    self._processMap["changeJacketNumber"] = Processor.process_changeJacketNumber
6054 
    self._processMap["markOrderAsRtoInTransit"] = Processor.process_markOrderAsRtoInTransit
5593 mandeep.dh 6055 
    self._processMap["acceptOrderForItem"] = Processor.process_acceptOrderForItem
6000 mandeep.dh 6056 
    self._processMap["createRechargeOrder"] = Processor.process_createRechargeOrder
6057 
    self._processMap["updateRechargeOrderStatus"] = Processor.process_updateRechargeOrderStatus
6058 
    self._processMap["activateRechargeTxn"] = Processor.process_activateRechargeTxn
6059 
    self._processMap["getRechargeOrders"] = Processor.process_getRechargeOrders
6060 
    self._processMap["getRechargeCoupons"] = Processor.process_getRechargeCoupons
94 ashish 6061 
 
6062 
  def process(self, iprot, oprot):
6063 
    (name, type, seqid) = iprot.readMessageBegin()
6064 
    if name not in self._processMap:
6065 
      iprot.skip(TType.STRUCT)
6066 
      iprot.readMessageEnd()
6067 
      x = TApplicationException(TApplicationException.UNKNOWN_METHOD, 'Unknown function %s' % (name))
6068 
      oprot.writeMessageBegin(name, TMessageType.EXCEPTION, seqid)
6069 
      x.write(oprot)
6070 
      oprot.writeMessageEnd()
6071 
      oprot.trans.flush()
6072 
      return
6073 
    else:
6074 
      self._processMap[name](self, seqid, iprot, oprot)
6075 
    return True
6076 
 
6077 
  def process_createTransaction(self, seqid, iprot, oprot):
6078 
    args = createTransaction_args()
6079 
    args.read(iprot)
6080 
    iprot.readMessageEnd()
6081 
    result = createTransaction_result()
6082 
    try:
132 ashish 6083 
      result.success = self._handler.createTransaction(args.transaction)
94 ashish 6084 
    except TransactionServiceException, ex:
6085 
      result.ex = ex
6086 
    oprot.writeMessageBegin("createTransaction", TMessageType.REPLY, seqid)
6087 
    result.write(oprot)
6088 
    oprot.writeMessageEnd()
6089 
    oprot.trans.flush()
6090 
 
6091 
  def process_getTransaction(self, seqid, iprot, oprot):
6092 
    args = getTransaction_args()
6093 
    args.read(iprot)
6094 
    iprot.readMessageEnd()
6095 
    result = getTransaction_result()
6096 
    try:
6097 
      result.success = self._handler.getTransaction(args.id)
6098 
    except TransactionServiceException, ex:
6099 
      result.ex = ex
6100 
    oprot.writeMessageBegin("getTransaction", TMessageType.REPLY, seqid)
6101 
    result.write(oprot)
6102 
    oprot.writeMessageEnd()
6103 
    oprot.trans.flush()
6104 
 
6105 
  def process_getTransactionsForCustomer(self, seqid, iprot, oprot):
6106 
    args = getTransactionsForCustomer_args()
6107 
    args.read(iprot)
6108 
    iprot.readMessageEnd()
6109 
    result = getTransactionsForCustomer_result()
6110 
    try:
6111 
      result.success = self._handler.getTransactionsForCustomer(args.customerId, args.from_date, args.to_date, args.status)
6112 
    except TransactionServiceException, ex:
6113 
      result.ex = ex
6114 
    oprot.writeMessageBegin("getTransactionsForCustomer", TMessageType.REPLY, seqid)
6115 
    result.write(oprot)
6116 
    oprot.writeMessageEnd()
6117 
    oprot.trans.flush()
6118 
 
132 ashish 6119 
  def process_getTransactionsForShoppingCartId(self, seqid, iprot, oprot):
6120 
    args = getTransactionsForShoppingCartId_args()
6121 
    args.read(iprot)
6122 
    iprot.readMessageEnd()
6123 
    result = getTransactionsForShoppingCartId_result()
6124 
    try:
6125 
      result.success = self._handler.getTransactionsForShoppingCartId(args.shoppingCartId)
6126 
    except TransactionServiceException, ex:
6127 
      result.ex = ex
6128 
    oprot.writeMessageBegin("getTransactionsForShoppingCartId", TMessageType.REPLY, seqid)
6129 
    result.write(oprot)
6130 
    oprot.writeMessageEnd()
6131 
    oprot.trans.flush()
6132 
 
94 ashish 6133 
  def process_getTransactionStatus(self, seqid, iprot, oprot):
6134 
    args = getTransactionStatus_args()
6135 
    args.read(iprot)
6136 
    iprot.readMessageEnd()
6137 
    result = getTransactionStatus_result()
6138 
    try:
6139 
      result.success = self._handler.getTransactionStatus(args.transactionId)
6140 
    except TransactionServiceException, ex:
6141 
      result.ex = ex
6142 
    oprot.writeMessageBegin("getTransactionStatus", TMessageType.REPLY, seqid)
6143 
    result.write(oprot)
6144 
    oprot.writeMessageEnd()
6145 
    oprot.trans.flush()
6146 
 
6147 
  def process_changeTransactionStatus(self, seqid, iprot, oprot):
6148 
    args = changeTransactionStatus_args()
6149 
    args.read(iprot)
6150 
    iprot.readMessageEnd()
6151 
    result = changeTransactionStatus_result()
6152 
    try:
5527 anupam.sin 6153 
      result.success = self._handler.changeTransactionStatus(args.transactionId, args.status, args.description, args.pickUp, args.orderType)
94 ashish 6154 
    except TransactionServiceException, ex:
6155 
      result.ex = ex
6156 
    oprot.writeMessageBegin("changeTransactionStatus", TMessageType.REPLY, seqid)
6157 
    result.write(oprot)
6158 
    oprot.writeMessageEnd()
6159 
    oprot.trans.flush()
6160 
 
1398 varun.gupt 6161 
  def process_enqueueTransactionInfoEmail(self, seqid, iprot, oprot):
6162 
    args = enqueueTransactionInfoEmail_args()
1382 varun.gupt 6163 
    args.read(iprot)
6164 
    iprot.readMessageEnd()
1398 varun.gupt 6165 
    result = enqueueTransactionInfoEmail_result()
1382 varun.gupt 6166 
    try:
1398 varun.gupt 6167 
      result.success = self._handler.enqueueTransactionInfoEmail(args.transactionId)
1382 varun.gupt 6168 
    except TransactionServiceException, ex:
6169 
      result.ex = ex
1398 varun.gupt 6170 
    oprot.writeMessageBegin("enqueueTransactionInfoEmail", TMessageType.REPLY, seqid)
1382 varun.gupt 6171 
    result.write(oprot)
6172 
    oprot.writeMessageEnd()
6173 
    oprot.trans.flush()
6174 
 
483 rajveer 6175 
  def process_getAllOrders(self, seqid, iprot, oprot):
6176 
    args = getAllOrders_args()
94 ashish 6177 
    args.read(iprot)
6178 
    iprot.readMessageEnd()
483 rajveer 6179 
    result = getAllOrders_result()
94 ashish 6180 
    try:
4801 anupam.sin 6181 
      result.success = self._handler.getAllOrders(args.statuses, args.from_date, args.to_date, args.warehouse_id)
94 ashish 6182 
    except TransactionServiceException, ex:
6183 
      result.ex = ex
483 rajveer 6184 
    oprot.writeMessageBegin("getAllOrders", TMessageType.REPLY, seqid)
94 ashish 6185 
    result.write(oprot)
6186 
    oprot.writeMessageEnd()
6187 
    oprot.trans.flush()
6188 
 
4133 chandransh 6189 
  def process_getOrdersInBatch(self, seqid, iprot, oprot):
6190 
    args = getOrdersInBatch_args()
6191 
    args.read(iprot)
6192 
    iprot.readMessageEnd()
6193 
    result = getOrdersInBatch_result()
6194 
    try:
6195 
      result.success = self._handler.getOrdersInBatch(args.statuses, args.offset, args.limit, args.warehouse_id)
6196 
    except TransactionServiceException, ex:
6197 
      result.ex = ex
6198 
    oprot.writeMessageBegin("getOrdersInBatch", TMessageType.REPLY, seqid)
6199 
    result.write(oprot)
6200 
    oprot.writeMessageEnd()
6201 
    oprot.trans.flush()
6202 
 
6203 
  def process_getOrderCount(self, seqid, iprot, oprot):
6204 
    args = getOrderCount_args()
6205 
    args.read(iprot)
6206 
    iprot.readMessageEnd()
6207 
    result = getOrderCount_result()
6208 
    try:
6209 
      result.success = self._handler.getOrderCount(args.statuses, args.warehouseId)
6210 
    except TransactionServiceException, ex:
6211 
      result.ex = ex
6212 
    oprot.writeMessageBegin("getOrderCount", TMessageType.REPLY, seqid)
6213 
    result.write(oprot)
6214 
    oprot.writeMessageEnd()
6215 
    oprot.trans.flush()
6216 
 
999 varun.gupt 6217 
  def process_getOrdersByBillingDate(self, seqid, iprot, oprot):
6218 
    args = getOrdersByBillingDate_args()
6219 
    args.read(iprot)
6220 
    iprot.readMessageEnd()
6221 
    result = getOrdersByBillingDate_result()
6222 
    try:
6223 
      result.success = self._handler.getOrdersByBillingDate(args.status, args.start_billing_date, args.end_billing_date, args.warehouse_id)
6224 
    except TransactionServiceException, ex:
6225 
      result.ex = ex
6226 
    oprot.writeMessageBegin("getOrdersByBillingDate", TMessageType.REPLY, seqid)
6227 
    result.write(oprot)
6228 
    oprot.writeMessageEnd()
6229 
    oprot.trans.flush()
6230 
 
3427 chandransh 6231 
  def process_getOrdersByShippingDate(self, seqid, iprot, oprot):
6232 
    args = getOrdersByShippingDate_args()
6233 
    args.read(iprot)
6234 
    iprot.readMessageEnd()
6235 
    result = getOrdersByShippingDate_result()
6236 
    try:
3451 chandransh 6237 
      result.success = self._handler.getOrdersByShippingDate(args.fromShippingDate, args.toShippingDate, args.providerId, args.warehouseId, args.cod)
3427 chandransh 6238 
    except TransactionServiceException, ex:
6239 
      result.ex = ex
6240 
    oprot.writeMessageBegin("getOrdersByShippingDate", TMessageType.REPLY, seqid)
6241 
    result.write(oprot)
6242 
    oprot.writeMessageEnd()
6243 
    oprot.trans.flush()
6244 
 
1382 varun.gupt 6245 
  def process_getReturnableOrdersForCustomer(self, seqid, iprot, oprot):
6246 
    args = getReturnableOrdersForCustomer_args()
6247 
    args.read(iprot)
6248 
    iprot.readMessageEnd()
6249 
    result = getReturnableOrdersForCustomer_result()
6250 
    try:
6251 
      result.success = self._handler.getReturnableOrdersForCustomer(args.customer_id, args.limit)
6252 
    except TransactionServiceException, ex:
6253 
      result.ex = ex
6254 
    oprot.writeMessageBegin("getReturnableOrdersForCustomer", TMessageType.REPLY, seqid)
6255 
    result.write(oprot)
6256 
    oprot.writeMessageEnd()
6257 
    oprot.trans.flush()
6258 
 
6259 
  def process_getCancellableOrdersForCustomer(self, seqid, iprot, oprot):
6260 
    args = getCancellableOrdersForCustomer_args()
6261 
    args.read(iprot)
6262 
    iprot.readMessageEnd()
6263 
    result = getCancellableOrdersForCustomer_result()
6264 
    try:
6265 
      result.success = self._handler.getCancellableOrdersForCustomer(args.customer_id, args.limit)
6266 
    except TransactionServiceException, ex:
6267 
      result.ex = ex
6268 
    oprot.writeMessageBegin("getCancellableOrdersForCustomer", TMessageType.REPLY, seqid)
6269 
    result.write(oprot)
6270 
    oprot.writeMessageEnd()
6271 
    oprot.trans.flush()
6272 
 
483 rajveer 6273 
  def process_changeOrderStatus(self, seqid, iprot, oprot):
6274 
    args = changeOrderStatus_args()
94 ashish 6275 
    args.read(iprot)
6276 
    iprot.readMessageEnd()
483 rajveer 6277 
    result = changeOrderStatus_result()
94 ashish 6278 
    try:
483 rajveer 6279 
      result.success = self._handler.changeOrderStatus(args.orderId, args.status, args.description)
94 ashish 6280 
    except TransactionServiceException, ex:
6281 
      result.ex = ex
483 rajveer 6282 
    oprot.writeMessageBegin("changeOrderStatus", TMessageType.REPLY, seqid)
94 ashish 6283 
    result.write(oprot)
6284 
    oprot.writeMessageEnd()
6285 
    oprot.trans.flush()
6286 
 
483 rajveer 6287 
  def process_getOrdersForTransaction(self, seqid, iprot, oprot):
6288 
    args = getOrdersForTransaction_args()
94 ashish 6289 
    args.read(iprot)
6290 
    iprot.readMessageEnd()
483 rajveer 6291 
    result = getOrdersForTransaction_result()
94 ashish 6292 
    try:
1528 ankur.sing 6293 
      result.success = self._handler.getOrdersForTransaction(args.transactionId, args.customerId)
94 ashish 6294 
    except TransactionServiceException, ex:
6295 
      result.ex = ex
483 rajveer 6296 
    oprot.writeMessageBegin("getOrdersForTransaction", TMessageType.REPLY, seqid)
94 ashish 6297 
    result.write(oprot)
6298 
    oprot.writeMessageEnd()
6299 
    oprot.trans.flush()
6300 
 
483 rajveer 6301 
  def process_getOrdersForCustomer(self, seqid, iprot, oprot):
6302 
    args = getOrdersForCustomer_args()
94 ashish 6303 
    args.read(iprot)
6304 
    iprot.readMessageEnd()
483 rajveer 6305 
    result = getOrdersForCustomer_result()
94 ashish 6306 
    try:
3014 chandransh 6307 
      result.success = self._handler.getOrdersForCustomer(args.customerId, args.from_date, args.to_date, args.statuses)
94 ashish 6308 
    except TransactionServiceException, ex:
6309 
      result.ex = ex
483 rajveer 6310 
    oprot.writeMessageBegin("getOrdersForCustomer", TMessageType.REPLY, seqid)
94 ashish 6311 
    result.write(oprot)
6312 
    oprot.writeMessageEnd()
6313 
    oprot.trans.flush()
6314 
 
483 rajveer 6315 
  def process_createOrder(self, seqid, iprot, oprot):
6316 
    args = createOrder_args()
94 ashish 6317 
    args.read(iprot)
6318 
    iprot.readMessageEnd()
483 rajveer 6319 
    result = createOrder_result()
94 ashish 6320 
    try:
483 rajveer 6321 
      result.success = self._handler.createOrder(args.order)
94 ashish 6322 
    except TransactionServiceException, ex:
6323 
      result.ex = ex
483 rajveer 6324 
    oprot.writeMessageBegin("createOrder", TMessageType.REPLY, seqid)
94 ashish 6325 
    result.write(oprot)
6326 
    oprot.writeMessageEnd()
6327 
    oprot.trans.flush()
6328 
 
483 rajveer 6329 
  def process_getOrder(self, seqid, iprot, oprot):
6330 
    args = getOrder_args()
94 ashish 6331 
    args.read(iprot)
6332 
    iprot.readMessageEnd()
483 rajveer 6333 
    result = getOrder_result()
94 ashish 6334 
    try:
483 rajveer 6335 
      result.success = self._handler.getOrder(args.id)
94 ashish 6336 
    except TransactionServiceException, ex:
6337 
      result.ex = ex
483 rajveer 6338 
    oprot.writeMessageBegin("getOrder", TMessageType.REPLY, seqid)
94 ashish 6339 
    result.write(oprot)
6340 
    oprot.writeMessageEnd()
6341 
    oprot.trans.flush()
6342 
 
483 rajveer 6343 
  def process_getLineItemsForOrder(self, seqid, iprot, oprot):
6344 
    args = getLineItemsForOrder_args()
94 ashish 6345 
    args.read(iprot)
6346 
    iprot.readMessageEnd()
483 rajveer 6347 
    result = getLineItemsForOrder_result()
94 ashish 6348 
    try:
483 rajveer 6349 
      result.success = self._handler.getLineItemsForOrder(args.orderId)
94 ashish 6350 
    except TransactionServiceException, ex:
6351 
      result.ex = ex
483 rajveer 6352 
    oprot.writeMessageBegin("getLineItemsForOrder", TMessageType.REPLY, seqid)
94 ashish 6353 
    result.write(oprot)
6354 
    oprot.writeMessageEnd()
6355 
    oprot.trans.flush()
6356 
 
4999 phani.kuma 6357 
  def process_getOrderList(self, seqid, iprot, oprot):
6358 
    args = getOrderList_args()
6359 
    args.read(iprot)
6360 
    iprot.readMessageEnd()
6361 
    result = getOrderList_result()
6362 
    result.success = self._handler.getOrderList(args.order_ids)
6363 
    oprot.writeMessageBegin("getOrderList", TMessageType.REPLY, seqid)
6364 
    result.write(oprot)
6365 
    oprot.writeMessageEnd()
6366 
    oprot.trans.flush()
6367 
 
5386 phani.kuma 6368 
  def process_getOrderListForVendor(self, seqid, iprot, oprot):
6369 
    args = getOrderListForVendor_args()
6370 
    args.read(iprot)
6371 
    iprot.readMessageEnd()
6372 
    result = getOrderListForVendor_result()
6373 
    result.success = self._handler.getOrderListForVendor(args.order_ids, args.vendorId)
6374 
    oprot.writeMessageBegin("getOrderListForVendor", TMessageType.REPLY, seqid)
6375 
    result.write(oprot)
6376 
    oprot.writeMessageEnd()
6377 
    oprot.trans.flush()
6378 
 
1528 ankur.sing 6379 
  def process_getOrderForCustomer(self, seqid, iprot, oprot):
6380 
    args = getOrderForCustomer_args()
6381 
    args.read(iprot)
6382 
    iprot.readMessageEnd()
6383 
    result = getOrderForCustomer_result()
6384 
    try:
6385 
      result.success = self._handler.getOrderForCustomer(args.orderId, args.customerId)
6386 
    except TransactionServiceException, ex:
6387 
      result.ex = ex
6388 
    oprot.writeMessageBegin("getOrderForCustomer", TMessageType.REPLY, seqid)
6389 
    result.write(oprot)
6390 
    oprot.writeMessageEnd()
6391 
    oprot.trans.flush()
6392 
 
3064 chandransh 6393 
  def process_getAlerts(self, seqid, iprot, oprot):
6394 
    args = getAlerts_args()
6395 
    args.read(iprot)
6396 
    iprot.readMessageEnd()
6397 
    result = getAlerts_result()
4444 rajveer 6398 
    result.success = self._handler.getAlerts(args.type, args.warehouseId, args.status, args.timestamp)
3064 chandransh 6399 
    oprot.writeMessageBegin("getAlerts", TMessageType.REPLY, seqid)
6400 
    result.write(oprot)
6401 
    oprot.writeMessageEnd()
6402 
    oprot.trans.flush()
6403 
 
4394 rajveer 6404 
  def process_addAlert(self, seqid, iprot, oprot):
6405 
    args = addAlert_args()
3064 chandransh 6406 
    args.read(iprot)
6407 
    iprot.readMessageEnd()
4394 rajveer 6408 
    result = addAlert_result()
4444 rajveer 6409 
    self._handler.addAlert(args.type, args.warehouseId, args.description)
4394 rajveer 6410 
    oprot.writeMessageBegin("addAlert", TMessageType.REPLY, seqid)
3064 chandransh 6411 
    result.write(oprot)
6412 
    oprot.writeMessageEnd()
6413 
    oprot.trans.flush()
6414 
 
4444 rajveer 6415 
  def process_markAlertsAsSeen(self, seqid, iprot, oprot):
6416 
    args = markAlertsAsSeen_args()
6417 
    args.read(iprot)
6418 
    iprot.readMessageEnd()
6419 
    result = markAlertsAsSeen_result()
6420 
    self._handler.markAlertsAsSeen(args.warehouseId)
6421 
    oprot.writeMessageBegin("markAlertsAsSeen", TMessageType.REPLY, seqid)
6422 
    result.write(oprot)
6423 
    oprot.writeMessageEnd()
6424 
    oprot.trans.flush()
6425 
 
3064 chandransh 6426 
  def process_getValidOrderCount(self, seqid, iprot, oprot):
6427 
    args = getValidOrderCount_args()
6428 
    args.read(iprot)
6429 
    iprot.readMessageEnd()
6430 
    result = getValidOrderCount_result()
6431 
    result.success = self._handler.getValidOrderCount()
6432 
    oprot.writeMessageBegin("getValidOrderCount", TMessageType.REPLY, seqid)
6433 
    result.write(oprot)
6434 
    oprot.writeMessageEnd()
6435 
    oprot.trans.flush()
6436 
 
6437 
  def process_getNoOfCustomersWithSuccessfulTransaction(self, seqid, iprot, oprot):
6438 
    args = getNoOfCustomersWithSuccessfulTransaction_args()
6439 
    args.read(iprot)
6440 
    iprot.readMessageEnd()
6441 
    result = getNoOfCustomersWithSuccessfulTransaction_result()
6442 
    result.success = self._handler.getNoOfCustomersWithSuccessfulTransaction()
6443 
    oprot.writeMessageBegin("getNoOfCustomersWithSuccessfulTransaction", TMessageType.REPLY, seqid)
6444 
    result.write(oprot)
6445 
    oprot.writeMessageEnd()
6446 
    oprot.trans.flush()
6447 
 
6448 
  def process_getValidOrdersAmountRange(self, seqid, iprot, oprot):
6449 
    args = getValidOrdersAmountRange_args()
6450 
    args.read(iprot)
6451 
    iprot.readMessageEnd()
6452 
    result = getValidOrdersAmountRange_result()
6453 
    result.success = self._handler.getValidOrdersAmountRange()
6454 
    oprot.writeMessageBegin("getValidOrdersAmountRange", TMessageType.REPLY, seqid)
6455 
    result.write(oprot)
6456 
    oprot.writeMessageEnd()
6457 
    oprot.trans.flush()
6458 
 
6459 
  def process_getValidOrders(self, seqid, iprot, oprot):
6460 
    args = getValidOrders_args()
6461 
    args.read(iprot)
6462 
    iprot.readMessageEnd()
6463 
    result = getValidOrders_result()
5874 rajveer 6464 
    result.success = self._handler.getValidOrders(args.limit, args.onlyStore)
3064 chandransh 6465 
    oprot.writeMessageBegin("getValidOrders", TMessageType.REPLY, seqid)
6466 
    result.write(oprot)
6467 
    oprot.writeMessageEnd()
6468 
    oprot.trans.flush()
6469 
 
1220 chandransh 6470 
  def process_batchOrders(self, seqid, iprot, oprot):
6471 
    args = batchOrders_args()
6472 
    args.read(iprot)
6473 
    iprot.readMessageEnd()
6474 
    result = batchOrders_result()
6475 
    try:
6476 
      result.success = self._handler.batchOrders(args.warehouseId)
6477 
    except TransactionServiceException, ex:
6478 
      result.ex = ex
6479 
    oprot.writeMessageBegin("batchOrders", TMessageType.REPLY, seqid)
6480 
    result.write(oprot)
6481 
    oprot.writeMessageEnd()
6482 
    oprot.trans.flush()
6483 
 
1208 chandransh 6484 
  def process_markOrderAsOutOfStock(self, seqid, iprot, oprot):
6485 
    args = markOrderAsOutOfStock_args()
6486 
    args.read(iprot)
6487 
    iprot.readMessageEnd()
6488 
    result = markOrderAsOutOfStock_result()
6489 
    try:
6490 
      result.success = self._handler.markOrderAsOutOfStock(args.orderId)
6491 
    except TransactionServiceException, ex:
6492 
      result.ex = ex
6493 
    oprot.writeMessageBegin("markOrderAsOutOfStock", TMessageType.REPLY, seqid)
6494 
    result.write(oprot)
6495 
    oprot.writeMessageEnd()
6496 
    oprot.trans.flush()
6497 
 
3064 chandransh 6498 
  def process_verifyOrder(self, seqid, iprot, oprot):
6499 
    args = verifyOrder_args()
759 chandransh 6500 
    args.read(iprot)
6501 
    iprot.readMessageEnd()
3064 chandransh 6502 
    result = verifyOrder_result()
759 chandransh 6503 
    try:
3064 chandransh 6504 
      result.success = self._handler.verifyOrder(args.orderId)
759 chandransh 6505 
    except TransactionServiceException, ex:
6506 
      result.ex = ex
3064 chandransh 6507 
    oprot.writeMessageBegin("verifyOrder", TMessageType.REPLY, seqid)
759 chandransh 6508 
    result.write(oprot)
6509 
    oprot.writeMessageEnd()
6510 
    oprot.trans.flush()
6511 
 
3064 chandransh 6512 
  def process_acceptOrder(self, seqid, iprot, oprot):
6513 
    args = acceptOrder_args()
1113 chandransh 6514 
    args.read(iprot)
6515 
    iprot.readMessageEnd()
3064 chandransh 6516 
    result = acceptOrder_result()
1113 chandransh 6517 
    try:
3064 chandransh 6518 
      result.success = self._handler.acceptOrder(args.orderId)
1113 chandransh 6519 
    except TransactionServiceException, ex:
6520 
      result.ex = ex
3064 chandransh 6521 
    oprot.writeMessageBegin("acceptOrder", TMessageType.REPLY, seqid)
1113 chandransh 6522 
    result.write(oprot)
6523 
    oprot.writeMessageEnd()
6524 
    oprot.trans.flush()
6525 
 
3064 chandransh 6526 
  def process_addBillingDetails(self, seqid, iprot, oprot):
6527 
    args = addBillingDetails_args()
1135 chandransh 6528 
    args.read(iprot)
6529 
    iprot.readMessageEnd()
3064 chandransh 6530 
    result = addBillingDetails_result()
1135 chandransh 6531 
    try:
5110 mandeep.dh 6532 
      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 6533 
    except TransactionServiceException, ex:
6534 
      result.ex = ex
3064 chandransh 6535 
    oprot.writeMessageBegin("addBillingDetails", TMessageType.REPLY, seqid)
1135 chandransh 6536 
    result.write(oprot)
6537 
    oprot.writeMessageEnd()
6538 
    oprot.trans.flush()
6539 
 
4579 rajveer 6540 
  def process_addInvoiceNumber(self, seqid, iprot, oprot):
6541 
    args = addInvoiceNumber_args()
6542 
    args.read(iprot)
6543 
    iprot.readMessageEnd()
6544 
    result = addInvoiceNumber_result()
6545 
    try:
4763 rajveer 6546 
      self._handler.addInvoiceNumber(args.orderId, args.invoiceNumber, args.color)
4579 rajveer 6547 
    except TransactionServiceException, ex:
6548 
      result.ex = ex
6549 
    oprot.writeMessageBegin("addInvoiceNumber", TMessageType.REPLY, seqid)
6550 
    result.write(oprot)
6551 
    oprot.writeMessageEnd()
6552 
    oprot.trans.flush()
6553 
 
4410 rajveer 6554 
  def process_markOrdersAsShippedFromWarehouse(self, seqid, iprot, oprot):
6555 
    args = markOrdersAsShippedFromWarehouse_args()
6556 
    args.read(iprot)
6557 
    iprot.readMessageEnd()
6558 
    result = markOrdersAsShippedFromWarehouse_result()
6559 
    try:
4789 rajveer 6560 
      result.success = self._handler.markOrdersAsShippedFromWarehouse(args.warehouseId, args.providerId, args.cod, args.orderIds)
4410 rajveer 6561 
    except TransactionServiceException, ex:
6562 
      result.ex = ex
6563 
    oprot.writeMessageBegin("markOrdersAsShippedFromWarehouse", TMessageType.REPLY, seqid)
6564 
    result.write(oprot)
6565 
    oprot.writeMessageEnd()
6566 
    oprot.trans.flush()
6567 
 
5676 rajveer 6568 
  def process_markOrdersAsReturnedFromStore(self, seqid, iprot, oprot):
6569 
    args = markOrdersAsReturnedFromStore_args()
6570 
    args.read(iprot)
6571 
    iprot.readMessageEnd()
6572 
    result = markOrdersAsReturnedFromStore_result()
6573 
    try:
5713 rajveer 6574 
      result.success = self._handler.markOrdersAsReturnedFromStore(args.providerId, args.orderIds, args.awbs)
5676 rajveer 6575 
    except TransactionServiceException, ex:
6576 
      result.ex = ex
6577 
    oprot.writeMessageBegin("markOrdersAsReturnedFromStore", TMessageType.REPLY, seqid)
6578 
    result.write(oprot)
6579 
    oprot.writeMessageEnd()
6580 
    oprot.trans.flush()
6581 
 
3064 chandransh 6582 
  def process_markOrdersAsPickedUp(self, seqid, iprot, oprot):
6583 
    args = markOrdersAsPickedUp_args()
304 ashish 6584 
    args.read(iprot)
6585 
    iprot.readMessageEnd()
3064 chandransh 6586 
    result = markOrdersAsPickedUp_result()
6587 
    try:
4910 phani.kuma 6588 
      self._handler.markOrdersAsPickedUp(args.providerId, args.pickupDetails)
3064 chandransh 6589 
    except TransactionServiceException, ex:
6590 
      result.ex = ex
6591 
    oprot.writeMessageBegin("markOrdersAsPickedUp", TMessageType.REPLY, seqid)
304 ashish 6592 
    result.write(oprot)
6593 
    oprot.writeMessageEnd()
6594 
    oprot.trans.flush()
94 ashish 6595 
 
4910 phani.kuma 6596 
  def process_getOrdersNotPickedUp(self, seqid, iprot, oprot):
6597 
    args = getOrdersNotPickedUp_args()
6598 
    args.read(iprot)
6599 
    iprot.readMessageEnd()
6600 
    result = getOrdersNotPickedUp_result()
6601 
    result.success = self._handler.getOrdersNotPickedUp(args.providerId)
6602 
    oprot.writeMessageBegin("getOrdersNotPickedUp", TMessageType.REPLY, seqid)
6603 
    result.write(oprot)
6604 
    oprot.writeMessageEnd()
6605 
    oprot.trans.flush()
6606 
 
3064 chandransh 6607 
  def process_markOrdersAsDelivered(self, seqid, iprot, oprot):
6608 
    args = markOrdersAsDelivered_args()
304 ashish 6609 
    args.read(iprot)
6610 
    iprot.readMessageEnd()
3064 chandransh 6611 
    result = markOrdersAsDelivered_result()
6612 
    try:
6613 
      self._handler.markOrdersAsDelivered(args.providerId, args.deliveredOrders)
6614 
    except TransactionServiceException, ex:
6615 
      result.ex = ex
6616 
    oprot.writeMessageBegin("markOrdersAsDelivered", TMessageType.REPLY, seqid)
304 ashish 6617 
    result.write(oprot)
6618 
    oprot.writeMessageEnd()
6619 
    oprot.trans.flush()
6620 
 
4910 phani.kuma 6621 
  def process_markAsRTOrders(self, seqid, iprot, oprot):
6622 
    args = markAsRTOrders_args()
1596 ankur.sing 6623 
    args.read(iprot)
6624 
    iprot.readMessageEnd()
4910 phani.kuma 6625 
    result = markAsRTOrders_result()
3064 chandransh 6626 
    try:
4910 phani.kuma 6627 
      self._handler.markAsRTOrders(args.providerId, args.returnedOrders)
3064 chandransh 6628 
    except TransactionServiceException, ex:
6629 
      result.ex = ex
4910 phani.kuma 6630 
    oprot.writeMessageBegin("markAsRTOrders", TMessageType.REPLY, seqid)
1596 ankur.sing 6631 
    result.write(oprot)
6632 
    oprot.writeMessageEnd()
6633 
    oprot.trans.flush()
304 ashish 6634 
 
4910 phani.kuma 6635 
  def process_getRTOrders(self, seqid, iprot, oprot):
6636 
    args = getRTOrders_args()
6637 
    args.read(iprot)
6638 
    iprot.readMessageEnd()
6639 
    result = getRTOrders_result()
6640 
    result.success = self._handler.getRTOrders(args.providerId)
6641 
    oprot.writeMessageBegin("getRTOrders", TMessageType.REPLY, seqid)
6642 
    result.write(oprot)
6643 
    oprot.writeMessageEnd()
6644 
    oprot.trans.flush()
6645 
 
3064 chandransh 6646 
  def process_updateNonDeliveryReason(self, seqid, iprot, oprot):
6647 
    args = updateNonDeliveryReason_args()
1627 ankur.sing 6648 
    args.read(iprot)
6649 
    iprot.readMessageEnd()
3064 chandransh 6650 
    result = updateNonDeliveryReason_result()
6651 
    try:
4910 phani.kuma 6652 
      self._handler.updateNonDeliveryReason(args.providerId, args.undeliveredOrders)
3064 chandransh 6653 
    except TransactionServiceException, ex:
6654 
      result.ex = ex
6655 
    oprot.writeMessageBegin("updateNonDeliveryReason", TMessageType.REPLY, seqid)
1627 ankur.sing 6656 
    result.write(oprot)
6657 
    oprot.writeMessageEnd()
6658 
    oprot.trans.flush()
1596 ankur.sing 6659 
 
4910 phani.kuma 6660 
  def process_getNonDeliveredOrdersbyCourier(self, seqid, iprot, oprot):
6661 
    args = getNonDeliveredOrdersbyCourier_args()
6662 
    args.read(iprot)
6663 
    iprot.readMessageEnd()
6664 
    result = getNonDeliveredOrdersbyCourier_result()
6665 
    result.success = self._handler.getNonDeliveredOrdersbyCourier(args.providerId)
6666 
    oprot.writeMessageBegin("getNonDeliveredOrdersbyCourier", TMessageType.REPLY, seqid)
6667 
    result.write(oprot)
6668 
    oprot.writeMessageEnd()
6669 
    oprot.trans.flush()
6670 
 
6671 
  def process_markOrdersAsLocalConnected(self, seqid, iprot, oprot):
6672 
    args = markOrdersAsLocalConnected_args()
6673 
    args.read(iprot)
6674 
    iprot.readMessageEnd()
6675 
    result = markOrdersAsLocalConnected_result()
6676 
    try:
6677 
      self._handler.markOrdersAsLocalConnected(args.providerId, args.local_connected_orders)
6678 
    except TransactionServiceException, ex:
6679 
      result.ex = ex
6680 
    oprot.writeMessageBegin("markOrdersAsLocalConnected", TMessageType.REPLY, seqid)
6681 
    result.write(oprot)
6682 
    oprot.writeMessageEnd()
6683 
    oprot.trans.flush()
6684 
 
6685 
  def process_getOrdersNotLocalConnected(self, seqid, iprot, oprot):
6686 
    args = getOrdersNotLocalConnected_args()
6687 
    args.read(iprot)
6688 
    iprot.readMessageEnd()
6689 
    result = getOrdersNotLocalConnected_result()
6690 
    result.success = self._handler.getOrdersNotLocalConnected(args.providerId)
6691 
    oprot.writeMessageBegin("getOrdersNotLocalConnected", TMessageType.REPLY, seqid)
6692 
    result.write(oprot)
6693 
    oprot.writeMessageEnd()
6694 
    oprot.trans.flush()
6695 
 
6696 
  def process_markOrdersAsDestinationCityReached(self, seqid, iprot, oprot):
6697 
    args = markOrdersAsDestinationCityReached_args()
6698 
    args.read(iprot)
6699 
    iprot.readMessageEnd()
6700 
    result = markOrdersAsDestinationCityReached_result()
6701 
    try:
6702 
      self._handler.markOrdersAsDestinationCityReached(args.providerId, args.destination_city_reached_orders)
6703 
    except TransactionServiceException, ex:
6704 
      result.ex = ex
6705 
    oprot.writeMessageBegin("markOrdersAsDestinationCityReached", TMessageType.REPLY, seqid)
6706 
    result.write(oprot)
6707 
    oprot.writeMessageEnd()
6708 
    oprot.trans.flush()
6709 
 
6710 
  def process_markOrdersAsFirstDeliveryAttempted(self, seqid, iprot, oprot):
6711 
    args = markOrdersAsFirstDeliveryAttempted_args()
6712 
    args.read(iprot)
6713 
    iprot.readMessageEnd()
6714 
    result = markOrdersAsFirstDeliveryAttempted_result()
6715 
    try:
6716 
      self._handler.markOrdersAsFirstDeliveryAttempted(args.providerId, args.first_atdl_orders)
6717 
    except TransactionServiceException, ex:
6718 
      result.ex = ex
6719 
    oprot.writeMessageBegin("markOrdersAsFirstDeliveryAttempted", TMessageType.REPLY, seqid)
6720 
    result.write(oprot)
6721 
    oprot.writeMessageEnd()
6722 
    oprot.trans.flush()
6723 
 
3064 chandransh 6724 
  def process_getUndeliveredOrders(self, seqid, iprot, oprot):
6725 
    args = getUndeliveredOrders_args()
1627 ankur.sing 6726 
    args.read(iprot)
6727 
    iprot.readMessageEnd()
3064 chandransh 6728 
    result = getUndeliveredOrders_result()
6729 
    result.success = self._handler.getUndeliveredOrders(args.providerId, args.warehouseId)
6730 
    oprot.writeMessageBegin("getUndeliveredOrders", TMessageType.REPLY, seqid)
1627 ankur.sing 6731 
    result.write(oprot)
6732 
    oprot.writeMessageEnd()
6733 
    oprot.trans.flush()
6734 
 
4783 phani.kuma 6735 
  def process_getUndeliveredOrdersExpectedDeliveryDateNotMet(self, seqid, iprot, oprot):
6736 
    args = getUndeliveredOrdersExpectedDeliveryDateNotMet_args()
6737 
    args.read(iprot)
6738 
    iprot.readMessageEnd()
6739 
    result = getUndeliveredOrdersExpectedDeliveryDateNotMet_result()
6740 
    result.success = self._handler.getUndeliveredOrdersExpectedDeliveryDateNotMet()
6741 
    oprot.writeMessageBegin("getUndeliveredOrdersExpectedDeliveryDateNotMet", TMessageType.REPLY, seqid)
6742 
    result.write(oprot)
6743 
    oprot.writeMessageEnd()
6744 
    oprot.trans.flush()
6745 
 
2536 chandransh 6746 
  def process_toggleDOAFlag(self, seqid, iprot, oprot):
6747 
    args = toggleDOAFlag_args()
6748 
    args.read(iprot)
6749 
    iprot.readMessageEnd()
6750 
    result = toggleDOAFlag_result()
6751 
    try:
6752 
      result.success = self._handler.toggleDOAFlag(args.orderId)
6753 
    except TransactionServiceException, ex:
6754 
      result.ex = ex
6755 
    oprot.writeMessageBegin("toggleDOAFlag", TMessageType.REPLY, seqid)
6756 
    result.write(oprot)
6757 
    oprot.writeMessageEnd()
6758 
    oprot.trans.flush()
1886 ankur.sing 6759 
 
4712 rajveer 6760 
  def process_markOrderAsDelivered(self, seqid, iprot, oprot):
6761 
    args = markOrderAsDelivered_args()
6762 
    args.read(iprot)
6763 
    iprot.readMessageEnd()
6764 
    result = markOrderAsDelivered_result()
6765 
    try:
6766 
      self._handler.markOrderAsDelivered(args.orderId, args.deliveryTimestamp, args.receiver)
6767 
    except TransactionServiceException, ex:
6768 
      result.ex = ex
6769 
    oprot.writeMessageBegin("markOrderAsDelivered", TMessageType.REPLY, seqid)
6770 
    result.write(oprot)
6771 
    oprot.writeMessageEnd()
6772 
    oprot.trans.flush()
6773 
 
5553 rajveer 6774 
  def process_markOrderAsReceivedAtStore(self, seqid, iprot, oprot):
6775 
    args = markOrderAsReceivedAtStore_args()
6776 
    args.read(iprot)
6777 
    iprot.readMessageEnd()
6778 
    result = markOrderAsReceivedAtStore_result()
6779 
    try:
6780 
      self._handler.markOrderAsReceivedAtStore(args.orderId, args.deliveryTimestamp)
6781 
    except TransactionServiceException, ex:
6782 
      result.ex = ex
6783 
    oprot.writeMessageBegin("markOrderAsReceivedAtStore", TMessageType.REPLY, seqid)
6784 
    result.write(oprot)
6785 
    oprot.writeMessageEnd()
6786 
    oprot.trans.flush()
6787 
 
4454 rajveer 6788 
  def process_markOrderDoaRequestReceived(self, seqid, iprot, oprot):
6789 
    args = markOrderDoaRequestReceived_args()
6790 
    args.read(iprot)
6791 
    iprot.readMessageEnd()
6792 
    result = markOrderDoaRequestReceived_result()
6793 
    try:
6794 
      result.success = self._handler.markOrderDoaRequestReceived(args.orderId)
6795 
    except TransactionServiceException, ex:
6796 
      result.ex = ex
6797 
    oprot.writeMessageBegin("markOrderDoaRequestReceived", TMessageType.REPLY, seqid)
6798 
    result.write(oprot)
6799 
    oprot.writeMessageEnd()
6800 
    oprot.trans.flush()
6801 
 
6802 
  def process_markOrderDoaRequestAuthorized(self, seqid, iprot, oprot):
6803 
    args = markOrderDoaRequestAuthorized_args()
6804 
    args.read(iprot)
6805 
    iprot.readMessageEnd()
6806 
    result = markOrderDoaRequestAuthorized_result()
6807 
    try:
6808 
      result.success = self._handler.markOrderDoaRequestAuthorized(args.orderId, args.isAuthorized)
6809 
    except TransactionServiceException, ex:
6810 
      result.ex = ex
6811 
    oprot.writeMessageBegin("markOrderDoaRequestAuthorized", TMessageType.REPLY, seqid)
6812 
    result.write(oprot)
6813 
    oprot.writeMessageEnd()
6814 
    oprot.trans.flush()
6815 
 
4488 rajveer 6816 
  def process_markOrderReturnRequestReceived(self, seqid, iprot, oprot):
6817 
    args = markOrderReturnRequestReceived_args()
6818 
    args.read(iprot)
6819 
    iprot.readMessageEnd()
6820 
    result = markOrderReturnRequestReceived_result()
6821 
    try:
6822 
      result.success = self._handler.markOrderReturnRequestReceived(args.orderId)
6823 
    except TransactionServiceException, ex:
6824 
      result.ex = ex
6825 
    oprot.writeMessageBegin("markOrderReturnRequestReceived", TMessageType.REPLY, seqid)
6826 
    result.write(oprot)
6827 
    oprot.writeMessageEnd()
6828 
    oprot.trans.flush()
6829 
 
6830 
  def process_markOrderReturnRequestAuthorized(self, seqid, iprot, oprot):
6831 
    args = markOrderReturnRequestAuthorized_args()
6832 
    args.read(iprot)
6833 
    iprot.readMessageEnd()
6834 
    result = markOrderReturnRequestAuthorized_result()
6835 
    try:
6836 
      result.success = self._handler.markOrderReturnRequestAuthorized(args.orderId, args.isAuthorized)
6837 
    except TransactionServiceException, ex:
6838 
      result.ex = ex
6839 
    oprot.writeMessageBegin("markOrderReturnRequestAuthorized", TMessageType.REPLY, seqid)
6840 
    result.write(oprot)
6841 
    oprot.writeMessageEnd()
6842 
    oprot.trans.flush()
6843 
 
2536 chandransh 6844 
  def process_requestPickupNumber(self, seqid, iprot, oprot):
6845 
    args = requestPickupNumber_args()
6846 
    args.read(iprot)
6847 
    iprot.readMessageEnd()
6848 
    result = requestPickupNumber_result()
6849 
    try:
4579 rajveer 6850 
      result.success = self._handler.requestPickupNumber(args.orderId, args.providerId)
2536 chandransh 6851 
    except TransactionServiceException, ex:
6852 
      result.ex = ex
6853 
    oprot.writeMessageBegin("requestPickupNumber", TMessageType.REPLY, seqid)
6854 
    result.write(oprot)
6855 
    oprot.writeMessageEnd()
6856 
    oprot.trans.flush()
6857 
 
6858 
  def process_authorizePickup(self, seqid, iprot, oprot):
6859 
    args = authorizePickup_args()
6860 
    args.read(iprot)
6861 
    iprot.readMessageEnd()
6862 
    result = authorizePickup_result()
6863 
    try:
4602 rajveer 6864 
      result.success = self._handler.authorizePickup(args.orderId, args.pickupNumber, args.providerId)
2536 chandransh 6865 
    except TransactionServiceException, ex:
6866 
      result.ex = ex
6867 
    oprot.writeMessageBegin("authorizePickup", TMessageType.REPLY, seqid)
6868 
    result.write(oprot)
6869 
    oprot.writeMessageEnd()
6870 
    oprot.trans.flush()
6871 
 
2764 chandransh 6872 
  def process_markDoasAsPickedUp(self, seqid, iprot, oprot):
6873 
    args = markDoasAsPickedUp_args()
6874 
    args.read(iprot)
6875 
    iprot.readMessageEnd()
6876 
    result = markDoasAsPickedUp_result()
4910 phani.kuma 6877 
    self._handler.markDoasAsPickedUp(args.providerId, args.pickupDetails)
2764 chandransh 6878 
    oprot.writeMessageBegin("markDoasAsPickedUp", TMessageType.REPLY, seqid)
6879 
    result.write(oprot)
6880 
    oprot.writeMessageEnd()
6881 
    oprot.trans.flush()
6882 
 
4910 phani.kuma 6883 
  def process_getDoasNotPickedUp(self, seqid, iprot, oprot):
6884 
    args = getDoasNotPickedUp_args()
6885 
    args.read(iprot)
6886 
    iprot.readMessageEnd()
6887 
    result = getDoasNotPickedUp_result()
6888 
    result.success = self._handler.getDoasNotPickedUp(args.providerId)
6889 
    oprot.writeMessageBegin("getDoasNotPickedUp", TMessageType.REPLY, seqid)
6890 
    result.write(oprot)
6891 
    oprot.writeMessageEnd()
6892 
    oprot.trans.flush()
6893 
 
4741 phani.kuma 6894 
  def process_markReturnOrdersAsPickedUp(self, seqid, iprot, oprot):
6895 
    args = markReturnOrdersAsPickedUp_args()
6896 
    args.read(iprot)
6897 
    iprot.readMessageEnd()
6898 
    result = markReturnOrdersAsPickedUp_result()
4910 phani.kuma 6899 
    self._handler.markReturnOrdersAsPickedUp(args.providerId, args.pickupDetails)
4741 phani.kuma 6900 
    oprot.writeMessageBegin("markReturnOrdersAsPickedUp", TMessageType.REPLY, seqid)
6901 
    result.write(oprot)
6902 
    oprot.writeMessageEnd()
6903 
    oprot.trans.flush()
6904 
 
4910 phani.kuma 6905 
  def process_getReturnOrdersNotPickedUp(self, seqid, iprot, oprot):
6906 
    args = getReturnOrdersNotPickedUp_args()
6907 
    args.read(iprot)
6908 
    iprot.readMessageEnd()
6909 
    result = getReturnOrdersNotPickedUp_result()
6910 
    result.success = self._handler.getReturnOrdersNotPickedUp(args.providerId)
6911 
    oprot.writeMessageBegin("getReturnOrdersNotPickedUp", TMessageType.REPLY, seqid)
6912 
    result.write(oprot)
6913 
    oprot.writeMessageEnd()
6914 
    oprot.trans.flush()
6915 
 
2616 chandransh 6916 
  def process_receiveReturn(self, seqid, iprot, oprot):
6917 
    args = receiveReturn_args()
2591 chandransh 6918 
    args.read(iprot)
6919 
    iprot.readMessageEnd()
2616 chandransh 6920 
    result = receiveReturn_result()
2591 chandransh 6921 
    try:
4479 rajveer 6922 
      result.success = self._handler.receiveReturn(args.orderId, args.receiveCondition)
2591 chandransh 6923 
    except TransactionServiceException, ex:
6924 
      result.ex = ex
2616 chandransh 6925 
    oprot.writeMessageBegin("receiveReturn", TMessageType.REPLY, seqid)
2591 chandransh 6926 
    result.write(oprot)
6927 
    oprot.writeMessageEnd()
6928 
    oprot.trans.flush()
2536 chandransh 6929 
 
2591 chandransh 6930 
  def process_validateDoa(self, seqid, iprot, oprot):
6931 
    args = validateDoa_args()
6932 
    args.read(iprot)
6933 
    iprot.readMessageEnd()
6934 
    result = validateDoa_result()
6935 
    try:
6936 
      result.success = self._handler.validateDoa(args.orderId, args.isValid)
6937 
    except TransactionServiceException, ex:
6938 
      result.ex = ex
6939 
    oprot.writeMessageBegin("validateDoa", TMessageType.REPLY, seqid)
6940 
    result.write(oprot)
6941 
    oprot.writeMessageEnd()
6942 
    oprot.trans.flush()
6943 
 
4495 rajveer 6944 
  def process_validateReturnProduct(self, seqid, iprot, oprot):
6945 
    args = validateReturnProduct_args()
6946 
    args.read(iprot)
6947 
    iprot.readMessageEnd()
6948 
    result = validateReturnProduct_result()
6949 
    try:
6950 
      result.success = self._handler.validateReturnProduct(args.orderId, args.isUsable)
6951 
    except TransactionServiceException, ex:
6952 
      result.ex = ex
6953 
    oprot.writeMessageBegin("validateReturnProduct", TMessageType.REPLY, seqid)
6954 
    result.write(oprot)
6955 
    oprot.writeMessageEnd()
6956 
    oprot.trans.flush()
6957 
 
2616 chandransh 6958 
  def process_reshipOrder(self, seqid, iprot, oprot):
6959 
    args = reshipOrder_args()
6960 
    args.read(iprot)
6961 
    iprot.readMessageEnd()
6962 
    result = reshipOrder_result()
6963 
    try:
6964 
      result.success = self._handler.reshipOrder(args.orderId)
6965 
    except TransactionServiceException, ex:
6966 
      result.ex = ex
6967 
    oprot.writeMessageBegin("reshipOrder", TMessageType.REPLY, seqid)
6968 
    result.write(oprot)
6969 
    oprot.writeMessageEnd()
6970 
    oprot.trans.flush()
2591 chandransh 6971 
 
2616 chandransh 6972 
  def process_refundOrder(self, seqid, iprot, oprot):
6973 
    args = refundOrder_args()
6974 
    args.read(iprot)
6975 
    iprot.readMessageEnd()
6976 
    result = refundOrder_result()
6977 
    try:
3226 chandransh 6978 
      result.success = self._handler.refundOrder(args.orderId, args.refundedBy, args.reason)
2616 chandransh 6979 
    except TransactionServiceException, ex:
6980 
      result.ex = ex
6981 
    oprot.writeMessageBegin("refundOrder", TMessageType.REPLY, seqid)
6982 
    result.write(oprot)
6983 
    oprot.writeMessageEnd()
6984 
    oprot.trans.flush()
6985 
 
2690 chandransh 6986 
  def process_getReturnOrders(self, seqid, iprot, oprot):
6987 
    args = getReturnOrders_args()
6988 
    args.read(iprot)
6989 
    iprot.readMessageEnd()
6990 
    result = getReturnOrders_result()
6991 
    result.success = self._handler.getReturnOrders(args.warehouseId, args.fromDate, args.toDate)
6992 
    oprot.writeMessageBegin("getReturnOrders", TMessageType.REPLY, seqid)
6993 
    result.write(oprot)
6994 
    oprot.writeMessageEnd()
6995 
    oprot.trans.flush()
2616 chandransh 6996 
 
5481 phani.kuma 6997 
  def process_getAllReturnOrders(self, seqid, iprot, oprot):
6998 
    args = getAllReturnOrders_args()
6999 
    args.read(iprot)
7000 
    iprot.readMessageEnd()
7001 
    result = getAllReturnOrders_result()
7002 
    result.success = self._handler.getAllReturnOrders(args.onlyNotProcessed, args.fromDate, args.toDate)
7003 
    oprot.writeMessageBegin("getAllReturnOrders", TMessageType.REPLY, seqid)
7004 
    result.write(oprot)
7005 
    oprot.writeMessageEnd()
7006 
    oprot.trans.flush()
7007 
 
2700 chandransh 7008 
  def process_getReturnOrder(self, seqid, iprot, oprot):
7009 
    args = getReturnOrder_args()
7010 
    args.read(iprot)
7011 
    iprot.readMessageEnd()
7012 
    result = getReturnOrder_result()
7013 
    try:
7014 
      result.success = self._handler.getReturnOrder(args.id)
7015 
    except TransactionServiceException, ex:
7016 
      result.ex = ex
7017 
    oprot.writeMessageBegin("getReturnOrder", TMessageType.REPLY, seqid)
7018 
    result.write(oprot)
7019 
    oprot.writeMessageEnd()
7020 
    oprot.trans.flush()
7021 
 
2690 chandransh 7022 
  def process_processReturn(self, seqid, iprot, oprot):
7023 
    args = processReturn_args()
7024 
    args.read(iprot)
7025 
    iprot.readMessageEnd()
7026 
    result = processReturn_result()
7027 
    try:
7028 
      self._handler.processReturn(args.returnOrderId)
7029 
    except TransactionServiceException, ex:
7030 
      result.ex = ex
7031 
    oprot.writeMessageBegin("processReturn", TMessageType.REPLY, seqid)
7032 
    result.write(oprot)
7033 
    oprot.writeMessageEnd()
7034 
    oprot.trans.flush()
7035 
 
3451 chandransh 7036 
  def process_updateWeight(self, seqid, iprot, oprot):
7037 
    args = updateWeight_args()
7038 
    args.read(iprot)
7039 
    iprot.readMessageEnd()
7040 
    result = updateWeight_result()
7041 
    try:
7042 
      result.success = self._handler.updateWeight(args.orderId, args.weight)
7043 
    except TransactionServiceException, ex:
7044 
      result.ex = ex
7045 
    oprot.writeMessageBegin("updateWeight", TMessageType.REPLY, seqid)
7046 
    result.write(oprot)
7047 
    oprot.writeMessageEnd()
7048 
    oprot.trans.flush()
2819 chandransh 7049 
 
3469 chandransh 7050 
  def process_changeItem(self, seqid, iprot, oprot):
7051 
    args = changeItem_args()
7052 
    args.read(iprot)
7053 
    iprot.readMessageEnd()
7054 
    result = changeItem_result()
7055 
    try:
7056 
      result.success = self._handler.changeItem(args.orderId, args.itemId)
7057 
    except TransactionServiceException, ex:
7058 
      result.ex = ex
7059 
    oprot.writeMessageBegin("changeItem", TMessageType.REPLY, seqid)
7060 
    result.write(oprot)
7061 
    oprot.writeMessageEnd()
7062 
    oprot.trans.flush()
3451 chandransh 7063 
 
3469 chandransh 7064 
  def process_shiftToWarehouse(self, seqid, iprot, oprot):
7065 
    args = shiftToWarehouse_args()
7066 
    args.read(iprot)
7067 
    iprot.readMessageEnd()
7068 
    result = shiftToWarehouse_result()
7069 
    try:
7070 
      result.success = self._handler.shiftToWarehouse(args.orderId, args.warehouseId)
7071 
    except TransactionServiceException, ex:
7072 
      result.ex = ex
7073 
    oprot.writeMessageBegin("shiftToWarehouse", TMessageType.REPLY, seqid)
7074 
    result.write(oprot)
7075 
    oprot.writeMessageEnd()
7076 
    oprot.trans.flush()
7077 
 
3553 chandransh 7078 
  def process_addDelayReason(self, seqid, iprot, oprot):
7079 
    args = addDelayReason_args()
7080 
    args.read(iprot)
7081 
    iprot.readMessageEnd()
7082 
    result = addDelayReason_result()
7083 
    try:
4647 rajveer 7084 
      result.success = self._handler.addDelayReason(args.orderId, args.delayReason, args.furtherDelay, args.delayReasonText)
3553 chandransh 7085 
    except TransactionServiceException, ex:
7086 
      result.ex = ex
7087 
    oprot.writeMessageBegin("addDelayReason", TMessageType.REPLY, seqid)
7088 
    result.write(oprot)
7089 
    oprot.writeMessageEnd()
7090 
    oprot.trans.flush()
3469 chandransh 7091 
 
3956 chandransh 7092 
  def process_reconcileCodCollection(self, seqid, iprot, oprot):
7093 
    args = reconcileCodCollection_args()
7094 
    args.read(iprot)
7095 
    iprot.readMessageEnd()
7096 
    result = reconcileCodCollection_result()
7097 
    try:
7098 
      result.success = self._handler.reconcileCodCollection(args.collectedAmountMap, args.xferBy, args.xferTxnId, args.xferDate)
7099 
    except TransactionServiceException, ex:
7100 
      result.ex = ex
7101 
    oprot.writeMessageBegin("reconcileCodCollection", TMessageType.REPLY, seqid)
7102 
    result.write(oprot)
7103 
    oprot.writeMessageEnd()
7104 
    oprot.trans.flush()
3553 chandransh 7105 
 
4008 mandeep.dh 7106 
  def process_getTransactionsRequiringExtraProcessing(self, seqid, iprot, oprot):
7107 
    args = getTransactionsRequiringExtraProcessing_args()
7108 
    args.read(iprot)
7109 
    iprot.readMessageEnd()
7110 
    result = getTransactionsRequiringExtraProcessing_result()
7111 
    result.success = self._handler.getTransactionsRequiringExtraProcessing(args.category)
7112 
    oprot.writeMessageBegin("getTransactionsRequiringExtraProcessing", TMessageType.REPLY, seqid)
7113 
    result.write(oprot)
7114 
    oprot.writeMessageEnd()
7115 
    oprot.trans.flush()
3956 chandransh 7116 
 
4008 mandeep.dh 7117 
  def process_markTransactionAsProcessed(self, seqid, iprot, oprot):
7118 
    args = markTransactionAsProcessed_args()
7119 
    args.read(iprot)
7120 
    iprot.readMessageEnd()
7121 
    result = markTransactionAsProcessed_result()
7122 
    self._handler.markTransactionAsProcessed(args.transactionId, args.category)
7123 
    oprot.writeMessageBegin("markTransactionAsProcessed", TMessageType.REPLY, seqid)
7124 
    result.write(oprot)
7125 
    oprot.writeMessageEnd()
7126 
    oprot.trans.flush()
7127 
 
4018 chandransh 7128 
  def process_getItemWiseRiskyOrdersCount(self, seqid, iprot, oprot):
7129 
    args = getItemWiseRiskyOrdersCount_args()
7130 
    args.read(iprot)
7131 
    iprot.readMessageEnd()
7132 
    result = getItemWiseRiskyOrdersCount_result()
7133 
    result.success = self._handler.getItemWiseRiskyOrdersCount()
7134 
    oprot.writeMessageBegin("getItemWiseRiskyOrdersCount", TMessageType.REPLY, seqid)
7135 
    result.write(oprot)
7136 
    oprot.writeMessageEnd()
7137 
    oprot.trans.flush()
4008 mandeep.dh 7138 
 
4295 varun.gupt 7139 
  def process_getOrdersForItemIds(self, seqid, iprot, oprot):
7140 
    args = getOrdersForItemIds_args()
7141 
    args.read(iprot)
7142 
    iprot.readMessageEnd()
7143 
    result = getOrdersForItemIds_result()
7144 
    result.success = self._handler.getOrdersForItemIds(args.itemIds)
7145 
    oprot.writeMessageBegin("getOrdersForItemIds", TMessageType.REPLY, seqid)
7146 
    result.write(oprot)
7147 
    oprot.writeMessageEnd()
7148 
    oprot.trans.flush()
7149 
 
4247 rajveer 7150 
  def process_markOrderCancellationRequestReceived(self, seqid, iprot, oprot):
7151 
    args = markOrderCancellationRequestReceived_args()
7152 
    args.read(iprot)
7153 
    iprot.readMessageEnd()
7154 
    result = markOrderCancellationRequestReceived_result()
7155 
    try:
7156 
      self._handler.markOrderCancellationRequestReceived(args.orderId)
7157 
    except TransactionServiceException, ex:
7158 
      result.ex = ex
7159 
    oprot.writeMessageBegin("markOrderCancellationRequestReceived", TMessageType.REPLY, seqid)
7160 
    result.write(oprot)
7161 
    oprot.writeMessageEnd()
7162 
    oprot.trans.flush()
4018 chandransh 7163 
 
4247 rajveer 7164 
  def process_markOrderCancellationRequestConfirmed(self, seqid, iprot, oprot):
7165 
    args = markOrderCancellationRequestConfirmed_args()
7166 
    args.read(iprot)
7167 
    iprot.readMessageEnd()
7168 
    result = markOrderCancellationRequestConfirmed_result()
7169 
    try:
7170 
      self._handler.markOrderCancellationRequestConfirmed(args.orderId)
7171 
    except TransactionServiceException, ex:
7172 
      result.ex = ex
7173 
    oprot.writeMessageBegin("markOrderCancellationRequestConfirmed", TMessageType.REPLY, seqid)
7174 
    result.write(oprot)
7175 
    oprot.writeMessageEnd()
7176 
    oprot.trans.flush()
7177 
 
7178 
  def process_markOrderCancellationRequestDenied(self, seqid, iprot, oprot):
7179 
    args = markOrderCancellationRequestDenied_args()
7180 
    args.read(iprot)
7181 
    iprot.readMessageEnd()
7182 
    result = markOrderCancellationRequestDenied_result()
7183 
    try:
7184 
      self._handler.markOrderCancellationRequestDenied(args.orderId)
7185 
    except TransactionServiceException, ex:
7186 
      result.ex = ex
7187 
    oprot.writeMessageBegin("markOrderCancellationRequestDenied", TMessageType.REPLY, seqid)
7188 
    result.write(oprot)
7189 
    oprot.writeMessageEnd()
7190 
    oprot.trans.flush()
7191 
 
4258 rajveer 7192 
  def process_markTransactionAsPaymentFlagRemoved(self, seqid, iprot, oprot):
7193 
    args = markTransactionAsPaymentFlagRemoved_args()
4247 rajveer 7194 
    args.read(iprot)
7195 
    iprot.readMessageEnd()
4258 rajveer 7196 
    result = markTransactionAsPaymentFlagRemoved_result()
4247 rajveer 7197 
    try:
4258 rajveer 7198 
      self._handler.markTransactionAsPaymentFlagRemoved(args.transactionId)
4247 rajveer 7199 
    except TransactionServiceException, ex:
7200 
      result.ex = ex
4258 rajveer 7201 
    oprot.writeMessageBegin("markTransactionAsPaymentFlagRemoved", TMessageType.REPLY, seqid)
4247 rajveer 7202 
    result.write(oprot)
7203 
    oprot.writeMessageEnd()
7204 
    oprot.trans.flush()
7205 
 
4259 anupam.sin 7206 
  def process_refundTransaction(self, seqid, iprot, oprot):
7207 
    args = refundTransaction_args()
7208 
    args.read(iprot)
7209 
    iprot.readMessageEnd()
7210 
    result = refundTransaction_result()
7211 
    try:
7212 
      self._handler.refundTransaction(args.transactionId, args.refundedBy, args.reason)
7213 
    except TransactionServiceException, ex:
7214 
      result.ex = ex
7215 
    oprot.writeMessageBegin("refundTransaction", TMessageType.REPLY, seqid)
7216 
    result.write(oprot)
7217 
    oprot.writeMessageEnd()
7218 
    oprot.trans.flush()
4247 rajveer 7219 
 
4324 mandeep.dh 7220 
  def process_updateShipmentAddress(self, seqid, iprot, oprot):
7221 
    args = updateShipmentAddress_args()
7222 
    args.read(iprot)
7223 
    iprot.readMessageEnd()
7224 
    result = updateShipmentAddress_result()
7225 
    try:
7226 
      self._handler.updateShipmentAddress(args.orderId, args.addressId)
7227 
    except TransactionServiceException, ex:
7228 
      result.ex = ex
7229 
    oprot.writeMessageBegin("updateShipmentAddress", TMessageType.REPLY, seqid)
7230 
    result.write(oprot)
7231 
    oprot.writeMessageEnd()
7232 
    oprot.trans.flush()
7233 
 
4285 rajveer 7234 
  def process_acceptOrdersForItemId(self, seqid, iprot, oprot):
7235 
    args = acceptOrdersForItemId_args()
7236 
    args.read(iprot)
7237 
    iprot.readMessageEnd()
7238 
    result = acceptOrdersForItemId_result()
7239 
    try:
7240 
      result.success = self._handler.acceptOrdersForItemId(args.itemId, args.inventory)
7241 
    except TransactionServiceException, ex:
7242 
      result.ex = ex
7243 
    oprot.writeMessageBegin("acceptOrdersForItemId", TMessageType.REPLY, seqid)
7244 
    result.write(oprot)
7245 
    oprot.writeMessageEnd()
7246 
    oprot.trans.flush()
4259 anupam.sin 7247 
 
4303 rajveer 7248 
  def process_markOrdersAsPORaised(self, seqid, iprot, oprot):
7249 
    args = markOrdersAsPORaised_args()
7250 
    args.read(iprot)
7251 
    iprot.readMessageEnd()
7252 
    result = markOrdersAsPORaised_result()
7253 
    try:
4369 rajveer 7254 
      self._handler.markOrdersAsPORaised(args.vendorId, args.itemId, args.quantity, args.estimate, args.isReminder)
4303 rajveer 7255 
    except TransactionServiceException, ex:
7256 
      result.ex = ex
7257 
    oprot.writeMessageBegin("markOrdersAsPORaised", TMessageType.REPLY, seqid)
7258 
    result.write(oprot)
7259 
    oprot.writeMessageEnd()
7260 
    oprot.trans.flush()
4285 rajveer 7261 
 
4303 rajveer 7262 
  def process_markOrdersAsReversalInitiated(self, seqid, iprot, oprot):
7263 
    args = markOrdersAsReversalInitiated_args()
7264 
    args.read(iprot)
7265 
    iprot.readMessageEnd()
7266 
    result = markOrdersAsReversalInitiated_result()
7267 
    try:
4369 rajveer 7268 
      self._handler.markOrdersAsReversalInitiated(args.vendorId, args.itemId, args.quantity, args.estimate, args.isReminder)
4303 rajveer 7269 
    except TransactionServiceException, ex:
7270 
      result.ex = ex
7271 
    oprot.writeMessageBegin("markOrdersAsReversalInitiated", TMessageType.REPLY, seqid)
7272 
    result.write(oprot)
7273 
    oprot.writeMessageEnd()
7274 
    oprot.trans.flush()
7275 
 
7276 
  def process_markOrdersAsNotAvailabke(self, seqid, iprot, oprot):
7277 
    args = markOrdersAsNotAvailabke_args()
7278 
    args.read(iprot)
7279 
    iprot.readMessageEnd()
7280 
    result = markOrdersAsNotAvailabke_result()
7281 
    try:
4369 rajveer 7282 
      self._handler.markOrdersAsNotAvailabke(args.vendorId, args.itemId, args.quantity, args.estimate, args.isReminder)
4303 rajveer 7283 
    except TransactionServiceException, ex:
7284 
      result.ex = ex
7285 
    oprot.writeMessageBegin("markOrdersAsNotAvailabke", TMessageType.REPLY, seqid)
7286 
    result.write(oprot)
7287 
    oprot.writeMessageEnd()
7288 
    oprot.trans.flush()
7289 
 
4369 rajveer 7290 
  def process_markOrdersAsTimeout(self, seqid, iprot, oprot):
7291 
    args = markOrdersAsTimeout_args()
7292 
    args.read(iprot)
7293 
    iprot.readMessageEnd()
7294 
    result = markOrdersAsTimeout_result()
7295 
    try:
7296 
      result.success = self._handler.markOrdersAsTimeout(args.vendorId)
7297 
    except TransactionServiceException, ex:
7298 
      result.ex = ex
7299 
    oprot.writeMessageBegin("markOrdersAsTimeout", TMessageType.REPLY, seqid)
7300 
    result.write(oprot)
7301 
    oprot.writeMessageEnd()
7302 
    oprot.trans.flush()
4303 rajveer 7303 
 
4662 rajveer 7304 
  def process_markOrderAsLostInTransit(self, seqid, iprot, oprot):
7305 
    args = markOrderAsLostInTransit_args()
7306 
    args.read(iprot)
7307 
    iprot.readMessageEnd()
7308 
    result = markOrderAsLostInTransit_result()
7309 
    try:
7310 
      result.success = self._handler.markOrderAsLostInTransit(args.orderId)
7311 
    except TransactionServiceException, ex:
7312 
      result.ex = ex
7313 
    oprot.writeMessageBegin("markOrderAsLostInTransit", TMessageType.REPLY, seqid)
7314 
    result.write(oprot)
7315 
    oprot.writeMessageEnd()
7316 
    oprot.trans.flush()
7317 
 
4386 anupam.sin 7318 
  def process_getOrderForAwb(self, seqid, iprot, oprot):
7319 
    args = getOrderForAwb_args()
7320 
    args.read(iprot)
7321 
    iprot.readMessageEnd()
7322 
    result = getOrderForAwb_result()
7323 
    try:
7324 
      result.success = self._handler.getOrderForAwb(args.awb)
7325 
    except TransactionServiceException, ex:
7326 
      result.ex = ex
7327 
    oprot.writeMessageBegin("getOrderForAwb", TMessageType.REPLY, seqid)
7328 
    result.write(oprot)
7329 
    oprot.writeMessageEnd()
7330 
    oprot.trans.flush()
4369 rajveer 7331 
 
4506 phani.kuma 7332 
  def process_getOrdersForProviderForStatus(self, seqid, iprot, oprot):
7333 
    args = getOrdersForProviderForStatus_args()
7334 
    args.read(iprot)
7335 
    iprot.readMessageEnd()
7336 
    result = getOrdersForProviderForStatus_result()
7337 
    try:
4910 phani.kuma 7338 
      result.success = self._handler.getOrdersForProviderForStatus(args.logistics_provider_id, args.order_status_list)
4506 phani.kuma 7339 
    except TransactionServiceException, ex:
7340 
      result.ex = ex
7341 
    oprot.writeMessageBegin("getOrdersForProviderForStatus", TMessageType.REPLY, seqid)
7342 
    result.write(oprot)
7343 
    oprot.writeMessageEnd()
7344 
    oprot.trans.flush()
4386 anupam.sin 7345 
 
4600 varun.gupt 7346 
  def process_getBilledOrdersForVendor(self, seqid, iprot, oprot):
7347 
    args = getBilledOrdersForVendor_args()
7348 
    args.read(iprot)
7349 
    iprot.readMessageEnd()
7350 
    result = getBilledOrdersForVendor_result()
7351 
    try:
7352 
      result.success = self._handler.getBilledOrdersForVendor(args.vendorId, args.billingDateFrom, args.billingDateTo)
7353 
    except TransactionServiceException, ex:
7354 
      result.ex = ex
7355 
    oprot.writeMessageBegin("getBilledOrdersForVendor", TMessageType.REPLY, seqid)
7356 
    result.write(oprot)
7357 
    oprot.writeMessageEnd()
7358 
    oprot.trans.flush()
4506 phani.kuma 7359 
 
4607 rajveer 7360 
  def process_getSlippedSippingDateOrders(self, seqid, iprot, oprot):
7361 
    args = getSlippedSippingDateOrders_args()
7362 
    args.read(iprot)
7363 
    iprot.readMessageEnd()
7364 
    result = getSlippedSippingDateOrders_result()
7365 
    try:
7366 
      result.success = self._handler.getSlippedSippingDateOrders()
7367 
    except TransactionServiceException, ex:
7368 
      result.ex = ex
7369 
    oprot.writeMessageBegin("getSlippedSippingDateOrders", TMessageType.REPLY, seqid)
7370 
    result.write(oprot)
7371 
    oprot.writeMessageEnd()
7372 
    oprot.trans.flush()
7373 
 
4709 rajveer 7374 
  def process_getCancelledOrders(self, seqid, iprot, oprot):
7375 
    args = getCancelledOrders_args()
7376 
    args.read(iprot)
7377 
    iprot.readMessageEnd()
7378 
    result = getCancelledOrders_result()
7379 
    try:
7380 
      result.success = self._handler.getCancelledOrders(args.cancelDateFrom, args.cancelDateTo)
7381 
    except TransactionServiceException, ex:
7382 
      result.ex = ex
7383 
    oprot.writeMessageBegin("getCancelledOrders", TMessageType.REPLY, seqid)
7384 
    result.write(oprot)
7385 
    oprot.writeMessageEnd()
7386 
    oprot.trans.flush()
7387 
 
4600 varun.gupt 7388 
  def process_saveBluedartSettlements(self, seqid, iprot, oprot):
7389 
    args = saveBluedartSettlements_args()
7390 
    args.read(iprot)
7391 
    iprot.readMessageEnd()
7392 
    result = saveBluedartSettlements_result()
7393 
    try:
7394 
      self._handler.saveBluedartSettlements(args.mapAWBAndAmount)
7395 
    except TransactionServiceException, ex:
7396 
      result.ex = ex
7397 
    oprot.writeMessageBegin("saveBluedartSettlements", TMessageType.REPLY, seqid)
7398 
    result.write(oprot)
7399 
    oprot.writeMessageEnd()
7400 
    oprot.trans.flush()
7401 
 
7402 
  def process_savePaymentSettlements(self, seqid, iprot, oprot):
7403 
    args = savePaymentSettlements_args()
7404 
    args.read(iprot)
7405 
    iprot.readMessageEnd()
7406 
    result = savePaymentSettlements_result()
7407 
    try:
4905 varun.gupt 7408 
      self._handler.savePaymentSettlements(args.settlementDate, args.paymentGatewayId, args.referenceId, args.serviceTax, args.otherCharges, args.netCollection)
4600 varun.gupt 7409 
    except TransactionServiceException, ex:
7410 
      result.ex = ex
7411 
    oprot.writeMessageBegin("savePaymentSettlements", TMessageType.REPLY, seqid)
7412 
    result.write(oprot)
7413 
    oprot.writeMessageEnd()
7414 
    oprot.trans.flush()
7415 
 
7416 
  def process_saveEBSSettlementSummary(self, seqid, iprot, oprot):
7417 
    args = saveEBSSettlementSummary_args()
7418 
    args.read(iprot)
7419 
    iprot.readMessageEnd()
7420 
    result = saveEBSSettlementSummary_result()
7421 
    try:
7422 
      self._handler.saveEBSSettlementSummary(args.settlementId, args.settlementDate, args.transactionDateFrom, args.transactionDateTo, args.amount)
7423 
    except TransactionServiceException, ex:
7424 
      result.ex = ex
7425 
    oprot.writeMessageBegin("saveEBSSettlementSummary", TMessageType.REPLY, seqid)
7426 
    result.write(oprot)
7427 
    oprot.writeMessageEnd()
7428 
    oprot.trans.flush()
7429 
 
5386 phani.kuma 7430 
  def process_getSettlementForPrepaid(self, seqid, iprot, oprot):
7431 
    args = getSettlementForPrepaid_args()
4600 varun.gupt 7432 
    args.read(iprot)
7433 
    iprot.readMessageEnd()
5386 phani.kuma 7434 
    result = getSettlementForPrepaid_result()
4600 varun.gupt 7435 
    try:
5386 phani.kuma 7436 
      result.success = self._handler.getSettlementForPrepaid(args.referenceId, args.isRefund)
4600 varun.gupt 7437 
    except TransactionServiceException, ex:
7438 
      result.ex = ex
5386 phani.kuma 7439 
    oprot.writeMessageBegin("getSettlementForPrepaid", TMessageType.REPLY, seqid)
4600 varun.gupt 7440 
    result.write(oprot)
7441 
    oprot.writeMessageEnd()
7442 
    oprot.trans.flush()
7443 
 
5386 phani.kuma 7444 
  def process_getSettlementForCod(self, seqid, iprot, oprot):
7445 
    args = getSettlementForCod_args()
7446 
    args.read(iprot)
7447 
    iprot.readMessageEnd()
7448 
    result = getSettlementForCod_result()
7449 
    try:
7450 
      result.success = self._handler.getSettlementForCod(args.orderId, args.isRefund)
7451 
    except TransactionServiceException, ex:
7452 
      result.ex = ex
7453 
    oprot.writeMessageBegin("getSettlementForCod", TMessageType.REPLY, seqid)
7454 
    result.write(oprot)
7455 
    oprot.writeMessageEnd()
7456 
    oprot.trans.flush()
7457 
 
4600 varun.gupt 7458 
  def process_getEBSSettlementSummaries(self, seqid, iprot, oprot):
7459 
    args = getEBSSettlementSummaries_args()
7460 
    args.read(iprot)
7461 
    iprot.readMessageEnd()
7462 
    result = getEBSSettlementSummaries_result()
7463 
    try:
7464 
      result.success = self._handler.getEBSSettlementSummaries()
7465 
    except TransactionServiceException, ex:
7466 
      result.ex = ex
7467 
    oprot.writeMessageBegin("getEBSSettlementSummaries", TMessageType.REPLY, seqid)
7468 
    result.write(oprot)
7469 
    oprot.writeMessageEnd()
7470 
    oprot.trans.flush()
7471 
 
7472 
  def process_markEBSSettlementUploaded(self, seqid, iprot, oprot):
7473 
    args = markEBSSettlementUploaded_args()
7474 
    args.read(iprot)
7475 
    iprot.readMessageEnd()
7476 
    result = markEBSSettlementUploaded_result()
7477 
    try:
7478 
      self._handler.markEBSSettlementUploaded(args.settlementId)
7479 
    except TransactionServiceException, ex:
7480 
      result.ex = ex
7481 
    oprot.writeMessageBegin("markEBSSettlementUploaded", TMessageType.REPLY, seqid)
7482 
    result.write(oprot)
7483 
    oprot.writeMessageEnd()
7484 
    oprot.trans.flush()
7485 
 
7486 
  def process_getEBSSettlementDate(self, seqid, iprot, oprot):
7487 
    args = getEBSSettlementDate_args()
7488 
    args.read(iprot)
7489 
    iprot.readMessageEnd()
7490 
    result = getEBSSettlementDate_result()
7491 
    try:
7492 
      result.success = self._handler.getEBSSettlementDate(args.settlementId)
7493 
    except TransactionServiceException, ex:
7494 
      result.ex = ex
7495 
    oprot.writeMessageBegin("getEBSSettlementDate", TMessageType.REPLY, seqid)
7496 
    result.write(oprot)
7497 
    oprot.writeMessageEnd()
7498 
    oprot.trans.flush()
7499 
 
4715 varun.gupt 7500 
  def process_getSettlementsByDate(self, seqid, iprot, oprot):
7501 
    args = getSettlementsByDate_args()
7502 
    args.read(iprot)
7503 
    iprot.readMessageEnd()
7504 
    result = getSettlementsByDate_result()
7505 
    try:
7506 
      result.success = self._handler.getSettlementsByDate(args.settlementDateFrom, args.settlementDateTo, args.isRefund)
7507 
    except TransactionServiceException, ex:
7508 
      result.ex = ex
7509 
    oprot.writeMessageBegin("getSettlementsByDate", TMessageType.REPLY, seqid)
7510 
    result.write(oprot)
7511 
    oprot.writeMessageEnd()
7512 
    oprot.trans.flush()
4600 varun.gupt 7513 
 
4715 varun.gupt 7514 
  def process_getReshippedOrderIds(self, seqid, iprot, oprot):
7515 
    args = getReshippedOrderIds_args()
7516 
    args.read(iprot)
7517 
    iprot.readMessageEnd()
7518 
    result = getReshippedOrderIds_result()
7519 
    try:
7520 
      result.success = self._handler.getReshippedOrderIds(args.orderIds)
7521 
    except TransactionServiceException, ex:
7522 
      result.ex = ex
7523 
    oprot.writeMessageBegin("getReshippedOrderIds", TMessageType.REPLY, seqid)
7524 
    result.write(oprot)
7525 
    oprot.writeMessageEnd()
7526 
    oprot.trans.flush()
7527 
 
5481 phani.kuma 7528 
  def process_getBilledOrders(self, seqid, iprot, oprot):
7529 
    args = getBilledOrders_args()
4875 varun.gupt 7530 
    args.read(iprot)
7531 
    iprot.readMessageEnd()
5481 phani.kuma 7532 
    result = getBilledOrders_result()
4875 varun.gupt 7533 
    try:
5481 phani.kuma 7534 
      result.success = self._handler.getBilledOrders(args.vendorId, args.onlyVendorNotPaid, args.billingDateFrom, args.billingDateTo)
4875 varun.gupt 7535 
    except TransactionServiceException, ex:
7536 
      result.ex = ex
5481 phani.kuma 7537 
    oprot.writeMessageBegin("getBilledOrders", TMessageType.REPLY, seqid)
4875 varun.gupt 7538 
    result.write(oprot)
7539 
    oprot.writeMessageEnd()
7540 
    oprot.trans.flush()
4757 mandeep.dh 7541 
 
5031 varun.gupt 7542 
  def process_getStatusDistributionOfOrders(self, seqid, iprot, oprot):
7543 
    args = getStatusDistributionOfOrders_args()
7544 
    args.read(iprot)
7545 
    iprot.readMessageEnd()
7546 
    result = getStatusDistributionOfOrders_result()
7547 
    try:
7548 
      result.success = self._handler.getStatusDistributionOfOrders(args.startDate, args.endDate)
7549 
    except TransactionServiceException, ex:
7550 
      result.ex = ex
7551 
    oprot.writeMessageBegin("getStatusDistributionOfOrders", TMessageType.REPLY, seqid)
7552 
    result.write(oprot)
7553 
    oprot.writeMessageEnd()
7554 
    oprot.trans.flush()
4875 varun.gupt 7555 
 
5067 varun.gupt 7556 
  def process_getOrderIdsForStatus(self, seqid, iprot, oprot):
7557 
    args = getOrderIdsForStatus_args()
7558 
    args.read(iprot)
7559 
    iprot.readMessageEnd()
7560 
    result = getOrderIdsForStatus_result()
7561 
    try:
7562 
      result.success = self._handler.getOrderIdsForStatus(args.status, args.startDatetime, args.endDatetime)
7563 
    except TransactionServiceException, ex:
7564 
      result.ex = ex
7565 
    oprot.writeMessageBegin("getOrderIdsForStatus", TMessageType.REPLY, seqid)
7566 
    result.write(oprot)
7567 
    oprot.writeMessageEnd()
7568 
    oprot.trans.flush()
5031 varun.gupt 7569 
 
5348 anupam.sin 7570 
  def process_updateCODAgent(self, seqid, iprot, oprot):
7571 
    args = updateCODAgent_args()
7572 
    args.read(iprot)
7573 
    iprot.readMessageEnd()
7574 
    result = updateCODAgent_result()
7575 
    try:
7576 
      self._handler.updateCODAgent(args.agent, args.orderId)
7577 
    except TransactionServiceException, ex:
7578 
      result.ex = ex
7579 
    oprot.writeMessageBegin("updateCODAgent", TMessageType.REPLY, seqid)
7580 
    result.write(oprot)
7581 
    oprot.writeMessageEnd()
7582 
    oprot.trans.flush()
7583 
 
5099 varun.gupt 7584 
  def process_updateOrderAsPaidToVendor(self, seqid, iprot, oprot):
7585 
    args = updateOrderAsPaidToVendor_args()
7586 
    args.read(iprot)
7587 
    iprot.readMessageEnd()
7588 
    result = updateOrderAsPaidToVendor_result()
7589 
    try:
7590 
      self._handler.updateOrderAsPaidToVendor(args.orderId)
7591 
    except TransactionServiceException, ex:
7592 
      result.ex = ex
7593 
    oprot.writeMessageBegin("updateOrderAsPaidToVendor", TMessageType.REPLY, seqid)
7594 
    result.write(oprot)
7595 
    oprot.writeMessageEnd()
7596 
    oprot.trans.flush()
5067 varun.gupt 7597 
 
5386 phani.kuma 7598 
  def process_updateOrderOnlyAsPaidToVendor(self, seqid, iprot, oprot):
7599 
    args = updateOrderOnlyAsPaidToVendor_args()
7600 
    args.read(iprot)
7601 
    iprot.readMessageEnd()
7602 
    result = updateOrderOnlyAsPaidToVendor_result()
7603 
    try:
7604 
      self._handler.updateOrderOnlyAsPaidToVendor(args.orderId)
7605 
    except TransactionServiceException, ex:
7606 
      result.ex = ex
7607 
    oprot.writeMessageBegin("updateOrderOnlyAsPaidToVendor", TMessageType.REPLY, seqid)
7608 
    result.write(oprot)
7609 
    oprot.writeMessageEnd()
7610 
    oprot.trans.flush()
7611 
 
5208 varun.gupt 7612 
  def process_getRefundedOrdersMarkedPaid(self, seqid, iprot, oprot):
7613 
    args = getRefundedOrdersMarkedPaid_args()
7614 
    args.read(iprot)
7615 
    iprot.readMessageEnd()
7616 
    result = getRefundedOrdersMarkedPaid_result()
7617 
    try:
7618 
      result.success = self._handler.getRefundedOrdersMarkedPaid()
7619 
    except TransactionServiceException, ex:
7620 
      result.ex = ex
7621 
    oprot.writeMessageBegin("getRefundedOrdersMarkedPaid", TMessageType.REPLY, seqid)
7622 
    result.write(oprot)
7623 
    oprot.writeMessageEnd()
7624 
    oprot.trans.flush()
5099 varun.gupt 7625 
 
5447 anupam.sin 7626 
  def process_getAllVerificationAgents(self, seqid, iprot, oprot):
7627 
    args = getAllVerificationAgents_args()
7628 
    args.read(iprot)
7629 
    iprot.readMessageEnd()
7630 
    result = getAllVerificationAgents_result()
7631 
    result.success = self._handler.getAllVerificationAgents(args.minOrderId, args.maxOrderId)
7632 
    oprot.writeMessageBegin("getAllVerificationAgents", TMessageType.REPLY, seqid)
7633 
    result.write(oprot)
7634 
    oprot.writeMessageEnd()
7635 
    oprot.trans.flush()
5208 varun.gupt 7636 
 
5527 anupam.sin 7637 
  def process_getAllAttributesForOrderId(self, seqid, iprot, oprot):
7638 
    args = getAllAttributesForOrderId_args()
7639 
    args.read(iprot)
7640 
    iprot.readMessageEnd()
7641 
    result = getAllAttributesForOrderId_result()
7642 
    result.success = self._handler.getAllAttributesForOrderId(args.orderId)
7643 
    oprot.writeMessageBegin("getAllAttributesForOrderId", TMessageType.REPLY, seqid)
7644 
    result.write(oprot)
7645 
    oprot.writeMessageEnd()
7646 
    oprot.trans.flush()
5447 anupam.sin 7647 
 
5676 rajveer 7648 
  def process_setOrderAttributes(self, seqid, iprot, oprot):
7649 
    args = setOrderAttributes_args()
7650 
    args.read(iprot)
7651 
    iprot.readMessageEnd()
7652 
    result = setOrderAttributes_result()
7653 
    self._handler.setOrderAttributes(args.orderId, args.attributes)
7654 
    oprot.writeMessageBegin("setOrderAttributes", TMessageType.REPLY, seqid)
7655 
    result.write(oprot)
7656 
    oprot.writeMessageEnd()
7657 
    oprot.trans.flush()
7658 
 
5527 anupam.sin 7659 
  def process_setOrderAttributeForTransaction(self, seqid, iprot, oprot):
7660 
    args = setOrderAttributeForTransaction_args()
7661 
    args.read(iprot)
7662 
    iprot.readMessageEnd()
7663 
    result = setOrderAttributeForTransaction_result()
7664 
    self._handler.setOrderAttributeForTransaction(args.transactionId, args.attribute)
7665 
    oprot.writeMessageBegin("setOrderAttributeForTransaction", TMessageType.REPLY, seqid)
7666 
    result.write(oprot)
7667 
    oprot.writeMessageEnd()
7668 
    oprot.trans.flush()
7669 
 
5553 rajveer 7670 
  def process_getReceivePendingOrders(self, seqid, iprot, oprot):
7671 
    args = getReceivePendingOrders_args()
7672 
    args.read(iprot)
7673 
    iprot.readMessageEnd()
7674 
    result = getReceivePendingOrders_result()
7675 
    result.success = self._handler.getReceivePendingOrders(args.storeId)
7676 
    oprot.writeMessageBegin("getReceivePendingOrders", TMessageType.REPLY, seqid)
7677 
    result.write(oprot)
7678 
    oprot.writeMessageEnd()
7679 
    oprot.trans.flush()
5527 anupam.sin 7680 
 
5553 rajveer 7681 
  def process_getReceivedAtStoreOrders(self, seqid, iprot, oprot):
7682 
    args = getReceivedAtStoreOrders_args()
7683 
    args.read(iprot)
7684 
    iprot.readMessageEnd()
7685 
    result = getReceivedAtStoreOrders_result()
7686 
    result.success = self._handler.getReceivedAtStoreOrders(args.storeId)
7687 
    oprot.writeMessageBegin("getReceivedAtStoreOrders", TMessageType.REPLY, seqid)
7688 
    result.write(oprot)
7689 
    oprot.writeMessageEnd()
7690 
    oprot.trans.flush()
7691 
 
5713 rajveer 7692 
  def process_getOrdersCollectionAtStore(self, seqid, iprot, oprot):
7693 
    args = getOrdersCollectionAtStore_args()
7694 
    args.read(iprot)
7695 
    iprot.readMessageEnd()
7696 
    result = getOrdersCollectionAtStore_result()
7697 
    result.success = self._handler.getOrdersCollectionAtStore(args.storeId, args.fromDate, args.toDate, args.onlyCod)
7698 
    oprot.writeMessageBegin("getOrdersCollectionAtStore", TMessageType.REPLY, seqid)
7699 
    result.write(oprot)
7700 
    oprot.writeMessageEnd()
7701 
    oprot.trans.flush()
7702 
 
5833 rajveer 7703 
  def process_getOrderAttributeValue(self, seqid, iprot, oprot):
7704 
    args = getOrderAttributeValue_args()
7705 
    args.read(iprot)
7706 
    iprot.readMessageEnd()
7707 
    result = getOrderAttributeValue_result()
7708 
    result.success = self._handler.getOrderAttributeValue(args.orderId, args.attributeName)
7709 
    oprot.writeMessageBegin("getOrderAttributeValue", TMessageType.REPLY, seqid)
7710 
    result.write(oprot)
7711 
    oprot.writeMessageEnd()
7712 
    oprot.trans.flush()
7713 
 
6019 rajveer 7714 
  def process_changeJacketNumber(self, seqid, iprot, oprot):
7715 
    args = changeJacketNumber_args()
7716 
    args.read(iprot)
7717 
    iprot.readMessageEnd()
7718 
    result = changeJacketNumber_result()
7719 
    result.success = self._handler.changeJacketNumber(args.orderId, args.jacketNumber)
7720 
    oprot.writeMessageBegin("changeJacketNumber", TMessageType.REPLY, seqid)
7721 
    result.write(oprot)
7722 
    oprot.writeMessageEnd()
7723 
    oprot.trans.flush()
7724 
 
7725 
  def process_markOrderAsRtoInTransit(self, seqid, iprot, oprot):
7726 
    args = markOrderAsRtoInTransit_args()
7727 
    args.read(iprot)
7728 
    iprot.readMessageEnd()
7729 
    result = markOrderAsRtoInTransit_result()
7730 
    result.success = self._handler.markOrderAsRtoInTransit(args.orderId)
7731 
    oprot.writeMessageBegin("markOrderAsRtoInTransit", TMessageType.REPLY, seqid)
7732 
    result.write(oprot)
7733 
    oprot.writeMessageEnd()
7734 
    oprot.trans.flush()
7735 
 
5593 mandeep.dh 7736 
  def process_acceptOrderForItem(self, seqid, iprot, oprot):
7737 
    args = acceptOrderForItem_args()
7738 
    args.read(iprot)
7739 
    iprot.readMessageEnd()
7740 
    result = acceptOrderForItem_result()
7741 
    self._handler.acceptOrderForItem(args.itemId, args.quantity, args.fulfilmentWarehouseId, args.billingWarehouseId)
7742 
    oprot.writeMessageBegin("acceptOrderForItem", TMessageType.REPLY, seqid)
7743 
    result.write(oprot)
7744 
    oprot.writeMessageEnd()
7745 
    oprot.trans.flush()
5553 rajveer 7746 
 
6000 mandeep.dh 7747 
  def process_createRechargeOrder(self, seqid, iprot, oprot):
7748 
    args = createRechargeOrder_args()
7749 
    args.read(iprot)
7750 
    iprot.readMessageEnd()
7751 
    result = createRechargeOrder_result()
7752 
    try:
7753 
      result.success = self._handler.createRechargeOrder(args.rechargeOrder)
7754 
    except TransactionServiceException, ex:
7755 
      result.ex = ex
7756 
    oprot.writeMessageBegin("createRechargeOrder", TMessageType.REPLY, seqid)
7757 
    result.write(oprot)
7758 
    oprot.writeMessageEnd()
7759 
    oprot.trans.flush()
5593 mandeep.dh 7760 
 
6000 mandeep.dh 7761 
  def process_updateRechargeOrderStatus(self, seqid, iprot, oprot):
7762 
    args = updateRechargeOrderStatus_args()
7763 
    args.read(iprot)
7764 
    iprot.readMessageEnd()
7765 
    result = updateRechargeOrderStatus_result()
7766 
    try:
7767 
      self._handler.updateRechargeOrderStatus(args.rechargeOrderId, args.rechargeOrderStatus)
7768 
    except TransactionServiceException, ex:
7769 
      result.ex = ex
7770 
    oprot.writeMessageBegin("updateRechargeOrderStatus", TMessageType.REPLY, seqid)
7771 
    result.write(oprot)
7772 
    oprot.writeMessageEnd()
7773 
    oprot.trans.flush()
7774 
 
7775 
  def process_activateRechargeTxn(self, seqid, iprot, oprot):
7776 
    args = activateRechargeTxn_args()
7777 
    args.read(iprot)
7778 
    iprot.readMessageEnd()
7779 
    result = activateRechargeTxn_result()
7780 
    try:
7781 
      result.success = self._handler.activateRechargeTxn(args.rechargeCoupons)
7782 
    except TransactionServiceException, ex:
7783 
      result.ex = ex
7784 
    oprot.writeMessageBegin("activateRechargeTxn", TMessageType.REPLY, seqid)
7785 
    result.write(oprot)
7786 
    oprot.writeMessageEnd()
7787 
    oprot.trans.flush()
7788 
 
7789 
  def process_getRechargeOrders(self, seqid, iprot, oprot):
7790 
    args = getRechargeOrders_args()
7791 
    args.read(iprot)
7792 
    iprot.readMessageEnd()
7793 
    result = getRechargeOrders_result()
7794 
    result.success = self._handler.getRechargeOrders(args.customerId)
7795 
    oprot.writeMessageBegin("getRechargeOrders", TMessageType.REPLY, seqid)
7796 
    result.write(oprot)
7797 
    oprot.writeMessageEnd()
7798 
    oprot.trans.flush()
7799 
 
7800 
  def process_getRechargeCoupons(self, seqid, iprot, oprot):
7801 
    args = getRechargeCoupons_args()
7802 
    args.read(iprot)
7803 
    iprot.readMessageEnd()
7804 
    result = getRechargeCoupons_result()
7805 
    result.success = self._handler.getRechargeCoupons(args.customerId, args.rechargeCouponStatus)
7806 
    oprot.writeMessageBegin("getRechargeCoupons", TMessageType.REPLY, seqid)
7807 
    result.write(oprot)
7808 
    oprot.writeMessageEnd()
7809 
    oprot.trans.flush()
7810 
 
7811 
 
94 ashish 7812 
# HELPER FUNCTIONS AND STRUCTURES
7813 
 
7814 
class createTransaction_args:
7815 
  """
7816 
  Attributes:
7817 
   - transaction
7818 
  """
7819 
 
7820 
  thrift_spec = (
7821 
    None, # 0
7822 
    (1, TType.STRUCT, 'transaction', (Transaction, Transaction.thrift_spec), None, ), # 1
7823 
  )
7824 
 
7825 
  def __init__(self, transaction=None,):
7826 
    self.transaction = transaction
7827 
 
7828 
  def read(self, iprot):
7829 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
7830 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
7831 
      return
7832 
    iprot.readStructBegin()
7833 
    while True:
7834 
      (fname, ftype, fid) = iprot.readFieldBegin()
7835 
      if ftype == TType.STOP:
7836 
        break
7837 
      if fid == 1:
7838 
        if ftype == TType.STRUCT:
7839 
          self.transaction = Transaction()
7840 
          self.transaction.read(iprot)
7841 
        else:
7842 
          iprot.skip(ftype)
7843 
      else:
7844 
        iprot.skip(ftype)
7845 
      iprot.readFieldEnd()
7846 
    iprot.readStructEnd()
7847 
 
7848 
  def write(self, oprot):
7849 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
7850 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
7851 
      return
7852 
    oprot.writeStructBegin('createTransaction_args')
3431 rajveer 7853 
    if self.transaction is not None:
94 ashish 7854 
      oprot.writeFieldBegin('transaction', TType.STRUCT, 1)
7855 
      self.transaction.write(oprot)
7856 
      oprot.writeFieldEnd()
7857 
    oprot.writeFieldStop()
7858 
    oprot.writeStructEnd()
7859 
 
3431 rajveer 7860 
  def validate(self):
7861 
    return
7862 
 
7863 
 
94 ashish 7864 
  def __repr__(self):
7865 
    L = ['%s=%r' % (key, value)
7866 
      for key, value in self.__dict__.iteritems()]
7867 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
7868 
 
7869 
  def __eq__(self, other):
7870 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
7871 
 
7872 
  def __ne__(self, other):
7873 
    return not (self == other)
7874 
 
7875 
class createTransaction_result:
7876 
  """
7877 
  Attributes:
132 ashish 7878 
   - success
94 ashish 7879 
   - ex
7880 
  """
7881 
 
7882 
  thrift_spec = (
132 ashish 7883 
    (0, TType.I64, 'success', None, None, ), # 0
94 ashish 7884 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
7885 
  )
7886 
 
132 ashish 7887 
  def __init__(self, success=None, ex=None,):
7888 
    self.success = success
94 ashish 7889 
    self.ex = ex
7890 
 
7891 
  def read(self, iprot):
7892 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
7893 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
7894 
      return
7895 
    iprot.readStructBegin()
7896 
    while True:
7897 
      (fname, ftype, fid) = iprot.readFieldBegin()
7898 
      if ftype == TType.STOP:
7899 
        break
132 ashish 7900 
      if fid == 0:
7901 
        if ftype == TType.I64:
7902 
          self.success = iprot.readI64();
7903 
        else:
7904 
          iprot.skip(ftype)
7905 
      elif fid == 1:
94 ashish 7906 
        if ftype == TType.STRUCT:
7907 
          self.ex = TransactionServiceException()
7908 
          self.ex.read(iprot)
7909 
        else:
7910 
          iprot.skip(ftype)
7911 
      else:
7912 
        iprot.skip(ftype)
7913 
      iprot.readFieldEnd()
7914 
    iprot.readStructEnd()
7915 
 
7916 
  def write(self, oprot):
7917 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
7918 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
7919 
      return
7920 
    oprot.writeStructBegin('createTransaction_result')
3431 rajveer 7921 
    if self.success is not None:
132 ashish 7922 
      oprot.writeFieldBegin('success', TType.I64, 0)
7923 
      oprot.writeI64(self.success)
7924 
      oprot.writeFieldEnd()
3431 rajveer 7925 
    if self.ex is not None:
94 ashish 7926 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
7927 
      self.ex.write(oprot)
7928 
      oprot.writeFieldEnd()
7929 
    oprot.writeFieldStop()
7930 
    oprot.writeStructEnd()
7931 
 
3431 rajveer 7932 
  def validate(self):
7933 
    return
7934 
 
7935 
 
94 ashish 7936 
  def __repr__(self):
7937 
    L = ['%s=%r' % (key, value)
7938 
      for key, value in self.__dict__.iteritems()]
7939 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
7940 
 
7941 
  def __eq__(self, other):
7942 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
7943 
 
7944 
  def __ne__(self, other):
7945 
    return not (self == other)
7946 
 
7947 
class getTransaction_args:
7948 
  """
7949 
  Attributes:
7950 
   - id
7951 
  """
7952 
 
7953 
  thrift_spec = (
7954 
    None, # 0
7955 
    (1, TType.I64, 'id', None, None, ), # 1
7956 
  )
7957 
 
7958 
  def __init__(self, id=None,):
7959 
    self.id = id
7960 
 
7961 
  def read(self, iprot):
7962 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
7963 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
7964 
      return
7965 
    iprot.readStructBegin()
7966 
    while True:
7967 
      (fname, ftype, fid) = iprot.readFieldBegin()
7968 
      if ftype == TType.STOP:
7969 
        break
7970 
      if fid == 1:
7971 
        if ftype == TType.I64:
7972 
          self.id = iprot.readI64();
7973 
        else:
7974 
          iprot.skip(ftype)
7975 
      else:
7976 
        iprot.skip(ftype)
7977 
      iprot.readFieldEnd()
7978 
    iprot.readStructEnd()
7979 
 
7980 
  def write(self, oprot):
7981 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
7982 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
7983 
      return
7984 
    oprot.writeStructBegin('getTransaction_args')
3431 rajveer 7985 
    if self.id is not None:
94 ashish 7986 
      oprot.writeFieldBegin('id', TType.I64, 1)
7987 
      oprot.writeI64(self.id)
7988 
      oprot.writeFieldEnd()
7989 
    oprot.writeFieldStop()
7990 
    oprot.writeStructEnd()
7991 
 
3431 rajveer 7992 
  def validate(self):
7993 
    return
7994 
 
7995 
 
94 ashish 7996 
  def __repr__(self):
7997 
    L = ['%s=%r' % (key, value)
7998 
      for key, value in self.__dict__.iteritems()]
7999 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8000 
 
8001 
  def __eq__(self, other):
8002 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8003 
 
8004 
  def __ne__(self, other):
8005 
    return not (self == other)
8006 
 
8007 
class getTransaction_result:
8008 
  """
8009 
  Attributes:
8010 
   - success
8011 
   - ex
8012 
  """
8013 
 
8014 
  thrift_spec = (
8015 
    (0, TType.STRUCT, 'success', (Transaction, Transaction.thrift_spec), None, ), # 0
8016 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
8017 
  )
8018 
 
8019 
  def __init__(self, success=None, ex=None,):
8020 
    self.success = success
8021 
    self.ex = ex
8022 
 
8023 
  def read(self, iprot):
8024 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8025 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8026 
      return
8027 
    iprot.readStructBegin()
8028 
    while True:
8029 
      (fname, ftype, fid) = iprot.readFieldBegin()
8030 
      if ftype == TType.STOP:
8031 
        break
8032 
      if fid == 0:
8033 
        if ftype == TType.STRUCT:
8034 
          self.success = Transaction()
8035 
          self.success.read(iprot)
8036 
        else:
8037 
          iprot.skip(ftype)
8038 
      elif fid == 1:
8039 
        if ftype == TType.STRUCT:
8040 
          self.ex = TransactionServiceException()
8041 
          self.ex.read(iprot)
8042 
        else:
8043 
          iprot.skip(ftype)
8044 
      else:
8045 
        iprot.skip(ftype)
8046 
      iprot.readFieldEnd()
8047 
    iprot.readStructEnd()
8048 
 
8049 
  def write(self, oprot):
8050 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8051 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8052 
      return
8053 
    oprot.writeStructBegin('getTransaction_result')
3431 rajveer 8054 
    if self.success is not None:
94 ashish 8055 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
8056 
      self.success.write(oprot)
8057 
      oprot.writeFieldEnd()
3431 rajveer 8058 
    if self.ex is not None:
94 ashish 8059 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
8060 
      self.ex.write(oprot)
8061 
      oprot.writeFieldEnd()
8062 
    oprot.writeFieldStop()
8063 
    oprot.writeStructEnd()
8064 
 
3431 rajveer 8065 
  def validate(self):
8066 
    return
8067 
 
8068 
 
94 ashish 8069 
  def __repr__(self):
8070 
    L = ['%s=%r' % (key, value)
8071 
      for key, value in self.__dict__.iteritems()]
8072 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8073 
 
8074 
  def __eq__(self, other):
8075 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8076 
 
8077 
  def __ne__(self, other):
8078 
    return not (self == other)
8079 
 
8080 
class getTransactionsForCustomer_args:
8081 
  """
8082 
  Attributes:
8083 
   - customerId
8084 
   - from_date
8085 
   - to_date
8086 
   - status
8087 
  """
8088 
 
8089 
  thrift_spec = (
8090 
    None, # 0
8091 
    (1, TType.I64, 'customerId', None, None, ), # 1
8092 
    (2, TType.I64, 'from_date', None, None, ), # 2
8093 
    (3, TType.I64, 'to_date', None, None, ), # 3
8094 
    (4, TType.I32, 'status', None, None, ), # 4
8095 
  )
8096 
 
8097 
  def __init__(self, customerId=None, from_date=None, to_date=None, status=None,):
8098 
    self.customerId = customerId
8099 
    self.from_date = from_date
8100 
    self.to_date = to_date
8101 
    self.status = status
8102 
 
8103 
  def read(self, iprot):
8104 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8105 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8106 
      return
8107 
    iprot.readStructBegin()
8108 
    while True:
8109 
      (fname, ftype, fid) = iprot.readFieldBegin()
8110 
      if ftype == TType.STOP:
8111 
        break
8112 
      if fid == 1:
8113 
        if ftype == TType.I64:
8114 
          self.customerId = iprot.readI64();
8115 
        else:
8116 
          iprot.skip(ftype)
8117 
      elif fid == 2:
8118 
        if ftype == TType.I64:
8119 
          self.from_date = iprot.readI64();
8120 
        else:
8121 
          iprot.skip(ftype)
8122 
      elif fid == 3:
8123 
        if ftype == TType.I64:
8124 
          self.to_date = iprot.readI64();
8125 
        else:
8126 
          iprot.skip(ftype)
8127 
      elif fid == 4:
8128 
        if ftype == TType.I32:
8129 
          self.status = iprot.readI32();
8130 
        else:
8131 
          iprot.skip(ftype)
8132 
      else:
8133 
        iprot.skip(ftype)
8134 
      iprot.readFieldEnd()
8135 
    iprot.readStructEnd()
8136 
 
8137 
  def write(self, oprot):
8138 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8139 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8140 
      return
8141 
    oprot.writeStructBegin('getTransactionsForCustomer_args')
3431 rajveer 8142 
    if self.customerId is not None:
94 ashish 8143 
      oprot.writeFieldBegin('customerId', TType.I64, 1)
8144 
      oprot.writeI64(self.customerId)
8145 
      oprot.writeFieldEnd()
3431 rajveer 8146 
    if self.from_date is not None:
94 ashish 8147 
      oprot.writeFieldBegin('from_date', TType.I64, 2)
8148 
      oprot.writeI64(self.from_date)
8149 
      oprot.writeFieldEnd()
3431 rajveer 8150 
    if self.to_date is not None:
94 ashish 8151 
      oprot.writeFieldBegin('to_date', TType.I64, 3)
8152 
      oprot.writeI64(self.to_date)
8153 
      oprot.writeFieldEnd()
3431 rajveer 8154 
    if self.status is not None:
94 ashish 8155 
      oprot.writeFieldBegin('status', TType.I32, 4)
8156 
      oprot.writeI32(self.status)
8157 
      oprot.writeFieldEnd()
8158 
    oprot.writeFieldStop()
8159 
    oprot.writeStructEnd()
8160 
 
3431 rajveer 8161 
  def validate(self):
8162 
    return
8163 
 
8164 
 
94 ashish 8165 
  def __repr__(self):
8166 
    L = ['%s=%r' % (key, value)
8167 
      for key, value in self.__dict__.iteritems()]
8168 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8169 
 
8170 
  def __eq__(self, other):
8171 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8172 
 
8173 
  def __ne__(self, other):
8174 
    return not (self == other)
8175 
 
8176 
class getTransactionsForCustomer_result:
8177 
  """
8178 
  Attributes:
8179 
   - success
8180 
   - ex
8181 
  """
8182 
 
8183 
  thrift_spec = (
8184 
    (0, TType.LIST, 'success', (TType.STRUCT,(Transaction, Transaction.thrift_spec)), None, ), # 0
8185 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
8186 
  )
8187 
 
8188 
  def __init__(self, success=None, ex=None,):
8189 
    self.success = success
8190 
    self.ex = ex
8191 
 
8192 
  def read(self, iprot):
8193 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8194 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8195 
      return
8196 
    iprot.readStructBegin()
8197 
    while True:
8198 
      (fname, ftype, fid) = iprot.readFieldBegin()
8199 
      if ftype == TType.STOP:
8200 
        break
8201 
      if fid == 0:
8202 
        if ftype == TType.LIST:
8203 
          self.success = []
6000 mandeep.dh 8204 
          (_etype73, _size70) = iprot.readListBegin()
8205 
          for _i74 in xrange(_size70):
8206 
            _elem75 = Transaction()
8207 
            _elem75.read(iprot)
8208 
            self.success.append(_elem75)
94 ashish 8209 
          iprot.readListEnd()
8210 
        else:
8211 
          iprot.skip(ftype)
8212 
      elif fid == 1:
8213 
        if ftype == TType.STRUCT:
8214 
          self.ex = TransactionServiceException()
8215 
          self.ex.read(iprot)
8216 
        else:
8217 
          iprot.skip(ftype)
8218 
      else:
8219 
        iprot.skip(ftype)
8220 
      iprot.readFieldEnd()
8221 
    iprot.readStructEnd()
8222 
 
8223 
  def write(self, oprot):
8224 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8225 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8226 
      return
8227 
    oprot.writeStructBegin('getTransactionsForCustomer_result')
3431 rajveer 8228 
    if self.success is not None:
94 ashish 8229 
      oprot.writeFieldBegin('success', TType.LIST, 0)
8230 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
6000 mandeep.dh 8231 
      for iter76 in self.success:
8232 
        iter76.write(oprot)
94 ashish 8233 
      oprot.writeListEnd()
8234 
      oprot.writeFieldEnd()
3431 rajveer 8235 
    if self.ex is not None:
94 ashish 8236 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
8237 
      self.ex.write(oprot)
8238 
      oprot.writeFieldEnd()
8239 
    oprot.writeFieldStop()
8240 
    oprot.writeStructEnd()
8241 
 
3431 rajveer 8242 
  def validate(self):
8243 
    return
8244 
 
8245 
 
94 ashish 8246 
  def __repr__(self):
8247 
    L = ['%s=%r' % (key, value)
8248 
      for key, value in self.__dict__.iteritems()]
8249 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8250 
 
8251 
  def __eq__(self, other):
8252 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8253 
 
8254 
  def __ne__(self, other):
8255 
    return not (self == other)
8256 
 
132 ashish 8257 
class getTransactionsForShoppingCartId_args:
8258 
  """
8259 
  Attributes:
8260 
   - shoppingCartId
8261 
  """
8262 
 
8263 
  thrift_spec = (
8264 
    None, # 0
8265 
    (1, TType.I64, 'shoppingCartId', None, None, ), # 1
8266 
  )
8267 
 
8268 
  def __init__(self, shoppingCartId=None,):
8269 
    self.shoppingCartId = shoppingCartId
8270 
 
8271 
  def read(self, iprot):
8272 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8273 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8274 
      return
8275 
    iprot.readStructBegin()
8276 
    while True:
8277 
      (fname, ftype, fid) = iprot.readFieldBegin()
8278 
      if ftype == TType.STOP:
8279 
        break
8280 
      if fid == 1:
8281 
        if ftype == TType.I64:
8282 
          self.shoppingCartId = iprot.readI64();
8283 
        else:
8284 
          iprot.skip(ftype)
8285 
      else:
8286 
        iprot.skip(ftype)
8287 
      iprot.readFieldEnd()
8288 
    iprot.readStructEnd()
8289 
 
8290 
  def write(self, oprot):
8291 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8292 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8293 
      return
8294 
    oprot.writeStructBegin('getTransactionsForShoppingCartId_args')
3431 rajveer 8295 
    if self.shoppingCartId is not None:
132 ashish 8296 
      oprot.writeFieldBegin('shoppingCartId', TType.I64, 1)
8297 
      oprot.writeI64(self.shoppingCartId)
8298 
      oprot.writeFieldEnd()
8299 
    oprot.writeFieldStop()
8300 
    oprot.writeStructEnd()
8301 
 
3431 rajveer 8302 
  def validate(self):
8303 
    return
8304 
 
8305 
 
132 ashish 8306 
  def __repr__(self):
8307 
    L = ['%s=%r' % (key, value)
8308 
      for key, value in self.__dict__.iteritems()]
8309 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8310 
 
8311 
  def __eq__(self, other):
8312 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8313 
 
8314 
  def __ne__(self, other):
8315 
    return not (self == other)
8316 
 
8317 
class getTransactionsForShoppingCartId_result:
8318 
  """
8319 
  Attributes:
8320 
   - success
8321 
   - ex
8322 
  """
8323 
 
8324 
  thrift_spec = (
8325 
    (0, TType.LIST, 'success', (TType.STRUCT,(Transaction, Transaction.thrift_spec)), None, ), # 0
8326 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
8327 
  )
8328 
 
8329 
  def __init__(self, success=None, ex=None,):
8330 
    self.success = success
8331 
    self.ex = ex
8332 
 
8333 
  def read(self, iprot):
8334 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8335 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8336 
      return
8337 
    iprot.readStructBegin()
8338 
    while True:
8339 
      (fname, ftype, fid) = iprot.readFieldBegin()
8340 
      if ftype == TType.STOP:
8341 
        break
8342 
      if fid == 0:
8343 
        if ftype == TType.LIST:
8344 
          self.success = []
6000 mandeep.dh 8345 
          (_etype80, _size77) = iprot.readListBegin()
8346 
          for _i81 in xrange(_size77):
8347 
            _elem82 = Transaction()
8348 
            _elem82.read(iprot)
8349 
            self.success.append(_elem82)
132 ashish 8350 
          iprot.readListEnd()
8351 
        else:
8352 
          iprot.skip(ftype)
8353 
      elif fid == 1:
8354 
        if ftype == TType.STRUCT:
8355 
          self.ex = TransactionServiceException()
8356 
          self.ex.read(iprot)
8357 
        else:
8358 
          iprot.skip(ftype)
8359 
      else:
8360 
        iprot.skip(ftype)
8361 
      iprot.readFieldEnd()
8362 
    iprot.readStructEnd()
8363 
 
8364 
  def write(self, oprot):
8365 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8366 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8367 
      return
8368 
    oprot.writeStructBegin('getTransactionsForShoppingCartId_result')
3431 rajveer 8369 
    if self.success is not None:
132 ashish 8370 
      oprot.writeFieldBegin('success', TType.LIST, 0)
8371 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
6000 mandeep.dh 8372 
      for iter83 in self.success:
8373 
        iter83.write(oprot)
132 ashish 8374 
      oprot.writeListEnd()
8375 
      oprot.writeFieldEnd()
3431 rajveer 8376 
    if self.ex is not None:
132 ashish 8377 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
8378 
      self.ex.write(oprot)
8379 
      oprot.writeFieldEnd()
8380 
    oprot.writeFieldStop()
8381 
    oprot.writeStructEnd()
8382 
 
3431 rajveer 8383 
  def validate(self):
8384 
    return
8385 
 
8386 
 
132 ashish 8387 
  def __repr__(self):
8388 
    L = ['%s=%r' % (key, value)
8389 
      for key, value in self.__dict__.iteritems()]
8390 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8391 
 
8392 
  def __eq__(self, other):
8393 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8394 
 
8395 
  def __ne__(self, other):
8396 
    return not (self == other)
8397 
 
94 ashish 8398 
class getTransactionStatus_args:
8399 
  """
8400 
  Attributes:
8401 
   - transactionId
8402 
  """
8403 
 
8404 
  thrift_spec = (
8405 
    None, # 0
8406 
    (1, TType.I64, 'transactionId', None, None, ), # 1
8407 
  )
8408 
 
8409 
  def __init__(self, transactionId=None,):
8410 
    self.transactionId = transactionId
8411 
 
8412 
  def read(self, iprot):
8413 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8414 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8415 
      return
8416 
    iprot.readStructBegin()
8417 
    while True:
8418 
      (fname, ftype, fid) = iprot.readFieldBegin()
8419 
      if ftype == TType.STOP:
8420 
        break
8421 
      if fid == 1:
8422 
        if ftype == TType.I64:
8423 
          self.transactionId = iprot.readI64();
8424 
        else:
8425 
          iprot.skip(ftype)
8426 
      else:
8427 
        iprot.skip(ftype)
8428 
      iprot.readFieldEnd()
8429 
    iprot.readStructEnd()
8430 
 
8431 
  def write(self, oprot):
8432 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8433 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8434 
      return
8435 
    oprot.writeStructBegin('getTransactionStatus_args')
3431 rajveer 8436 
    if self.transactionId is not None:
94 ashish 8437 
      oprot.writeFieldBegin('transactionId', TType.I64, 1)
8438 
      oprot.writeI64(self.transactionId)
8439 
      oprot.writeFieldEnd()
8440 
    oprot.writeFieldStop()
8441 
    oprot.writeStructEnd()
8442 
 
3431 rajveer 8443 
  def validate(self):
8444 
    return
8445 
 
8446 
 
94 ashish 8447 
  def __repr__(self):
8448 
    L = ['%s=%r' % (key, value)
8449 
      for key, value in self.__dict__.iteritems()]
8450 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8451 
 
8452 
  def __eq__(self, other):
8453 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8454 
 
8455 
  def __ne__(self, other):
8456 
    return not (self == other)
8457 
 
8458 
class getTransactionStatus_result:
8459 
  """
8460 
  Attributes:
8461 
   - success
8462 
   - ex
8463 
  """
8464 
 
8465 
  thrift_spec = (
8466 
    (0, TType.I32, 'success', None, None, ), # 0
8467 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
8468 
  )
8469 
 
8470 
  def __init__(self, success=None, ex=None,):
8471 
    self.success = success
8472 
    self.ex = ex
8473 
 
8474 
  def read(self, iprot):
8475 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8476 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8477 
      return
8478 
    iprot.readStructBegin()
8479 
    while True:
8480 
      (fname, ftype, fid) = iprot.readFieldBegin()
8481 
      if ftype == TType.STOP:
8482 
        break
8483 
      if fid == 0:
8484 
        if ftype == TType.I32:
8485 
          self.success = iprot.readI32();
8486 
        else:
8487 
          iprot.skip(ftype)
8488 
      elif fid == 1:
8489 
        if ftype == TType.STRUCT:
8490 
          self.ex = TransactionServiceException()
8491 
          self.ex.read(iprot)
8492 
        else:
8493 
          iprot.skip(ftype)
8494 
      else:
8495 
        iprot.skip(ftype)
8496 
      iprot.readFieldEnd()
8497 
    iprot.readStructEnd()
8498 
 
8499 
  def write(self, oprot):
8500 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8501 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8502 
      return
8503 
    oprot.writeStructBegin('getTransactionStatus_result')
3431 rajveer 8504 
    if self.success is not None:
94 ashish 8505 
      oprot.writeFieldBegin('success', TType.I32, 0)
8506 
      oprot.writeI32(self.success)
8507 
      oprot.writeFieldEnd()
3431 rajveer 8508 
    if self.ex is not None:
94 ashish 8509 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
8510 
      self.ex.write(oprot)
8511 
      oprot.writeFieldEnd()
8512 
    oprot.writeFieldStop()
8513 
    oprot.writeStructEnd()
8514 
 
3431 rajveer 8515 
  def validate(self):
8516 
    return
8517 
 
8518 
 
94 ashish 8519 
  def __repr__(self):
8520 
    L = ['%s=%r' % (key, value)
8521 
      for key, value in self.__dict__.iteritems()]
8522 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8523 
 
8524 
  def __eq__(self, other):
8525 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8526 
 
8527 
  def __ne__(self, other):
8528 
    return not (self == other)
8529 
 
8530 
class changeTransactionStatus_args:
8531 
  """
8532 
  Attributes:
8533 
   - transactionId
8534 
   - status
8535 
   - description
5527 anupam.sin 8536 
   - pickUp
8537 
   - orderType
94 ashish 8538 
  """
8539 
 
8540 
  thrift_spec = (
8541 
    None, # 0
8542 
    (1, TType.I64, 'transactionId', None, None, ), # 1
8543 
    (2, TType.I32, 'status', None, None, ), # 2
8544 
    (3, TType.STRING, 'description', None, None, ), # 3
5527 anupam.sin 8545 
    (4, TType.I64, 'pickUp', None, None, ), # 4
8546 
    (5, TType.I32, 'orderType', None, None, ), # 5
94 ashish 8547 
  )
8548 
 
5527 anupam.sin 8549 
  def __init__(self, transactionId=None, status=None, description=None, pickUp=None, orderType=None,):
94 ashish 8550 
    self.transactionId = transactionId
8551 
    self.status = status
8552 
    self.description = description
5527 anupam.sin 8553 
    self.pickUp = pickUp
8554 
    self.orderType = orderType
94 ashish 8555 
 
8556 
  def read(self, iprot):
8557 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8558 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8559 
      return
8560 
    iprot.readStructBegin()
8561 
    while True:
8562 
      (fname, ftype, fid) = iprot.readFieldBegin()
8563 
      if ftype == TType.STOP:
8564 
        break
8565 
      if fid == 1:
8566 
        if ftype == TType.I64:
8567 
          self.transactionId = iprot.readI64();
8568 
        else:
8569 
          iprot.skip(ftype)
8570 
      elif fid == 2:
8571 
        if ftype == TType.I32:
8572 
          self.status = iprot.readI32();
8573 
        else:
8574 
          iprot.skip(ftype)
8575 
      elif fid == 3:
8576 
        if ftype == TType.STRING:
8577 
          self.description = iprot.readString();
8578 
        else:
8579 
          iprot.skip(ftype)
5387 rajveer 8580 
      elif fid == 4:
5527 anupam.sin 8581 
        if ftype == TType.I64:
8582 
          self.pickUp = iprot.readI64();
5387 rajveer 8583 
        else:
8584 
          iprot.skip(ftype)
5527 anupam.sin 8585 
      elif fid == 5:
8586 
        if ftype == TType.I32:
8587 
          self.orderType = iprot.readI32();
8588 
        else:
8589 
          iprot.skip(ftype)
94 ashish 8590 
      else:
8591 
        iprot.skip(ftype)
8592 
      iprot.readFieldEnd()
8593 
    iprot.readStructEnd()
8594 
 
8595 
  def write(self, oprot):
8596 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8597 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8598 
      return
8599 
    oprot.writeStructBegin('changeTransactionStatus_args')
3431 rajveer 8600 
    if self.transactionId is not None:
94 ashish 8601 
      oprot.writeFieldBegin('transactionId', TType.I64, 1)
8602 
      oprot.writeI64(self.transactionId)
8603 
      oprot.writeFieldEnd()
3431 rajveer 8604 
    if self.status is not None:
94 ashish 8605 
      oprot.writeFieldBegin('status', TType.I32, 2)
8606 
      oprot.writeI32(self.status)
8607 
      oprot.writeFieldEnd()
3431 rajveer 8608 
    if self.description is not None:
94 ashish 8609 
      oprot.writeFieldBegin('description', TType.STRING, 3)
8610 
      oprot.writeString(self.description)
8611 
      oprot.writeFieldEnd()
5527 anupam.sin 8612 
    if self.pickUp is not None:
8613 
      oprot.writeFieldBegin('pickUp', TType.I64, 4)
8614 
      oprot.writeI64(self.pickUp)
5387 rajveer 8615 
      oprot.writeFieldEnd()
5527 anupam.sin 8616 
    if self.orderType is not None:
8617 
      oprot.writeFieldBegin('orderType', TType.I32, 5)
8618 
      oprot.writeI32(self.orderType)
8619 
      oprot.writeFieldEnd()
94 ashish 8620 
    oprot.writeFieldStop()
8621 
    oprot.writeStructEnd()
8622 
 
3431 rajveer 8623 
  def validate(self):
8624 
    return
8625 
 
8626 
 
94 ashish 8627 
  def __repr__(self):
8628 
    L = ['%s=%r' % (key, value)
8629 
      for key, value in self.__dict__.iteritems()]
8630 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8631 
 
8632 
  def __eq__(self, other):
8633 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8634 
 
8635 
  def __ne__(self, other):
8636 
    return not (self == other)
8637 
 
8638 
class changeTransactionStatus_result:
8639 
  """
8640 
  Attributes:
8641 
   - success
8642 
   - ex
8643 
  """
8644 
 
8645 
  thrift_spec = (
8646 
    (0, TType.BOOL, 'success', None, None, ), # 0
8647 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
8648 
  )
8649 
 
8650 
  def __init__(self, success=None, ex=None,):
8651 
    self.success = success
8652 
    self.ex = ex
8653 
 
8654 
  def read(self, iprot):
8655 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8656 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8657 
      return
8658 
    iprot.readStructBegin()
8659 
    while True:
8660 
      (fname, ftype, fid) = iprot.readFieldBegin()
8661 
      if ftype == TType.STOP:
8662 
        break
8663 
      if fid == 0:
8664 
        if ftype == TType.BOOL:
8665 
          self.success = iprot.readBool();
8666 
        else:
8667 
          iprot.skip(ftype)
8668 
      elif fid == 1:
8669 
        if ftype == TType.STRUCT:
8670 
          self.ex = TransactionServiceException()
8671 
          self.ex.read(iprot)
8672 
        else:
8673 
          iprot.skip(ftype)
8674 
      else:
8675 
        iprot.skip(ftype)
8676 
      iprot.readFieldEnd()
8677 
    iprot.readStructEnd()
8678 
 
8679 
  def write(self, oprot):
8680 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8681 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8682 
      return
8683 
    oprot.writeStructBegin('changeTransactionStatus_result')
3431 rajveer 8684 
    if self.success is not None:
94 ashish 8685 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
8686 
      oprot.writeBool(self.success)
8687 
      oprot.writeFieldEnd()
3431 rajveer 8688 
    if self.ex is not None:
94 ashish 8689 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
8690 
      self.ex.write(oprot)
8691 
      oprot.writeFieldEnd()
8692 
    oprot.writeFieldStop()
8693 
    oprot.writeStructEnd()
8694 
 
3431 rajveer 8695 
  def validate(self):
8696 
    return
8697 
 
8698 
 
94 ashish 8699 
  def __repr__(self):
8700 
    L = ['%s=%r' % (key, value)
8701 
      for key, value in self.__dict__.iteritems()]
8702 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8703 
 
8704 
  def __eq__(self, other):
8705 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8706 
 
8707 
  def __ne__(self, other):
8708 
    return not (self == other)
8709 
 
1398 varun.gupt 8710 
class enqueueTransactionInfoEmail_args:
1382 varun.gupt 8711 
  """
8712 
  Attributes:
8713 
   - transactionId
8714 
  """
8715 
 
8716 
  thrift_spec = (
8717 
    None, # 0
8718 
    (1, TType.I64, 'transactionId', None, None, ), # 1
8719 
  )
8720 
 
8721 
  def __init__(self, transactionId=None,):
8722 
    self.transactionId = transactionId
8723 
 
8724 
  def read(self, iprot):
8725 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8726 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8727 
      return
8728 
    iprot.readStructBegin()
8729 
    while True:
8730 
      (fname, ftype, fid) = iprot.readFieldBegin()
8731 
      if ftype == TType.STOP:
8732 
        break
8733 
      if fid == 1:
8734 
        if ftype == TType.I64:
8735 
          self.transactionId = iprot.readI64();
8736 
        else:
8737 
          iprot.skip(ftype)
8738 
      else:
8739 
        iprot.skip(ftype)
8740 
      iprot.readFieldEnd()
8741 
    iprot.readStructEnd()
8742 
 
8743 
  def write(self, oprot):
8744 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8745 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8746 
      return
1398 varun.gupt 8747 
    oprot.writeStructBegin('enqueueTransactionInfoEmail_args')
3431 rajveer 8748 
    if self.transactionId is not None:
1382 varun.gupt 8749 
      oprot.writeFieldBegin('transactionId', TType.I64, 1)
8750 
      oprot.writeI64(self.transactionId)
8751 
      oprot.writeFieldEnd()
8752 
    oprot.writeFieldStop()
8753 
    oprot.writeStructEnd()
8754 
 
3431 rajveer 8755 
  def validate(self):
8756 
    return
8757 
 
8758 
 
1382 varun.gupt 8759 
  def __repr__(self):
8760 
    L = ['%s=%r' % (key, value)
8761 
      for key, value in self.__dict__.iteritems()]
8762 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8763 
 
8764 
  def __eq__(self, other):
8765 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8766 
 
8767 
  def __ne__(self, other):
8768 
    return not (self == other)
8769 
 
1398 varun.gupt 8770 
class enqueueTransactionInfoEmail_result:
1382 varun.gupt 8771 
  """
8772 
  Attributes:
8773 
   - success
8774 
   - ex
8775 
  """
8776 
 
8777 
  thrift_spec = (
8778 
    (0, TType.BOOL, 'success', None, None, ), # 0
8779 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
8780 
  )
8781 
 
8782 
  def __init__(self, success=None, ex=None,):
8783 
    self.success = success
8784 
    self.ex = ex
8785 
 
8786 
  def read(self, iprot):
8787 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8788 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8789 
      return
8790 
    iprot.readStructBegin()
8791 
    while True:
8792 
      (fname, ftype, fid) = iprot.readFieldBegin()
8793 
      if ftype == TType.STOP:
8794 
        break
8795 
      if fid == 0:
8796 
        if ftype == TType.BOOL:
8797 
          self.success = iprot.readBool();
8798 
        else:
8799 
          iprot.skip(ftype)
8800 
      elif fid == 1:
8801 
        if ftype == TType.STRUCT:
8802 
          self.ex = TransactionServiceException()
8803 
          self.ex.read(iprot)
8804 
        else:
8805 
          iprot.skip(ftype)
8806 
      else:
8807 
        iprot.skip(ftype)
8808 
      iprot.readFieldEnd()
8809 
    iprot.readStructEnd()
8810 
 
8811 
  def write(self, oprot):
8812 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8813 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8814 
      return
1398 varun.gupt 8815 
    oprot.writeStructBegin('enqueueTransactionInfoEmail_result')
3431 rajveer 8816 
    if self.success is not None:
1382 varun.gupt 8817 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
8818 
      oprot.writeBool(self.success)
8819 
      oprot.writeFieldEnd()
3431 rajveer 8820 
    if self.ex is not None:
1382 varun.gupt 8821 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
8822 
      self.ex.write(oprot)
8823 
      oprot.writeFieldEnd()
8824 
    oprot.writeFieldStop()
8825 
    oprot.writeStructEnd()
8826 
 
3431 rajveer 8827 
  def validate(self):
8828 
    return
8829 
 
8830 
 
1382 varun.gupt 8831 
  def __repr__(self):
8832 
    L = ['%s=%r' % (key, value)
8833 
      for key, value in self.__dict__.iteritems()]
8834 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8835 
 
8836 
  def __eq__(self, other):
8837 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8838 
 
8839 
  def __ne__(self, other):
8840 
    return not (self == other)
8841 
 
483 rajveer 8842 
class getAllOrders_args:
94 ashish 8843 
  """
8844 
  Attributes:
4801 anupam.sin 8845 
   - statuses
483 rajveer 8846 
   - from_date
8847 
   - to_date
8848 
   - warehouse_id
94 ashish 8849 
  """
8850 
 
8851 
  thrift_spec = (
8852 
    None, # 0
4801 anupam.sin 8853 
    (1, TType.LIST, 'statuses', (TType.I32,None), None, ), # 1
483 rajveer 8854 
    (2, TType.I64, 'from_date', None, None, ), # 2
8855 
    (3, TType.I64, 'to_date', None, None, ), # 3
8856 
    (4, TType.I64, 'warehouse_id', None, None, ), # 4
94 ashish 8857 
  )
8858 
 
4801 anupam.sin 8859 
  def __init__(self, statuses=None, from_date=None, to_date=None, warehouse_id=None,):
8860 
    self.statuses = statuses
483 rajveer 8861 
    self.from_date = from_date
8862 
    self.to_date = to_date
8863 
    self.warehouse_id = warehouse_id
94 ashish 8864 
 
8865 
  def read(self, iprot):
8866 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8867 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8868 
      return
8869 
    iprot.readStructBegin()
8870 
    while True:
8871 
      (fname, ftype, fid) = iprot.readFieldBegin()
8872 
      if ftype == TType.STOP:
8873 
        break
8874 
      if fid == 1:
4801 anupam.sin 8875 
        if ftype == TType.LIST:
8876 
          self.statuses = []
6000 mandeep.dh 8877 
          (_etype87, _size84) = iprot.readListBegin()
8878 
          for _i88 in xrange(_size84):
8879 
            _elem89 = iprot.readI32();
8880 
            self.statuses.append(_elem89)
4801 anupam.sin 8881 
          iprot.readListEnd()
94 ashish 8882 
        else:
8883 
          iprot.skip(ftype)
483 rajveer 8884 
      elif fid == 2:
8885 
        if ftype == TType.I64:
8886 
          self.from_date = iprot.readI64();
94 ashish 8887 
        else:
8888 
          iprot.skip(ftype)
483 rajveer 8889 
      elif fid == 3:
8890 
        if ftype == TType.I64:
8891 
          self.to_date = iprot.readI64();
94 ashish 8892 
        else:
8893 
          iprot.skip(ftype)
483 rajveer 8894 
      elif fid == 4:
94 ashish 8895 
        if ftype == TType.I64:
483 rajveer 8896 
          self.warehouse_id = iprot.readI64();
94 ashish 8897 
        else:
8898 
          iprot.skip(ftype)
8899 
      else:
8900 
        iprot.skip(ftype)
8901 
      iprot.readFieldEnd()
8902 
    iprot.readStructEnd()
8903 
 
8904 
  def write(self, oprot):
8905 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8906 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8907 
      return
483 rajveer 8908 
    oprot.writeStructBegin('getAllOrders_args')
4801 anupam.sin 8909 
    if self.statuses is not None:
8910 
      oprot.writeFieldBegin('statuses', TType.LIST, 1)
8911 
      oprot.writeListBegin(TType.I32, len(self.statuses))
6000 mandeep.dh 8912 
      for iter90 in self.statuses:
8913 
        oprot.writeI32(iter90)
4801 anupam.sin 8914 
      oprot.writeListEnd()
94 ashish 8915 
      oprot.writeFieldEnd()
3431 rajveer 8916 
    if self.from_date is not None:
483 rajveer 8917 
      oprot.writeFieldBegin('from_date', TType.I64, 2)
8918 
      oprot.writeI64(self.from_date)
94 ashish 8919 
      oprot.writeFieldEnd()
3431 rajveer 8920 
    if self.to_date is not None:
483 rajveer 8921 
      oprot.writeFieldBegin('to_date', TType.I64, 3)
8922 
      oprot.writeI64(self.to_date)
94 ashish 8923 
      oprot.writeFieldEnd()
3431 rajveer 8924 
    if self.warehouse_id is not None:
483 rajveer 8925 
      oprot.writeFieldBegin('warehouse_id', TType.I64, 4)
8926 
      oprot.writeI64(self.warehouse_id)
94 ashish 8927 
      oprot.writeFieldEnd()
8928 
    oprot.writeFieldStop()
8929 
    oprot.writeStructEnd()
8930 
 
3431 rajveer 8931 
  def validate(self):
8932 
    return
8933 
 
8934 
 
94 ashish 8935 
  def __repr__(self):
8936 
    L = ['%s=%r' % (key, value)
8937 
      for key, value in self.__dict__.iteritems()]
8938 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8939 
 
8940 
  def __eq__(self, other):
8941 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8942 
 
8943 
  def __ne__(self, other):
8944 
    return not (self == other)
8945 
 
483 rajveer 8946 
class getAllOrders_result:
94 ashish 8947 
  """
8948 
  Attributes:
8949 
   - success
8950 
   - ex
8951 
  """
8952 
 
8953 
  thrift_spec = (
483 rajveer 8954 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
94 ashish 8955 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
8956 
  )
8957 
 
8958 
  def __init__(self, success=None, ex=None,):
8959 
    self.success = success
8960 
    self.ex = ex
8961 
 
8962 
  def read(self, iprot):
8963 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8964 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8965 
      return
8966 
    iprot.readStructBegin()
8967 
    while True:
8968 
      (fname, ftype, fid) = iprot.readFieldBegin()
8969 
      if ftype == TType.STOP:
8970 
        break
8971 
      if fid == 0:
483 rajveer 8972 
        if ftype == TType.LIST:
8973 
          self.success = []
6000 mandeep.dh 8974 
          (_etype94, _size91) = iprot.readListBegin()
8975 
          for _i95 in xrange(_size91):
8976 
            _elem96 = Order()
8977 
            _elem96.read(iprot)
8978 
            self.success.append(_elem96)
483 rajveer 8979 
          iprot.readListEnd()
94 ashish 8980 
        else:
8981 
          iprot.skip(ftype)
8982 
      elif fid == 1:
8983 
        if ftype == TType.STRUCT:
8984 
          self.ex = TransactionServiceException()
8985 
          self.ex.read(iprot)
8986 
        else:
8987 
          iprot.skip(ftype)
8988 
      else:
8989 
        iprot.skip(ftype)
8990 
      iprot.readFieldEnd()
8991 
    iprot.readStructEnd()
8992 
 
8993 
  def write(self, oprot):
8994 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8995 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8996 
      return
483 rajveer 8997 
    oprot.writeStructBegin('getAllOrders_result')
3431 rajveer 8998 
    if self.success is not None:
483 rajveer 8999 
      oprot.writeFieldBegin('success', TType.LIST, 0)
9000 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
6000 mandeep.dh 9001 
      for iter97 in self.success:
9002 
        iter97.write(oprot)
483 rajveer 9003 
      oprot.writeListEnd()
94 ashish 9004 
      oprot.writeFieldEnd()
3431 rajveer 9005 
    if self.ex is not None:
94 ashish 9006 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
9007 
      self.ex.write(oprot)
9008 
      oprot.writeFieldEnd()
9009 
    oprot.writeFieldStop()
9010 
    oprot.writeStructEnd()
9011 
 
3431 rajveer 9012 
  def validate(self):
9013 
    return
9014 
 
9015 
 
94 ashish 9016 
  def __repr__(self):
9017 
    L = ['%s=%r' % (key, value)
9018 
      for key, value in self.__dict__.iteritems()]
9019 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9020 
 
9021 
  def __eq__(self, other):
9022 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9023 
 
9024 
  def __ne__(self, other):
9025 
    return not (self == other)
9026 
 
4133 chandransh 9027 
class getOrdersInBatch_args:
9028 
  """
9029 
  Attributes:
9030 
   - statuses
9031 
   - offset
9032 
   - limit
9033 
   - warehouse_id
9034 
  """
9035 
 
9036 
  thrift_spec = (
9037 
    None, # 0
9038 
    (1, TType.LIST, 'statuses', (TType.I32,None), None, ), # 1
9039 
    (2, TType.I64, 'offset', None, None, ), # 2
9040 
    (3, TType.I64, 'limit', None, None, ), # 3
9041 
    (4, TType.I64, 'warehouse_id', None, None, ), # 4
9042 
  )
9043 
 
9044 
  def __init__(self, statuses=None, offset=None, limit=None, warehouse_id=None,):
9045 
    self.statuses = statuses
9046 
    self.offset = offset
9047 
    self.limit = limit
9048 
    self.warehouse_id = warehouse_id
9049 
 
9050 
  def read(self, iprot):
9051 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9052 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9053 
      return
9054 
    iprot.readStructBegin()
9055 
    while True:
9056 
      (fname, ftype, fid) = iprot.readFieldBegin()
9057 
      if ftype == TType.STOP:
9058 
        break
9059 
      if fid == 1:
9060 
        if ftype == TType.LIST:
9061 
          self.statuses = []
6000 mandeep.dh 9062 
          (_etype101, _size98) = iprot.readListBegin()
9063 
          for _i102 in xrange(_size98):
9064 
            _elem103 = iprot.readI32();
9065 
            self.statuses.append(_elem103)
4133 chandransh 9066 
          iprot.readListEnd()
9067 
        else:
9068 
          iprot.skip(ftype)
9069 
      elif fid == 2:
9070 
        if ftype == TType.I64:
9071 
          self.offset = iprot.readI64();
9072 
        else:
9073 
          iprot.skip(ftype)
9074 
      elif fid == 3:
9075 
        if ftype == TType.I64:
9076 
          self.limit = iprot.readI64();
9077 
        else:
9078 
          iprot.skip(ftype)
9079 
      elif fid == 4:
9080 
        if ftype == TType.I64:
9081 
          self.warehouse_id = iprot.readI64();
9082 
        else:
9083 
          iprot.skip(ftype)
9084 
      else:
9085 
        iprot.skip(ftype)
9086 
      iprot.readFieldEnd()
9087 
    iprot.readStructEnd()
9088 
 
9089 
  def write(self, oprot):
9090 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9091 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9092 
      return
9093 
    oprot.writeStructBegin('getOrdersInBatch_args')
9094 
    if self.statuses is not None:
9095 
      oprot.writeFieldBegin('statuses', TType.LIST, 1)
9096 
      oprot.writeListBegin(TType.I32, len(self.statuses))
6000 mandeep.dh 9097 
      for iter104 in self.statuses:
9098 
        oprot.writeI32(iter104)
4133 chandransh 9099 
      oprot.writeListEnd()
9100 
      oprot.writeFieldEnd()
9101 
    if self.offset is not None:
9102 
      oprot.writeFieldBegin('offset', TType.I64, 2)
9103 
      oprot.writeI64(self.offset)
9104 
      oprot.writeFieldEnd()
9105 
    if self.limit is not None:
9106 
      oprot.writeFieldBegin('limit', TType.I64, 3)
9107 
      oprot.writeI64(self.limit)
9108 
      oprot.writeFieldEnd()
9109 
    if self.warehouse_id is not None:
9110 
      oprot.writeFieldBegin('warehouse_id', TType.I64, 4)
9111 
      oprot.writeI64(self.warehouse_id)
9112 
      oprot.writeFieldEnd()
9113 
    oprot.writeFieldStop()
9114 
    oprot.writeStructEnd()
9115 
 
9116 
  def validate(self):
9117 
    return
9118 
 
9119 
 
9120 
  def __repr__(self):
9121 
    L = ['%s=%r' % (key, value)
9122 
      for key, value in self.__dict__.iteritems()]
9123 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9124 
 
9125 
  def __eq__(self, other):
9126 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9127 
 
9128 
  def __ne__(self, other):
9129 
    return not (self == other)
9130 
 
9131 
class getOrdersInBatch_result:
9132 
  """
9133 
  Attributes:
9134 
   - success
9135 
   - ex
9136 
  """
9137 
 
9138 
  thrift_spec = (
9139 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
9140 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
9141 
  )
9142 
 
9143 
  def __init__(self, success=None, ex=None,):
9144 
    self.success = success
9145 
    self.ex = ex
9146 
 
9147 
  def read(self, iprot):
9148 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9149 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9150 
      return
9151 
    iprot.readStructBegin()
9152 
    while True:
9153 
      (fname, ftype, fid) = iprot.readFieldBegin()
9154 
      if ftype == TType.STOP:
9155 
        break
9156 
      if fid == 0:
9157 
        if ftype == TType.LIST:
9158 
          self.success = []
6000 mandeep.dh 9159 
          (_etype108, _size105) = iprot.readListBegin()
9160 
          for _i109 in xrange(_size105):
9161 
            _elem110 = Order()
9162 
            _elem110.read(iprot)
9163 
            self.success.append(_elem110)
4133 chandransh 9164 
          iprot.readListEnd()
9165 
        else:
9166 
          iprot.skip(ftype)
9167 
      elif fid == 1:
9168 
        if ftype == TType.STRUCT:
9169 
          self.ex = TransactionServiceException()
9170 
          self.ex.read(iprot)
9171 
        else:
9172 
          iprot.skip(ftype)
9173 
      else:
9174 
        iprot.skip(ftype)
9175 
      iprot.readFieldEnd()
9176 
    iprot.readStructEnd()
9177 
 
9178 
  def write(self, oprot):
9179 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9180 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9181 
      return
9182 
    oprot.writeStructBegin('getOrdersInBatch_result')
9183 
    if self.success is not None:
9184 
      oprot.writeFieldBegin('success', TType.LIST, 0)
9185 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
6000 mandeep.dh 9186 
      for iter111 in self.success:
9187 
        iter111.write(oprot)
4133 chandransh 9188 
      oprot.writeListEnd()
9189 
      oprot.writeFieldEnd()
9190 
    if self.ex is not None:
9191 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
9192 
      self.ex.write(oprot)
9193 
      oprot.writeFieldEnd()
9194 
    oprot.writeFieldStop()
9195 
    oprot.writeStructEnd()
9196 
 
9197 
  def validate(self):
9198 
    return
9199 
 
9200 
 
9201 
  def __repr__(self):
9202 
    L = ['%s=%r' % (key, value)
9203 
      for key, value in self.__dict__.iteritems()]
9204 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9205 
 
9206 
  def __eq__(self, other):
9207 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9208 
 
9209 
  def __ne__(self, other):
9210 
    return not (self == other)
9211 
 
9212 
class getOrderCount_args:
9213 
  """
9214 
  Attributes:
9215 
   - statuses
9216 
   - warehouseId
9217 
  """
9218 
 
9219 
  thrift_spec = (
9220 
    None, # 0
9221 
    (1, TType.LIST, 'statuses', (TType.I32,None), None, ), # 1
9222 
    (2, TType.I64, 'warehouseId', None, None, ), # 2
9223 
  )
9224 
 
9225 
  def __init__(self, statuses=None, warehouseId=None,):
9226 
    self.statuses = statuses
9227 
    self.warehouseId = warehouseId
9228 
 
9229 
  def read(self, iprot):
9230 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9231 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9232 
      return
9233 
    iprot.readStructBegin()
9234 
    while True:
9235 
      (fname, ftype, fid) = iprot.readFieldBegin()
9236 
      if ftype == TType.STOP:
9237 
        break
9238 
      if fid == 1:
9239 
        if ftype == TType.LIST:
9240 
          self.statuses = []
6000 mandeep.dh 9241 
          (_etype115, _size112) = iprot.readListBegin()
9242 
          for _i116 in xrange(_size112):
9243 
            _elem117 = iprot.readI32();
9244 
            self.statuses.append(_elem117)
4133 chandransh 9245 
          iprot.readListEnd()
9246 
        else:
9247 
          iprot.skip(ftype)
9248 
      elif fid == 2:
9249 
        if ftype == TType.I64:
9250 
          self.warehouseId = iprot.readI64();
9251 
        else:
9252 
          iprot.skip(ftype)
9253 
      else:
9254 
        iprot.skip(ftype)
9255 
      iprot.readFieldEnd()
9256 
    iprot.readStructEnd()
9257 
 
9258 
  def write(self, oprot):
9259 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9260 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9261 
      return
9262 
    oprot.writeStructBegin('getOrderCount_args')
9263 
    if self.statuses is not None:
9264 
      oprot.writeFieldBegin('statuses', TType.LIST, 1)
9265 
      oprot.writeListBegin(TType.I32, len(self.statuses))
6000 mandeep.dh 9266 
      for iter118 in self.statuses:
9267 
        oprot.writeI32(iter118)
4133 chandransh 9268 
      oprot.writeListEnd()
9269 
      oprot.writeFieldEnd()
9270 
    if self.warehouseId is not None:
9271 
      oprot.writeFieldBegin('warehouseId', TType.I64, 2)
9272 
      oprot.writeI64(self.warehouseId)
9273 
      oprot.writeFieldEnd()
9274 
    oprot.writeFieldStop()
9275 
    oprot.writeStructEnd()
9276 
 
9277 
  def validate(self):
9278 
    return
9279 
 
9280 
 
9281 
  def __repr__(self):
9282 
    L = ['%s=%r' % (key, value)
9283 
      for key, value in self.__dict__.iteritems()]
9284 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9285 
 
9286 
  def __eq__(self, other):
9287 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9288 
 
9289 
  def __ne__(self, other):
9290 
    return not (self == other)
9291 
 
9292 
class getOrderCount_result:
9293 
  """
9294 
  Attributes:
9295 
   - success
9296 
   - ex
9297 
  """
9298 
 
9299 
  thrift_spec = (
9300 
    (0, TType.I32, 'success', None, None, ), # 0
9301 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
9302 
  )
9303 
 
9304 
  def __init__(self, success=None, ex=None,):
9305 
    self.success = success
9306 
    self.ex = ex
9307 
 
9308 
  def read(self, iprot):
9309 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9310 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9311 
      return
9312 
    iprot.readStructBegin()
9313 
    while True:
9314 
      (fname, ftype, fid) = iprot.readFieldBegin()
9315 
      if ftype == TType.STOP:
9316 
        break
9317 
      if fid == 0:
9318 
        if ftype == TType.I32:
9319 
          self.success = iprot.readI32();
9320 
        else:
9321 
          iprot.skip(ftype)
9322 
      elif fid == 1:
9323 
        if ftype == TType.STRUCT:
9324 
          self.ex = TransactionServiceException()
9325 
          self.ex.read(iprot)
9326 
        else:
9327 
          iprot.skip(ftype)
9328 
      else:
9329 
        iprot.skip(ftype)
9330 
      iprot.readFieldEnd()
9331 
    iprot.readStructEnd()
9332 
 
9333 
  def write(self, oprot):
9334 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9335 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9336 
      return
9337 
    oprot.writeStructBegin('getOrderCount_result')
9338 
    if self.success is not None:
9339 
      oprot.writeFieldBegin('success', TType.I32, 0)
9340 
      oprot.writeI32(self.success)
9341 
      oprot.writeFieldEnd()
9342 
    if self.ex is not None:
9343 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
9344 
      self.ex.write(oprot)
9345 
      oprot.writeFieldEnd()
9346 
    oprot.writeFieldStop()
9347 
    oprot.writeStructEnd()
9348 
 
9349 
  def validate(self):
9350 
    return
9351 
 
9352 
 
9353 
  def __repr__(self):
9354 
    L = ['%s=%r' % (key, value)
9355 
      for key, value in self.__dict__.iteritems()]
9356 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9357 
 
9358 
  def __eq__(self, other):
9359 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9360 
 
9361 
  def __ne__(self, other):
9362 
    return not (self == other)
9363 
 
999 varun.gupt 9364 
class getOrdersByBillingDate_args:
9365 
  """
9366 
  Attributes:
9367 
   - status
9368 
   - start_billing_date
9369 
   - end_billing_date
9370 
   - warehouse_id
9371 
  """
9372 
 
9373 
  thrift_spec = (
9374 
    None, # 0
9375 
    (1, TType.I32, 'status', None, None, ), # 1
9376 
    (2, TType.I64, 'start_billing_date', None, None, ), # 2
9377 
    (3, TType.I64, 'end_billing_date', None, None, ), # 3
9378 
    (4, TType.I64, 'warehouse_id', None, None, ), # 4
9379 
  )
9380 
 
9381 
  def __init__(self, status=None, start_billing_date=None, end_billing_date=None, warehouse_id=None,):
9382 
    self.status = status
9383 
    self.start_billing_date = start_billing_date
9384 
    self.end_billing_date = end_billing_date
9385 
    self.warehouse_id = warehouse_id
9386 
 
9387 
  def read(self, iprot):
9388 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9389 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9390 
      return
9391 
    iprot.readStructBegin()
9392 
    while True:
9393 
      (fname, ftype, fid) = iprot.readFieldBegin()
9394 
      if ftype == TType.STOP:
9395 
        break
9396 
      if fid == 1:
9397 
        if ftype == TType.I32:
9398 
          self.status = iprot.readI32();
9399 
        else:
9400 
          iprot.skip(ftype)
9401 
      elif fid == 2:
9402 
        if ftype == TType.I64:
9403 
          self.start_billing_date = iprot.readI64();
9404 
        else:
9405 
          iprot.skip(ftype)
9406 
      elif fid == 3:
9407 
        if ftype == TType.I64:
9408 
          self.end_billing_date = iprot.readI64();
9409 
        else:
9410 
          iprot.skip(ftype)
9411 
      elif fid == 4:
9412 
        if ftype == TType.I64:
9413 
          self.warehouse_id = iprot.readI64();
9414 
        else:
9415 
          iprot.skip(ftype)
9416 
      else:
9417 
        iprot.skip(ftype)
9418 
      iprot.readFieldEnd()
9419 
    iprot.readStructEnd()
9420 
 
9421 
  def write(self, oprot):
9422 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9423 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9424 
      return
9425 
    oprot.writeStructBegin('getOrdersByBillingDate_args')
3431 rajveer 9426 
    if self.status is not None:
999 varun.gupt 9427 
      oprot.writeFieldBegin('status', TType.I32, 1)
9428 
      oprot.writeI32(self.status)
9429 
      oprot.writeFieldEnd()
3431 rajveer 9430 
    if self.start_billing_date is not None:
999 varun.gupt 9431 
      oprot.writeFieldBegin('start_billing_date', TType.I64, 2)
9432 
      oprot.writeI64(self.start_billing_date)
9433 
      oprot.writeFieldEnd()
3431 rajveer 9434 
    if self.end_billing_date is not None:
999 varun.gupt 9435 
      oprot.writeFieldBegin('end_billing_date', TType.I64, 3)
9436 
      oprot.writeI64(self.end_billing_date)
9437 
      oprot.writeFieldEnd()
3431 rajveer 9438 
    if self.warehouse_id is not None:
999 varun.gupt 9439 
      oprot.writeFieldBegin('warehouse_id', TType.I64, 4)
9440 
      oprot.writeI64(self.warehouse_id)
9441 
      oprot.writeFieldEnd()
9442 
    oprot.writeFieldStop()
9443 
    oprot.writeStructEnd()
9444 
 
3431 rajveer 9445 
  def validate(self):
9446 
    return
9447 
 
9448 
 
999 varun.gupt 9449 
  def __repr__(self):
9450 
    L = ['%s=%r' % (key, value)
9451 
      for key, value in self.__dict__.iteritems()]
9452 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9453 
 
9454 
  def __eq__(self, other):
9455 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9456 
 
9457 
  def __ne__(self, other):
9458 
    return not (self == other)
9459 
 
9460 
class getOrdersByBillingDate_result:
9461 
  """
9462 
  Attributes:
9463 
   - success
9464 
   - ex
9465 
  """
9466 
 
9467 
  thrift_spec = (
9468 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
9469 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
9470 
  )
9471 
 
9472 
  def __init__(self, success=None, ex=None,):
9473 
    self.success = success
9474 
    self.ex = ex
9475 
 
9476 
  def read(self, iprot):
9477 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9478 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9479 
      return
9480 
    iprot.readStructBegin()
9481 
    while True:
9482 
      (fname, ftype, fid) = iprot.readFieldBegin()
9483 
      if ftype == TType.STOP:
9484 
        break
9485 
      if fid == 0:
9486 
        if ftype == TType.LIST:
9487 
          self.success = []
6000 mandeep.dh 9488 
          (_etype122, _size119) = iprot.readListBegin()
9489 
          for _i123 in xrange(_size119):
9490 
            _elem124 = Order()
9491 
            _elem124.read(iprot)
9492 
            self.success.append(_elem124)
999 varun.gupt 9493 
          iprot.readListEnd()
9494 
        else:
9495 
          iprot.skip(ftype)
9496 
      elif fid == 1:
9497 
        if ftype == TType.STRUCT:
9498 
          self.ex = TransactionServiceException()
9499 
          self.ex.read(iprot)
9500 
        else:
9501 
          iprot.skip(ftype)
9502 
      else:
9503 
        iprot.skip(ftype)
9504 
      iprot.readFieldEnd()
9505 
    iprot.readStructEnd()
9506 
 
9507 
  def write(self, oprot):
9508 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9509 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9510 
      return
9511 
    oprot.writeStructBegin('getOrdersByBillingDate_result')
3431 rajveer 9512 
    if self.success is not None:
999 varun.gupt 9513 
      oprot.writeFieldBegin('success', TType.LIST, 0)
9514 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
6000 mandeep.dh 9515 
      for iter125 in self.success:
9516 
        iter125.write(oprot)
999 varun.gupt 9517 
      oprot.writeListEnd()
9518 
      oprot.writeFieldEnd()
3431 rajveer 9519 
    if self.ex is not None:
999 varun.gupt 9520 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
9521 
      self.ex.write(oprot)
9522 
      oprot.writeFieldEnd()
9523 
    oprot.writeFieldStop()
9524 
    oprot.writeStructEnd()
9525 
 
3431 rajveer 9526 
  def validate(self):
9527 
    return
9528 
 
9529 
 
999 varun.gupt 9530 
  def __repr__(self):
9531 
    L = ['%s=%r' % (key, value)
9532 
      for key, value in self.__dict__.iteritems()]
9533 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9534 
 
9535 
  def __eq__(self, other):
9536 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9537 
 
9538 
  def __ne__(self, other):
9539 
    return not (self == other)
9540 
 
3427 chandransh 9541 
class getOrdersByShippingDate_args:
9542 
  """
9543 
  Attributes:
9544 
   - fromShippingDate
9545 
   - toShippingDate
9546 
   - providerId
9547 
   - warehouseId
3451 chandransh 9548 
   - cod
3427 chandransh 9549 
  """
9550 
 
9551 
  thrift_spec = (
9552 
    None, # 0
9553 
    (1, TType.I64, 'fromShippingDate', None, None, ), # 1
9554 
    (2, TType.I64, 'toShippingDate', None, None, ), # 2
9555 
    (3, TType.I64, 'providerId', None, None, ), # 3
9556 
    (4, TType.I64, 'warehouseId', None, None, ), # 4
3451 chandransh 9557 
    (5, TType.BOOL, 'cod', None, None, ), # 5
3427 chandransh 9558 
  )
9559 
 
3451 chandransh 9560 
  def __init__(self, fromShippingDate=None, toShippingDate=None, providerId=None, warehouseId=None, cod=None,):
3427 chandransh 9561 
    self.fromShippingDate = fromShippingDate
9562 
    self.toShippingDate = toShippingDate
9563 
    self.providerId = providerId
9564 
    self.warehouseId = warehouseId
3451 chandransh 9565 
    self.cod = cod
3427 chandransh 9566 
 
9567 
  def read(self, iprot):
9568 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9569 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9570 
      return
9571 
    iprot.readStructBegin()
9572 
    while True:
9573 
      (fname, ftype, fid) = iprot.readFieldBegin()
9574 
      if ftype == TType.STOP:
9575 
        break
9576 
      if fid == 1:
9577 
        if ftype == TType.I64:
9578 
          self.fromShippingDate = iprot.readI64();
9579 
        else:
9580 
          iprot.skip(ftype)
9581 
      elif fid == 2:
9582 
        if ftype == TType.I64:
9583 
          self.toShippingDate = iprot.readI64();
9584 
        else:
9585 
          iprot.skip(ftype)
9586 
      elif fid == 3:
9587 
        if ftype == TType.I64:
9588 
          self.providerId = iprot.readI64();
9589 
        else:
9590 
          iprot.skip(ftype)
9591 
      elif fid == 4:
9592 
        if ftype == TType.I64:
9593 
          self.warehouseId = iprot.readI64();
9594 
        else:
9595 
          iprot.skip(ftype)
3451 chandransh 9596 
      elif fid == 5:
9597 
        if ftype == TType.BOOL:
9598 
          self.cod = iprot.readBool();
9599 
        else:
9600 
          iprot.skip(ftype)
3427 chandransh 9601 
      else:
9602 
        iprot.skip(ftype)
9603 
      iprot.readFieldEnd()
9604 
    iprot.readStructEnd()
9605 
 
9606 
  def write(self, oprot):
9607 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9608 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9609 
      return
9610 
    oprot.writeStructBegin('getOrdersByShippingDate_args')
3431 rajveer 9611 
    if self.fromShippingDate is not None:
3427 chandransh 9612 
      oprot.writeFieldBegin('fromShippingDate', TType.I64, 1)
9613 
      oprot.writeI64(self.fromShippingDate)
9614 
      oprot.writeFieldEnd()
3431 rajveer 9615 
    if self.toShippingDate is not None:
3427 chandransh 9616 
      oprot.writeFieldBegin('toShippingDate', TType.I64, 2)
9617 
      oprot.writeI64(self.toShippingDate)
9618 
      oprot.writeFieldEnd()
3431 rajveer 9619 
    if self.providerId is not None:
3427 chandransh 9620 
      oprot.writeFieldBegin('providerId', TType.I64, 3)
9621 
      oprot.writeI64(self.providerId)
9622 
      oprot.writeFieldEnd()
3431 rajveer 9623 
    if self.warehouseId is not None:
3427 chandransh 9624 
      oprot.writeFieldBegin('warehouseId', TType.I64, 4)
9625 
      oprot.writeI64(self.warehouseId)
9626 
      oprot.writeFieldEnd()
3451 chandransh 9627 
    if self.cod is not None:
9628 
      oprot.writeFieldBegin('cod', TType.BOOL, 5)
9629 
      oprot.writeBool(self.cod)
9630 
      oprot.writeFieldEnd()
3427 chandransh 9631 
    oprot.writeFieldStop()
9632 
    oprot.writeStructEnd()
9633 
 
3431 rajveer 9634 
  def validate(self):
9635 
    return
9636 
 
9637 
 
3427 chandransh 9638 
  def __repr__(self):
9639 
    L = ['%s=%r' % (key, value)
9640 
      for key, value in self.__dict__.iteritems()]
9641 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9642 
 
9643 
  def __eq__(self, other):
9644 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9645 
 
9646 
  def __ne__(self, other):
9647 
    return not (self == other)
9648 
 
9649 
class getOrdersByShippingDate_result:
9650 
  """
9651 
  Attributes:
9652 
   - success
9653 
   - ex
9654 
  """
9655 
 
9656 
  thrift_spec = (
9657 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
9658 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
9659 
  )
9660 
 
9661 
  def __init__(self, success=None, ex=None,):
9662 
    self.success = success
9663 
    self.ex = ex
9664 
 
9665 
  def read(self, iprot):
9666 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9667 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9668 
      return
9669 
    iprot.readStructBegin()
9670 
    while True:
9671 
      (fname, ftype, fid) = iprot.readFieldBegin()
9672 
      if ftype == TType.STOP:
9673 
        break
9674 
      if fid == 0:
9675 
        if ftype == TType.LIST:
9676 
          self.success = []
6000 mandeep.dh 9677 
          (_etype129, _size126) = iprot.readListBegin()
9678 
          for _i130 in xrange(_size126):
9679 
            _elem131 = Order()
9680 
            _elem131.read(iprot)
9681 
            self.success.append(_elem131)
3427 chandransh 9682 
          iprot.readListEnd()
9683 
        else:
9684 
          iprot.skip(ftype)
9685 
      elif fid == 1:
9686 
        if ftype == TType.STRUCT:
9687 
          self.ex = TransactionServiceException()
9688 
          self.ex.read(iprot)
9689 
        else:
9690 
          iprot.skip(ftype)
9691 
      else:
9692 
        iprot.skip(ftype)
9693 
      iprot.readFieldEnd()
9694 
    iprot.readStructEnd()
9695 
 
9696 
  def write(self, oprot):
9697 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9698 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9699 
      return
9700 
    oprot.writeStructBegin('getOrdersByShippingDate_result')
3431 rajveer 9701 
    if self.success is not None:
3427 chandransh 9702 
      oprot.writeFieldBegin('success', TType.LIST, 0)
9703 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
6000 mandeep.dh 9704 
      for iter132 in self.success:
9705 
        iter132.write(oprot)
3427 chandransh 9706 
      oprot.writeListEnd()
9707 
      oprot.writeFieldEnd()
3431 rajveer 9708 
    if self.ex is not None:
3427 chandransh 9709 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
9710 
      self.ex.write(oprot)
9711 
      oprot.writeFieldEnd()
9712 
    oprot.writeFieldStop()
9713 
    oprot.writeStructEnd()
9714 
 
3431 rajveer 9715 
  def validate(self):
9716 
    return
9717 
 
9718 
 
3427 chandransh 9719 
  def __repr__(self):
9720 
    L = ['%s=%r' % (key, value)
9721 
      for key, value in self.__dict__.iteritems()]
9722 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9723 
 
9724 
  def __eq__(self, other):
9725 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9726 
 
9727 
  def __ne__(self, other):
9728 
    return not (self == other)
9729 
 
1382 varun.gupt 9730 
class getReturnableOrdersForCustomer_args:
9731 
  """
9732 
  Attributes:
9733 
   - customer_id
9734 
   - limit
9735 
  """
9736 
 
9737 
  thrift_spec = (
9738 
    None, # 0
9739 
    (1, TType.I64, 'customer_id', None, None, ), # 1
9740 
    (2, TType.I64, 'limit', None, None, ), # 2
9741 
  )
9742 
 
9743 
  def __init__(self, customer_id=None, limit=None,):
9744 
    self.customer_id = customer_id
9745 
    self.limit = limit
9746 
 
9747 
  def read(self, iprot):
9748 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9749 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9750 
      return
9751 
    iprot.readStructBegin()
9752 
    while True:
9753 
      (fname, ftype, fid) = iprot.readFieldBegin()
9754 
      if ftype == TType.STOP:
9755 
        break
9756 
      if fid == 1:
9757 
        if ftype == TType.I64:
9758 
          self.customer_id = iprot.readI64();
9759 
        else:
9760 
          iprot.skip(ftype)
9761 
      elif fid == 2:
9762 
        if ftype == TType.I64:
9763 
          self.limit = iprot.readI64();
9764 
        else:
9765 
          iprot.skip(ftype)
9766 
      else:
9767 
        iprot.skip(ftype)
9768 
      iprot.readFieldEnd()
9769 
    iprot.readStructEnd()
9770 
 
9771 
  def write(self, oprot):
9772 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9773 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9774 
      return
9775 
    oprot.writeStructBegin('getReturnableOrdersForCustomer_args')
3431 rajveer 9776 
    if self.customer_id is not None:
1382 varun.gupt 9777 
      oprot.writeFieldBegin('customer_id', TType.I64, 1)
9778 
      oprot.writeI64(self.customer_id)
9779 
      oprot.writeFieldEnd()
3431 rajveer 9780 
    if self.limit is not None:
1382 varun.gupt 9781 
      oprot.writeFieldBegin('limit', TType.I64, 2)
9782 
      oprot.writeI64(self.limit)
9783 
      oprot.writeFieldEnd()
9784 
    oprot.writeFieldStop()
9785 
    oprot.writeStructEnd()
9786 
 
3431 rajveer 9787 
  def validate(self):
9788 
    return
9789 
 
9790 
 
1382 varun.gupt 9791 
  def __repr__(self):
9792 
    L = ['%s=%r' % (key, value)
9793 
      for key, value in self.__dict__.iteritems()]
9794 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9795 
 
9796 
  def __eq__(self, other):
9797 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9798 
 
9799 
  def __ne__(self, other):
9800 
    return not (self == other)
9801 
 
9802 
class getReturnableOrdersForCustomer_result:
9803 
  """
9804 
  Attributes:
9805 
   - success
9806 
   - ex
9807 
  """
9808 
 
9809 
  thrift_spec = (
9810 
    (0, TType.LIST, 'success', (TType.I64,None), None, ), # 0
9811 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
9812 
  )
9813 
 
9814 
  def __init__(self, success=None, ex=None,):
9815 
    self.success = success
9816 
    self.ex = ex
9817 
 
9818 
  def read(self, iprot):
9819 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9820 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9821 
      return
9822 
    iprot.readStructBegin()
9823 
    while True:
9824 
      (fname, ftype, fid) = iprot.readFieldBegin()
9825 
      if ftype == TType.STOP:
9826 
        break
9827 
      if fid == 0:
9828 
        if ftype == TType.LIST:
9829 
          self.success = []
6000 mandeep.dh 9830 
          (_etype136, _size133) = iprot.readListBegin()
9831 
          for _i137 in xrange(_size133):
9832 
            _elem138 = iprot.readI64();
9833 
            self.success.append(_elem138)
1382 varun.gupt 9834 
          iprot.readListEnd()
9835 
        else:
9836 
          iprot.skip(ftype)
9837 
      elif fid == 1:
9838 
        if ftype == TType.STRUCT:
9839 
          self.ex = TransactionServiceException()
9840 
          self.ex.read(iprot)
9841 
        else:
9842 
          iprot.skip(ftype)
9843 
      else:
9844 
        iprot.skip(ftype)
9845 
      iprot.readFieldEnd()
9846 
    iprot.readStructEnd()
9847 
 
9848 
  def write(self, oprot):
9849 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9850 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9851 
      return
9852 
    oprot.writeStructBegin('getReturnableOrdersForCustomer_result')
3431 rajveer 9853 
    if self.success is not None:
1382 varun.gupt 9854 
      oprot.writeFieldBegin('success', TType.LIST, 0)
9855 
      oprot.writeListBegin(TType.I64, len(self.success))
6000 mandeep.dh 9856 
      for iter139 in self.success:
9857 
        oprot.writeI64(iter139)
1382 varun.gupt 9858 
      oprot.writeListEnd()
9859 
      oprot.writeFieldEnd()
3431 rajveer 9860 
    if self.ex is not None:
1382 varun.gupt 9861 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
9862 
      self.ex.write(oprot)
9863 
      oprot.writeFieldEnd()
9864 
    oprot.writeFieldStop()
9865 
    oprot.writeStructEnd()
9866 
 
3431 rajveer 9867 
  def validate(self):
9868 
    return
9869 
 
9870 
 
1382 varun.gupt 9871 
  def __repr__(self):
9872 
    L = ['%s=%r' % (key, value)
9873 
      for key, value in self.__dict__.iteritems()]
9874 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9875 
 
9876 
  def __eq__(self, other):
9877 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9878 
 
9879 
  def __ne__(self, other):
9880 
    return not (self == other)
9881 
 
9882 
class getCancellableOrdersForCustomer_args:
9883 
  """
9884 
  Attributes:
9885 
   - customer_id
9886 
   - limit
9887 
  """
9888 
 
9889 
  thrift_spec = (
9890 
    None, # 0
9891 
    (1, TType.I64, 'customer_id', None, None, ), # 1
9892 
    (2, TType.I64, 'limit', None, None, ), # 2
9893 
  )
9894 
 
9895 
  def __init__(self, customer_id=None, limit=None,):
9896 
    self.customer_id = customer_id
9897 
    self.limit = limit
9898 
 
9899 
  def read(self, iprot):
9900 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9901 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9902 
      return
9903 
    iprot.readStructBegin()
9904 
    while True:
9905 
      (fname, ftype, fid) = iprot.readFieldBegin()
9906 
      if ftype == TType.STOP:
9907 
        break
9908 
      if fid == 1:
9909 
        if ftype == TType.I64:
9910 
          self.customer_id = iprot.readI64();
9911 
        else:
9912 
          iprot.skip(ftype)
9913 
      elif fid == 2:
9914 
        if ftype == TType.I64:
9915 
          self.limit = iprot.readI64();
9916 
        else:
9917 
          iprot.skip(ftype)
9918 
      else:
9919 
        iprot.skip(ftype)
9920 
      iprot.readFieldEnd()
9921 
    iprot.readStructEnd()
9922 
 
9923 
  def write(self, oprot):
9924 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9925 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9926 
      return
9927 
    oprot.writeStructBegin('getCancellableOrdersForCustomer_args')
3431 rajveer 9928 
    if self.customer_id is not None:
1382 varun.gupt 9929 
      oprot.writeFieldBegin('customer_id', TType.I64, 1)
9930 
      oprot.writeI64(self.customer_id)
9931 
      oprot.writeFieldEnd()
3431 rajveer 9932 
    if self.limit is not None:
1382 varun.gupt 9933 
      oprot.writeFieldBegin('limit', TType.I64, 2)
9934 
      oprot.writeI64(self.limit)
9935 
      oprot.writeFieldEnd()
9936 
    oprot.writeFieldStop()
9937 
    oprot.writeStructEnd()
9938 
 
3431 rajveer 9939 
  def validate(self):
9940 
    return
9941 
 
9942 
 
1382 varun.gupt 9943 
  def __repr__(self):
9944 
    L = ['%s=%r' % (key, value)
9945 
      for key, value in self.__dict__.iteritems()]
9946 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9947 
 
9948 
  def __eq__(self, other):
9949 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9950 
 
9951 
  def __ne__(self, other):
9952 
    return not (self == other)
9953 
 
9954 
class getCancellableOrdersForCustomer_result:
9955 
  """
9956 
  Attributes:
9957 
   - success
9958 
   - ex
9959 
  """
9960 
 
9961 
  thrift_spec = (
9962 
    (0, TType.LIST, 'success', (TType.I64,None), None, ), # 0
9963 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
9964 
  )
9965 
 
9966 
  def __init__(self, success=None, ex=None,):
9967 
    self.success = success
9968 
    self.ex = ex
9969 
 
9970 
  def read(self, iprot):
9971 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9972 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9973 
      return
9974 
    iprot.readStructBegin()
9975 
    while True:
9976 
      (fname, ftype, fid) = iprot.readFieldBegin()
9977 
      if ftype == TType.STOP:
9978 
        break
9979 
      if fid == 0:
9980 
        if ftype == TType.LIST:
9981 
          self.success = []
6000 mandeep.dh 9982 
          (_etype143, _size140) = iprot.readListBegin()
9983 
          for _i144 in xrange(_size140):
9984 
            _elem145 = iprot.readI64();
9985 
            self.success.append(_elem145)
1382 varun.gupt 9986 
          iprot.readListEnd()
9987 
        else:
9988 
          iprot.skip(ftype)
9989 
      elif fid == 1:
9990 
        if ftype == TType.STRUCT:
9991 
          self.ex = TransactionServiceException()
9992 
          self.ex.read(iprot)
9993 
        else:
9994 
          iprot.skip(ftype)
9995 
      else:
9996 
        iprot.skip(ftype)
9997 
      iprot.readFieldEnd()
9998 
    iprot.readStructEnd()
9999 
 
10000 
  def write(self, oprot):
10001 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10002 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10003 
      return
10004 
    oprot.writeStructBegin('getCancellableOrdersForCustomer_result')
3431 rajveer 10005 
    if self.success is not None:
1382 varun.gupt 10006 
      oprot.writeFieldBegin('success', TType.LIST, 0)
10007 
      oprot.writeListBegin(TType.I64, len(self.success))
6000 mandeep.dh 10008 
      for iter146 in self.success:
10009 
        oprot.writeI64(iter146)
1382 varun.gupt 10010 
      oprot.writeListEnd()
10011 
      oprot.writeFieldEnd()
3431 rajveer 10012 
    if self.ex is not None:
1382 varun.gupt 10013 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
10014 
      self.ex.write(oprot)
10015 
      oprot.writeFieldEnd()
10016 
    oprot.writeFieldStop()
10017 
    oprot.writeStructEnd()
10018 
 
3431 rajveer 10019 
  def validate(self):
10020 
    return
10021 
 
10022 
 
1382 varun.gupt 10023 
  def __repr__(self):
10024 
    L = ['%s=%r' % (key, value)
10025 
      for key, value in self.__dict__.iteritems()]
10026 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10027 
 
10028 
  def __eq__(self, other):
10029 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10030 
 
10031 
  def __ne__(self, other):
10032 
    return not (self == other)
10033 
 
483 rajveer 10034 
class changeOrderStatus_args:
94 ashish 10035 
  """
10036 
  Attributes:
483 rajveer 10037 
   - orderId
10038 
   - status
10039 
   - description
94 ashish 10040 
  """
10041 
 
10042 
  thrift_spec = (
10043 
    None, # 0
483 rajveer 10044 
    (1, TType.I64, 'orderId', None, None, ), # 1
10045 
    (2, TType.I32, 'status', None, None, ), # 2
10046 
    (3, TType.STRING, 'description', None, None, ), # 3
94 ashish 10047 
  )
10048 
 
483 rajveer 10049 
  def __init__(self, orderId=None, status=None, description=None,):
10050 
    self.orderId = orderId
10051 
    self.status = status
10052 
    self.description = description
94 ashish 10053 
 
10054 
  def read(self, iprot):
10055 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10056 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10057 
      return
10058 
    iprot.readStructBegin()
10059 
    while True:
10060 
      (fname, ftype, fid) = iprot.readFieldBegin()
10061 
      if ftype == TType.STOP:
10062 
        break
10063 
      if fid == 1:
10064 
        if ftype == TType.I64:
483 rajveer 10065 
          self.orderId = iprot.readI64();
94 ashish 10066 
        else:
10067 
          iprot.skip(ftype)
10068 
      elif fid == 2:
483 rajveer 10069 
        if ftype == TType.I32:
10070 
          self.status = iprot.readI32();
94 ashish 10071 
        else:
10072 
          iprot.skip(ftype)
483 rajveer 10073 
      elif fid == 3:
10074 
        if ftype == TType.STRING:
10075 
          self.description = iprot.readString();
10076 
        else:
10077 
          iprot.skip(ftype)
94 ashish 10078 
      else:
10079 
        iprot.skip(ftype)
10080 
      iprot.readFieldEnd()
10081 
    iprot.readStructEnd()
10082 
 
10083 
  def write(self, oprot):
10084 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10085 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10086 
      return
483 rajveer 10087 
    oprot.writeStructBegin('changeOrderStatus_args')
3431 rajveer 10088 
    if self.orderId is not None:
483 rajveer 10089 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
10090 
      oprot.writeI64(self.orderId)
94 ashish 10091 
      oprot.writeFieldEnd()
3431 rajveer 10092 
    if self.status is not None:
483 rajveer 10093 
      oprot.writeFieldBegin('status', TType.I32, 2)
10094 
      oprot.writeI32(self.status)
94 ashish 10095 
      oprot.writeFieldEnd()
3431 rajveer 10096 
    if self.description is not None:
483 rajveer 10097 
      oprot.writeFieldBegin('description', TType.STRING, 3)
10098 
      oprot.writeString(self.description)
10099 
      oprot.writeFieldEnd()
94 ashish 10100 
    oprot.writeFieldStop()
10101 
    oprot.writeStructEnd()
10102 
 
3431 rajveer 10103 
  def validate(self):
10104 
    return
10105 
 
10106 
 
94 ashish 10107 
  def __repr__(self):
10108 
    L = ['%s=%r' % (key, value)
10109 
      for key, value in self.__dict__.iteritems()]
10110 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10111 
 
10112 
  def __eq__(self, other):
10113 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10114 
 
10115 
  def __ne__(self, other):
10116 
    return not (self == other)
10117 
 
483 rajveer 10118 
class changeOrderStatus_result:
94 ashish 10119 
  """
10120 
  Attributes:
10121 
   - success
10122 
   - ex
10123 
  """
10124 
 
10125 
  thrift_spec = (
10126 
    (0, TType.BOOL, 'success', None, None, ), # 0
10127 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
10128 
  )
10129 
 
10130 
  def __init__(self, success=None, ex=None,):
10131 
    self.success = success
10132 
    self.ex = ex
10133 
 
10134 
  def read(self, iprot):
10135 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10136 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10137 
      return
10138 
    iprot.readStructBegin()
10139 
    while True:
10140 
      (fname, ftype, fid) = iprot.readFieldBegin()
10141 
      if ftype == TType.STOP:
10142 
        break
10143 
      if fid == 0:
10144 
        if ftype == TType.BOOL:
10145 
          self.success = iprot.readBool();
10146 
        else:
10147 
          iprot.skip(ftype)
10148 
      elif fid == 1:
10149 
        if ftype == TType.STRUCT:
10150 
          self.ex = TransactionServiceException()
10151 
          self.ex.read(iprot)
10152 
        else:
10153 
          iprot.skip(ftype)
10154 
      else:
10155 
        iprot.skip(ftype)
10156 
      iprot.readFieldEnd()
10157 
    iprot.readStructEnd()
10158 
 
10159 
  def write(self, oprot):
10160 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10161 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10162 
      return
483 rajveer 10163 
    oprot.writeStructBegin('changeOrderStatus_result')
3431 rajveer 10164 
    if self.success is not None:
94 ashish 10165 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
10166 
      oprot.writeBool(self.success)
10167 
      oprot.writeFieldEnd()
3431 rajveer 10168 
    if self.ex is not None:
94 ashish 10169 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
10170 
      self.ex.write(oprot)
10171 
      oprot.writeFieldEnd()
10172 
    oprot.writeFieldStop()
10173 
    oprot.writeStructEnd()
10174 
 
3431 rajveer 10175 
  def validate(self):
10176 
    return
10177 
 
10178 
 
94 ashish 10179 
  def __repr__(self):
10180 
    L = ['%s=%r' % (key, value)
10181 
      for key, value in self.__dict__.iteritems()]
10182 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10183 
 
10184 
  def __eq__(self, other):
10185 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10186 
 
10187 
  def __ne__(self, other):
10188 
    return not (self == other)
10189 
 
3064 chandransh 10190 
class getOrdersForTransaction_args:
494 rajveer 10191 
  """
10192 
  Attributes:
3064 chandransh 10193 
   - transactionId
10194 
   - customerId
494 rajveer 10195 
  """
10196 
 
10197 
  thrift_spec = (
10198 
    None, # 0
3064 chandransh 10199 
    (1, TType.I64, 'transactionId', None, None, ), # 1
10200 
    (2, TType.I64, 'customerId', None, None, ), # 2
494 rajveer 10201 
  )
10202 
 
3064 chandransh 10203 
  def __init__(self, transactionId=None, customerId=None,):
10204 
    self.transactionId = transactionId
10205 
    self.customerId = customerId
494 rajveer 10206 
 
10207 
  def read(self, iprot):
10208 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10209 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10210 
      return
10211 
    iprot.readStructBegin()
10212 
    while True:
10213 
      (fname, ftype, fid) = iprot.readFieldBegin()
10214 
      if ftype == TType.STOP:
10215 
        break
10216 
      if fid == 1:
10217 
        if ftype == TType.I64:
3064 chandransh 10218 
          self.transactionId = iprot.readI64();
494 rajveer 10219 
        else:
10220 
          iprot.skip(ftype)
10221 
      elif fid == 2:
3064 chandransh 10222 
        if ftype == TType.I64:
10223 
          self.customerId = iprot.readI64();
494 rajveer 10224 
        else:
10225 
          iprot.skip(ftype)
10226 
      else:
10227 
        iprot.skip(ftype)
10228 
      iprot.readFieldEnd()
10229 
    iprot.readStructEnd()
10230 
 
10231 
  def write(self, oprot):
10232 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10233 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10234 
      return
3064 chandransh 10235 
    oprot.writeStructBegin('getOrdersForTransaction_args')
3431 rajveer 10236 
    if self.transactionId is not None:
3064 chandransh 10237 
      oprot.writeFieldBegin('transactionId', TType.I64, 1)
10238 
      oprot.writeI64(self.transactionId)
494 rajveer 10239 
      oprot.writeFieldEnd()
3431 rajveer 10240 
    if self.customerId is not None:
3064 chandransh 10241 
      oprot.writeFieldBegin('customerId', TType.I64, 2)
10242 
      oprot.writeI64(self.customerId)
494 rajveer 10243 
      oprot.writeFieldEnd()
10244 
    oprot.writeFieldStop()
10245 
    oprot.writeStructEnd()
10246 
 
3431 rajveer 10247 
  def validate(self):
10248 
    return
10249 
 
10250 
 
494 rajveer 10251 
  def __repr__(self):
10252 
    L = ['%s=%r' % (key, value)
10253 
      for key, value in self.__dict__.iteritems()]
10254 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10255 
 
10256 
  def __eq__(self, other):
10257 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10258 
 
10259 
  def __ne__(self, other):
10260 
    return not (self == other)
10261 
 
3064 chandransh 10262 
class getOrdersForTransaction_result:
494 rajveer 10263 
  """
10264 
  Attributes:
10265 
   - success
10266 
   - ex
10267 
  """
10268 
 
10269 
  thrift_spec = (
3064 chandransh 10270 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
494 rajveer 10271 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
10272 
  )
10273 
 
10274 
  def __init__(self, success=None, ex=None,):
10275 
    self.success = success
10276 
    self.ex = ex
10277 
 
10278 
  def read(self, iprot):
10279 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10280 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10281 
      return
10282 
    iprot.readStructBegin()
10283 
    while True:
10284 
      (fname, ftype, fid) = iprot.readFieldBegin()
10285 
      if ftype == TType.STOP:
10286 
        break
10287 
      if fid == 0:
3064 chandransh 10288 
        if ftype == TType.LIST:
10289 
          self.success = []
6000 mandeep.dh 10290 
          (_etype150, _size147) = iprot.readListBegin()
10291 
          for _i151 in xrange(_size147):
10292 
            _elem152 = Order()
10293 
            _elem152.read(iprot)
10294 
            self.success.append(_elem152)
3064 chandransh 10295 
          iprot.readListEnd()
494 rajveer 10296 
        else:
10297 
          iprot.skip(ftype)
10298 
      elif fid == 1:
10299 
        if ftype == TType.STRUCT:
10300 
          self.ex = TransactionServiceException()
10301 
          self.ex.read(iprot)
10302 
        else:
10303 
          iprot.skip(ftype)
10304 
      else:
10305 
        iprot.skip(ftype)
10306 
      iprot.readFieldEnd()
10307 
    iprot.readStructEnd()
10308 
 
10309 
  def write(self, oprot):
10310 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10311 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10312 
      return
3064 chandransh 10313 
    oprot.writeStructBegin('getOrdersForTransaction_result')
3431 rajveer 10314 
    if self.success is not None:
3064 chandransh 10315 
      oprot.writeFieldBegin('success', TType.LIST, 0)
10316 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
6000 mandeep.dh 10317 
      for iter153 in self.success:
10318 
        iter153.write(oprot)
3064 chandransh 10319 
      oprot.writeListEnd()
494 rajveer 10320 
      oprot.writeFieldEnd()
3431 rajveer 10321 
    if self.ex is not None:
494 rajveer 10322 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
10323 
      self.ex.write(oprot)
10324 
      oprot.writeFieldEnd()
10325 
    oprot.writeFieldStop()
10326 
    oprot.writeStructEnd()
10327 
 
3431 rajveer 10328 
  def validate(self):
10329 
    return
10330 
 
10331 
 
494 rajveer 10332 
  def __repr__(self):
10333 
    L = ['%s=%r' % (key, value)
10334 
      for key, value in self.__dict__.iteritems()]
10335 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10336 
 
10337 
  def __eq__(self, other):
10338 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10339 
 
10340 
  def __ne__(self, other):
10341 
    return not (self == other)
10342 
 
3064 chandransh 10343 
class getOrdersForCustomer_args:
1149 chandransh 10344 
  """
10345 
  Attributes:
3064 chandransh 10346 
   - customerId
10347 
   - from_date
10348 
   - to_date
10349 
   - statuses
1149 chandransh 10350 
  """
10351 
 
10352 
  thrift_spec = (
10353 
    None, # 0
3064 chandransh 10354 
    (1, TType.I64, 'customerId', None, None, ), # 1
10355 
    (2, TType.I64, 'from_date', None, None, ), # 2
10356 
    (3, TType.I64, 'to_date', None, None, ), # 3
10357 
    (4, TType.LIST, 'statuses', (TType.I32,None), None, ), # 4
1149 chandransh 10358 
  )
10359 
 
3064 chandransh 10360 
  def __init__(self, customerId=None, from_date=None, to_date=None, statuses=None,):
10361 
    self.customerId = customerId
10362 
    self.from_date = from_date
10363 
    self.to_date = to_date
10364 
    self.statuses = statuses
1149 chandransh 10365 
 
10366 
  def read(self, iprot):
10367 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10368 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10369 
      return
10370 
    iprot.readStructBegin()
10371 
    while True:
10372 
      (fname, ftype, fid) = iprot.readFieldBegin()
10373 
      if ftype == TType.STOP:
10374 
        break
10375 
      if fid == 1:
10376 
        if ftype == TType.I64:
3064 chandransh 10377 
          self.customerId = iprot.readI64();
1149 chandransh 10378 
        else:
10379 
          iprot.skip(ftype)
10380 
      elif fid == 2:
10381 
        if ftype == TType.I64:
3064 chandransh 10382 
          self.from_date = iprot.readI64();
1149 chandransh 10383 
        else:
10384 
          iprot.skip(ftype)
2783 chandransh 10385 
      elif fid == 3:
10386 
        if ftype == TType.I64:
3064 chandransh 10387 
          self.to_date = iprot.readI64();
2783 chandransh 10388 
        else:
10389 
          iprot.skip(ftype)
10390 
      elif fid == 4:
3064 chandransh 10391 
        if ftype == TType.LIST:
10392 
          self.statuses = []
6000 mandeep.dh 10393 
          (_etype157, _size154) = iprot.readListBegin()
10394 
          for _i158 in xrange(_size154):
10395 
            _elem159 = iprot.readI32();
10396 
            self.statuses.append(_elem159)
3064 chandransh 10397 
          iprot.readListEnd()
2783 chandransh 10398 
        else:
10399 
          iprot.skip(ftype)
1149 chandransh 10400 
      else:
10401 
        iprot.skip(ftype)
10402 
      iprot.readFieldEnd()
10403 
    iprot.readStructEnd()
10404 
 
10405 
  def write(self, oprot):
10406 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10407 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10408 
      return
3064 chandransh 10409 
    oprot.writeStructBegin('getOrdersForCustomer_args')
3431 rajveer 10410 
    if self.customerId is not None:
3064 chandransh 10411 
      oprot.writeFieldBegin('customerId', TType.I64, 1)
10412 
      oprot.writeI64(self.customerId)
1149 chandransh 10413 
      oprot.writeFieldEnd()
3431 rajveer 10414 
    if self.from_date is not None:
3064 chandransh 10415 
      oprot.writeFieldBegin('from_date', TType.I64, 2)
10416 
      oprot.writeI64(self.from_date)
1149 chandransh 10417 
      oprot.writeFieldEnd()
3431 rajveer 10418 
    if self.to_date is not None:
3064 chandransh 10419 
      oprot.writeFieldBegin('to_date', TType.I64, 3)
10420 
      oprot.writeI64(self.to_date)
2783 chandransh 10421 
      oprot.writeFieldEnd()
3431 rajveer 10422 
    if self.statuses is not None:
3064 chandransh 10423 
      oprot.writeFieldBegin('statuses', TType.LIST, 4)
10424 
      oprot.writeListBegin(TType.I32, len(self.statuses))
6000 mandeep.dh 10425 
      for iter160 in self.statuses:
10426 
        oprot.writeI32(iter160)
3064 chandransh 10427 
      oprot.writeListEnd()
2783 chandransh 10428 
      oprot.writeFieldEnd()
1149 chandransh 10429 
    oprot.writeFieldStop()
10430 
    oprot.writeStructEnd()
10431 
 
3431 rajveer 10432 
  def validate(self):
10433 
    return
10434 
 
10435 
 
1149 chandransh 10436 
  def __repr__(self):
10437 
    L = ['%s=%r' % (key, value)
10438 
      for key, value in self.__dict__.iteritems()]
10439 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10440 
 
10441 
  def __eq__(self, other):
10442 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10443 
 
10444 
  def __ne__(self, other):
10445 
    return not (self == other)
10446 
 
3064 chandransh 10447 
class getOrdersForCustomer_result:
1149 chandransh 10448 
  """
10449 
  Attributes:
10450 
   - success
10451 
   - ex
10452 
  """
10453 
 
10454 
  thrift_spec = (
3064 chandransh 10455 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
1149 chandransh 10456 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
10457 
  )
10458 
 
10459 
  def __init__(self, success=None, ex=None,):
10460 
    self.success = success
10461 
    self.ex = ex
10462 
 
10463 
  def read(self, iprot):
10464 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10465 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10466 
      return
10467 
    iprot.readStructBegin()
10468 
    while True:
10469 
      (fname, ftype, fid) = iprot.readFieldBegin()
10470 
      if ftype == TType.STOP:
10471 
        break
10472 
      if fid == 0:
3064 chandransh 10473 
        if ftype == TType.LIST:
10474 
          self.success = []
6000 mandeep.dh 10475 
          (_etype164, _size161) = iprot.readListBegin()
10476 
          for _i165 in xrange(_size161):
10477 
            _elem166 = Order()
10478 
            _elem166.read(iprot)
10479 
            self.success.append(_elem166)
3064 chandransh 10480 
          iprot.readListEnd()
1149 chandransh 10481 
        else:
10482 
          iprot.skip(ftype)
10483 
      elif fid == 1:
10484 
        if ftype == TType.STRUCT:
10485 
          self.ex = TransactionServiceException()
10486 
          self.ex.read(iprot)
10487 
        else:
10488 
          iprot.skip(ftype)
10489 
      else:
10490 
        iprot.skip(ftype)
10491 
      iprot.readFieldEnd()
10492 
    iprot.readStructEnd()
10493 
 
10494 
  def write(self, oprot):
10495 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10496 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10497 
      return
3064 chandransh 10498 
    oprot.writeStructBegin('getOrdersForCustomer_result')
3431 rajveer 10499 
    if self.success is not None:
3064 chandransh 10500 
      oprot.writeFieldBegin('success', TType.LIST, 0)
10501 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
6000 mandeep.dh 10502 
      for iter167 in self.success:
10503 
        iter167.write(oprot)
3064 chandransh 10504 
      oprot.writeListEnd()
1149 chandransh 10505 
      oprot.writeFieldEnd()
3431 rajveer 10506 
    if self.ex is not None:
1149 chandransh 10507 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
10508 
      self.ex.write(oprot)
10509 
      oprot.writeFieldEnd()
10510 
    oprot.writeFieldStop()
10511 
    oprot.writeStructEnd()
10512 
 
3431 rajveer 10513 
  def validate(self):
10514 
    return
10515 
 
10516 
 
1149 chandransh 10517 
  def __repr__(self):
10518 
    L = ['%s=%r' % (key, value)
10519 
      for key, value in self.__dict__.iteritems()]
10520 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10521 
 
10522 
  def __eq__(self, other):
10523 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10524 
 
10525 
  def __ne__(self, other):
10526 
    return not (self == other)
10527 
 
3064 chandransh 10528 
class createOrder_args:
921 rajveer 10529 
  """
10530 
  Attributes:
3064 chandransh 10531 
   - order
921 rajveer 10532 
  """
10533 
 
10534 
  thrift_spec = (
10535 
    None, # 0
3064 chandransh 10536 
    (1, TType.STRUCT, 'order', (Order, Order.thrift_spec), None, ), # 1
921 rajveer 10537 
  )
10538 
 
3064 chandransh 10539 
  def __init__(self, order=None,):
10540 
    self.order = order
921 rajveer 10541 
 
10542 
  def read(self, iprot):
10543 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10544 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10545 
      return
10546 
    iprot.readStructBegin()
10547 
    while True:
10548 
      (fname, ftype, fid) = iprot.readFieldBegin()
10549 
      if ftype == TType.STOP:
10550 
        break
10551 
      if fid == 1:
3064 chandransh 10552 
        if ftype == TType.STRUCT:
10553 
          self.order = Order()
10554 
          self.order.read(iprot)
921 rajveer 10555 
        else:
10556 
          iprot.skip(ftype)
10557 
      else:
10558 
        iprot.skip(ftype)
10559 
      iprot.readFieldEnd()
10560 
    iprot.readStructEnd()
10561 
 
10562 
  def write(self, oprot):
10563 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10564 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10565 
      return
3064 chandransh 10566 
    oprot.writeStructBegin('createOrder_args')
3431 rajveer 10567 
    if self.order is not None:
3064 chandransh 10568 
      oprot.writeFieldBegin('order', TType.STRUCT, 1)
10569 
      self.order.write(oprot)
921 rajveer 10570 
      oprot.writeFieldEnd()
10571 
    oprot.writeFieldStop()
10572 
    oprot.writeStructEnd()
10573 
 
3431 rajveer 10574 
  def validate(self):
10575 
    return
10576 
 
10577 
 
921 rajveer 10578 
  def __repr__(self):
10579 
    L = ['%s=%r' % (key, value)
10580 
      for key, value in self.__dict__.iteritems()]
10581 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10582 
 
10583 
  def __eq__(self, other):
10584 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10585 
 
10586 
  def __ne__(self, other):
10587 
    return not (self == other)
10588 
 
3064 chandransh 10589 
class createOrder_result:
921 rajveer 10590 
  """
10591 
  Attributes:
10592 
   - success
10593 
   - ex
10594 
  """
10595 
 
10596 
  thrift_spec = (
3064 chandransh 10597 
    (0, TType.I64, 'success', None, None, ), # 0
921 rajveer 10598 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
10599 
  )
10600 
 
10601 
  def __init__(self, success=None, ex=None,):
10602 
    self.success = success
10603 
    self.ex = ex
10604 
 
10605 
  def read(self, iprot):
10606 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10607 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10608 
      return
10609 
    iprot.readStructBegin()
10610 
    while True:
10611 
      (fname, ftype, fid) = iprot.readFieldBegin()
10612 
      if ftype == TType.STOP:
10613 
        break
10614 
      if fid == 0:
3064 chandransh 10615 
        if ftype == TType.I64:
10616 
          self.success = iprot.readI64();
921 rajveer 10617 
        else:
10618 
          iprot.skip(ftype)
10619 
      elif fid == 1:
10620 
        if ftype == TType.STRUCT:
10621 
          self.ex = TransactionServiceException()
10622 
          self.ex.read(iprot)
10623 
        else:
10624 
          iprot.skip(ftype)
10625 
      else:
10626 
        iprot.skip(ftype)
10627 
      iprot.readFieldEnd()
10628 
    iprot.readStructEnd()
10629 
 
10630 
  def write(self, oprot):
10631 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10632 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10633 
      return
3064 chandransh 10634 
    oprot.writeStructBegin('createOrder_result')
3431 rajveer 10635 
    if self.success is not None:
3064 chandransh 10636 
      oprot.writeFieldBegin('success', TType.I64, 0)
10637 
      oprot.writeI64(self.success)
921 rajveer 10638 
      oprot.writeFieldEnd()
3431 rajveer 10639 
    if self.ex is not None:
921 rajveer 10640 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
10641 
      self.ex.write(oprot)
10642 
      oprot.writeFieldEnd()
10643 
    oprot.writeFieldStop()
10644 
    oprot.writeStructEnd()
10645 
 
3431 rajveer 10646 
  def validate(self):
10647 
    return
10648 
 
10649 
 
921 rajveer 10650 
  def __repr__(self):
10651 
    L = ['%s=%r' % (key, value)
10652 
      for key, value in self.__dict__.iteritems()]
10653 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10654 
 
10655 
  def __eq__(self, other):
10656 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10657 
 
10658 
  def __ne__(self, other):
10659 
    return not (self == other)
10660 
 
3064 chandransh 10661 
class getOrder_args:
921 rajveer 10662 
  """
10663 
  Attributes:
3064 chandransh 10664 
   - id
921 rajveer 10665 
  """
10666 
 
10667 
  thrift_spec = (
10668 
    None, # 0
3064 chandransh 10669 
    (1, TType.I64, 'id', None, None, ), # 1
921 rajveer 10670 
  )
10671 
 
3064 chandransh 10672 
  def __init__(self, id=None,):
10673 
    self.id = id
921 rajveer 10674 
 
10675 
  def read(self, iprot):
10676 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10677 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10678 
      return
10679 
    iprot.readStructBegin()
10680 
    while True:
10681 
      (fname, ftype, fid) = iprot.readFieldBegin()
10682 
      if ftype == TType.STOP:
10683 
        break
10684 
      if fid == 1:
10685 
        if ftype == TType.I64:
3064 chandransh 10686 
          self.id = iprot.readI64();
921 rajveer 10687 
        else:
10688 
          iprot.skip(ftype)
10689 
      else:
10690 
        iprot.skip(ftype)
10691 
      iprot.readFieldEnd()
10692 
    iprot.readStructEnd()
10693 
 
10694 
  def write(self, oprot):
10695 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10696 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10697 
      return
3064 chandransh 10698 
    oprot.writeStructBegin('getOrder_args')
3431 rajveer 10699 
    if self.id is not None:
3064 chandransh 10700 
      oprot.writeFieldBegin('id', TType.I64, 1)
10701 
      oprot.writeI64(self.id)
921 rajveer 10702 
      oprot.writeFieldEnd()
10703 
    oprot.writeFieldStop()
10704 
    oprot.writeStructEnd()
10705 
 
3431 rajveer 10706 
  def validate(self):
10707 
    return
10708 
 
10709 
 
921 rajveer 10710 
  def __repr__(self):
10711 
    L = ['%s=%r' % (key, value)
10712 
      for key, value in self.__dict__.iteritems()]
10713 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10714 
 
10715 
  def __eq__(self, other):
10716 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10717 
 
10718 
  def __ne__(self, other):
10719 
    return not (self == other)
10720 
 
3064 chandransh 10721 
class getOrder_result:
921 rajveer 10722 
  """
10723 
  Attributes:
10724 
   - success
10725 
   - ex
10726 
  """
10727 
 
10728 
  thrift_spec = (
3064 chandransh 10729 
    (0, TType.STRUCT, 'success', (Order, Order.thrift_spec), None, ), # 0
921 rajveer 10730 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
10731 
  )
10732 
 
10733 
  def __init__(self, success=None, ex=None,):
10734 
    self.success = success
10735 
    self.ex = ex
10736 
 
10737 
  def read(self, iprot):
10738 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10739 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10740 
      return
10741 
    iprot.readStructBegin()
10742 
    while True:
10743 
      (fname, ftype, fid) = iprot.readFieldBegin()
10744 
      if ftype == TType.STOP:
10745 
        break
10746 
      if fid == 0:
3064 chandransh 10747 
        if ftype == TType.STRUCT:
10748 
          self.success = Order()
10749 
          self.success.read(iprot)
921 rajveer 10750 
        else:
10751 
          iprot.skip(ftype)
10752 
      elif fid == 1:
10753 
        if ftype == TType.STRUCT:
10754 
          self.ex = TransactionServiceException()
10755 
          self.ex.read(iprot)
10756 
        else:
10757 
          iprot.skip(ftype)
10758 
      else:
10759 
        iprot.skip(ftype)
10760 
      iprot.readFieldEnd()
10761 
    iprot.readStructEnd()
10762 
 
10763 
  def write(self, oprot):
10764 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10765 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10766 
      return
3064 chandransh 10767 
    oprot.writeStructBegin('getOrder_result')
3431 rajveer 10768 
    if self.success is not None:
3064 chandransh 10769 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
10770 
      self.success.write(oprot)
921 rajveer 10771 
      oprot.writeFieldEnd()
3431 rajveer 10772 
    if self.ex is not None:
921 rajveer 10773 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
10774 
      self.ex.write(oprot)
10775 
      oprot.writeFieldEnd()
10776 
    oprot.writeFieldStop()
10777 
    oprot.writeStructEnd()
10778 
 
3431 rajveer 10779 
  def validate(self):
10780 
    return
10781 
 
10782 
 
921 rajveer 10783 
  def __repr__(self):
10784 
    L = ['%s=%r' % (key, value)
10785 
      for key, value in self.__dict__.iteritems()]
10786 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10787 
 
10788 
  def __eq__(self, other):
10789 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10790 
 
10791 
  def __ne__(self, other):
10792 
    return not (self == other)
10793 
 
3064 chandransh 10794 
class getLineItemsForOrder_args:
94 ashish 10795 
  """
10796 
  Attributes:
3064 chandransh 10797 
   - orderId
94 ashish 10798 
  """
10799 
 
10800 
  thrift_spec = (
10801 
    None, # 0
3064 chandransh 10802 
    (1, TType.I64, 'orderId', None, None, ), # 1
94 ashish 10803 
  )
10804 
 
3064 chandransh 10805 
  def __init__(self, orderId=None,):
10806 
    self.orderId = orderId
94 ashish 10807 
 
10808 
  def read(self, iprot):
10809 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10810 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10811 
      return
10812 
    iprot.readStructBegin()
10813 
    while True:
10814 
      (fname, ftype, fid) = iprot.readFieldBegin()
10815 
      if ftype == TType.STOP:
10816 
        break
10817 
      if fid == 1:
10818 
        if ftype == TType.I64:
3064 chandransh 10819 
          self.orderId = iprot.readI64();
94 ashish 10820 
        else:
10821 
          iprot.skip(ftype)
10822 
      else:
10823 
        iprot.skip(ftype)
10824 
      iprot.readFieldEnd()
10825 
    iprot.readStructEnd()
10826 
 
10827 
  def write(self, oprot):
10828 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10829 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10830 
      return
3064 chandransh 10831 
    oprot.writeStructBegin('getLineItemsForOrder_args')
3431 rajveer 10832 
    if self.orderId is not None:
3064 chandransh 10833 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
10834 
      oprot.writeI64(self.orderId)
94 ashish 10835 
      oprot.writeFieldEnd()
10836 
    oprot.writeFieldStop()
10837 
    oprot.writeStructEnd()
10838 
 
3431 rajveer 10839 
  def validate(self):
10840 
    return
10841 
 
10842 
 
94 ashish 10843 
  def __repr__(self):
10844 
    L = ['%s=%r' % (key, value)
10845 
      for key, value in self.__dict__.iteritems()]
10846 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10847 
 
10848 
  def __eq__(self, other):
10849 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10850 
 
10851 
  def __ne__(self, other):
10852 
    return not (self == other)
10853 
 
3064 chandransh 10854 
class getLineItemsForOrder_result:
94 ashish 10855 
  """
10856 
  Attributes:
10857 
   - success
10858 
   - ex
10859 
  """
10860 
 
10861 
  thrift_spec = (
3064 chandransh 10862 
    (0, TType.LIST, 'success', (TType.STRUCT,(LineItem, LineItem.thrift_spec)), None, ), # 0
94 ashish 10863 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
10864 
  )
10865 
 
10866 
  def __init__(self, success=None, ex=None,):
10867 
    self.success = success
10868 
    self.ex = ex
10869 
 
10870 
  def read(self, iprot):
10871 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10872 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10873 
      return
10874 
    iprot.readStructBegin()
10875 
    while True:
10876 
      (fname, ftype, fid) = iprot.readFieldBegin()
10877 
      if ftype == TType.STOP:
10878 
        break
10879 
      if fid == 0:
483 rajveer 10880 
        if ftype == TType.LIST:
10881 
          self.success = []
6000 mandeep.dh 10882 
          (_etype171, _size168) = iprot.readListBegin()
10883 
          for _i172 in xrange(_size168):
10884 
            _elem173 = LineItem()
10885 
            _elem173.read(iprot)
10886 
            self.success.append(_elem173)
483 rajveer 10887 
          iprot.readListEnd()
94 ashish 10888 
        else:
10889 
          iprot.skip(ftype)
10890 
      elif fid == 1:
10891 
        if ftype == TType.STRUCT:
10892 
          self.ex = TransactionServiceException()
10893 
          self.ex.read(iprot)
10894 
        else:
10895 
          iprot.skip(ftype)
10896 
      else:
10897 
        iprot.skip(ftype)
10898 
      iprot.readFieldEnd()
10899 
    iprot.readStructEnd()
10900 
 
10901 
  def write(self, oprot):
10902 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10903 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10904 
      return
3064 chandransh 10905 
    oprot.writeStructBegin('getLineItemsForOrder_result')
3431 rajveer 10906 
    if self.success is not None:
483 rajveer 10907 
      oprot.writeFieldBegin('success', TType.LIST, 0)
10908 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
6000 mandeep.dh 10909 
      for iter174 in self.success:
10910 
        iter174.write(oprot)
483 rajveer 10911 
      oprot.writeListEnd()
94 ashish 10912 
      oprot.writeFieldEnd()
3431 rajveer 10913 
    if self.ex is not None:
94 ashish 10914 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
10915 
      self.ex.write(oprot)
10916 
      oprot.writeFieldEnd()
10917 
    oprot.writeFieldStop()
10918 
    oprot.writeStructEnd()
10919 
 
3431 rajveer 10920 
  def validate(self):
10921 
    return
10922 
 
10923 
 
94 ashish 10924 
  def __repr__(self):
10925 
    L = ['%s=%r' % (key, value)
10926 
      for key, value in self.__dict__.iteritems()]
10927 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10928 
 
10929 
  def __eq__(self, other):
10930 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10931 
 
10932 
  def __ne__(self, other):
10933 
    return not (self == other)
10934 
 
4999 phani.kuma 10935 
class getOrderList_args:
10936 
  """
10937 
  Attributes:
10938 
   - order_ids
10939 
  """
10940 
 
10941 
  thrift_spec = (
10942 
    None, # 0
10943 
    (1, TType.LIST, 'order_ids', (TType.I64,None), None, ), # 1
10944 
  )
10945 
 
10946 
  def __init__(self, order_ids=None,):
10947 
    self.order_ids = order_ids
10948 
 
10949 
  def read(self, iprot):
10950 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10951 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10952 
      return
10953 
    iprot.readStructBegin()
10954 
    while True:
10955 
      (fname, ftype, fid) = iprot.readFieldBegin()
10956 
      if ftype == TType.STOP:
10957 
        break
10958 
      if fid == 1:
10959 
        if ftype == TType.LIST:
10960 
          self.order_ids = []
6000 mandeep.dh 10961 
          (_etype178, _size175) = iprot.readListBegin()
10962 
          for _i179 in xrange(_size175):
10963 
            _elem180 = iprot.readI64();
10964 
            self.order_ids.append(_elem180)
4999 phani.kuma 10965 
          iprot.readListEnd()
10966 
        else:
10967 
          iprot.skip(ftype)
10968 
      else:
10969 
        iprot.skip(ftype)
10970 
      iprot.readFieldEnd()
10971 
    iprot.readStructEnd()
10972 
 
10973 
  def write(self, oprot):
10974 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10975 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10976 
      return
10977 
    oprot.writeStructBegin('getOrderList_args')
10978 
    if self.order_ids is not None:
10979 
      oprot.writeFieldBegin('order_ids', TType.LIST, 1)
10980 
      oprot.writeListBegin(TType.I64, len(self.order_ids))
6000 mandeep.dh 10981 
      for iter181 in self.order_ids:
10982 
        oprot.writeI64(iter181)
4999 phani.kuma 10983 
      oprot.writeListEnd()
10984 
      oprot.writeFieldEnd()
10985 
    oprot.writeFieldStop()
10986 
    oprot.writeStructEnd()
10987 
 
10988 
  def validate(self):
10989 
    return
10990 
 
10991 
 
10992 
  def __repr__(self):
10993 
    L = ['%s=%r' % (key, value)
10994 
      for key, value in self.__dict__.iteritems()]
10995 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10996 
 
10997 
  def __eq__(self, other):
10998 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10999 
 
11000 
  def __ne__(self, other):
11001 
    return not (self == other)
11002 
 
11003 
class getOrderList_result:
11004 
  """
11005 
  Attributes:
11006 
   - success
11007 
  """
11008 
 
11009 
  thrift_spec = (
11010 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
11011 
  )
11012 
 
11013 
  def __init__(self, success=None,):
11014 
    self.success = success
11015 
 
11016 
  def read(self, iprot):
11017 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11018 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11019 
      return
11020 
    iprot.readStructBegin()
11021 
    while True:
11022 
      (fname, ftype, fid) = iprot.readFieldBegin()
11023 
      if ftype == TType.STOP:
11024 
        break
11025 
      if fid == 0:
11026 
        if ftype == TType.LIST:
11027 
          self.success = []
6000 mandeep.dh 11028 
          (_etype185, _size182) = iprot.readListBegin()
11029 
          for _i186 in xrange(_size182):
11030 
            _elem187 = Order()
11031 
            _elem187.read(iprot)
11032 
            self.success.append(_elem187)
4999 phani.kuma 11033 
          iprot.readListEnd()
11034 
        else:
11035 
          iprot.skip(ftype)
11036 
      else:
11037 
        iprot.skip(ftype)
11038 
      iprot.readFieldEnd()
11039 
    iprot.readStructEnd()
11040 
 
11041 
  def write(self, oprot):
11042 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11043 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11044 
      return
11045 
    oprot.writeStructBegin('getOrderList_result')
11046 
    if self.success is not None:
11047 
      oprot.writeFieldBegin('success', TType.LIST, 0)
11048 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
6000 mandeep.dh 11049 
      for iter188 in self.success:
11050 
        iter188.write(oprot)
4999 phani.kuma 11051 
      oprot.writeListEnd()
11052 
      oprot.writeFieldEnd()
11053 
    oprot.writeFieldStop()
11054 
    oprot.writeStructEnd()
11055 
 
11056 
  def validate(self):
11057 
    return
11058 
 
11059 
 
11060 
  def __repr__(self):
11061 
    L = ['%s=%r' % (key, value)
11062 
      for key, value in self.__dict__.iteritems()]
11063 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11064 
 
11065 
  def __eq__(self, other):
11066 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11067 
 
11068 
  def __ne__(self, other):
11069 
    return not (self == other)
11070 
 
5386 phani.kuma 11071 
class getOrderListForVendor_args:
11072 
  """
11073 
  Attributes:
11074 
   - order_ids
11075 
   - vendorId
11076 
  """
11077 
 
11078 
  thrift_spec = (
11079 
    None, # 0
11080 
    (1, TType.LIST, 'order_ids', (TType.I64,None), None, ), # 1
11081 
    (2, TType.I64, 'vendorId', None, None, ), # 2
11082 
  )
11083 
 
11084 
  def __init__(self, order_ids=None, vendorId=None,):
11085 
    self.order_ids = order_ids
11086 
    self.vendorId = vendorId
11087 
 
11088 
  def read(self, iprot):
11089 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11090 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11091 
      return
11092 
    iprot.readStructBegin()
11093 
    while True:
11094 
      (fname, ftype, fid) = iprot.readFieldBegin()
11095 
      if ftype == TType.STOP:
11096 
        break
11097 
      if fid == 1:
11098 
        if ftype == TType.LIST:
11099 
          self.order_ids = []
6000 mandeep.dh 11100 
          (_etype192, _size189) = iprot.readListBegin()
11101 
          for _i193 in xrange(_size189):
11102 
            _elem194 = iprot.readI64();
11103 
            self.order_ids.append(_elem194)
5386 phani.kuma 11104 
          iprot.readListEnd()
11105 
        else:
11106 
          iprot.skip(ftype)
11107 
      elif fid == 2:
11108 
        if ftype == TType.I64:
11109 
          self.vendorId = iprot.readI64();
11110 
        else:
11111 
          iprot.skip(ftype)
11112 
      else:
11113 
        iprot.skip(ftype)
11114 
      iprot.readFieldEnd()
11115 
    iprot.readStructEnd()
11116 
 
11117 
  def write(self, oprot):
11118 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11119 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11120 
      return
11121 
    oprot.writeStructBegin('getOrderListForVendor_args')
11122 
    if self.order_ids is not None:
11123 
      oprot.writeFieldBegin('order_ids', TType.LIST, 1)
11124 
      oprot.writeListBegin(TType.I64, len(self.order_ids))
6000 mandeep.dh 11125 
      for iter195 in self.order_ids:
11126 
        oprot.writeI64(iter195)
5386 phani.kuma 11127 
      oprot.writeListEnd()
11128 
      oprot.writeFieldEnd()
11129 
    if self.vendorId is not None:
11130 
      oprot.writeFieldBegin('vendorId', TType.I64, 2)
11131 
      oprot.writeI64(self.vendorId)
11132 
      oprot.writeFieldEnd()
11133 
    oprot.writeFieldStop()
11134 
    oprot.writeStructEnd()
11135 
 
11136 
  def validate(self):
11137 
    return
11138 
 
11139 
 
11140 
  def __repr__(self):
11141 
    L = ['%s=%r' % (key, value)
11142 
      for key, value in self.__dict__.iteritems()]
11143 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11144 
 
11145 
  def __eq__(self, other):
11146 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11147 
 
11148 
  def __ne__(self, other):
11149 
    return not (self == other)
11150 
 
11151 
class getOrderListForVendor_result:
11152 
  """
11153 
  Attributes:
11154 
   - success
11155 
  """
11156 
 
11157 
  thrift_spec = (
11158 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
11159 
  )
11160 
 
11161 
  def __init__(self, success=None,):
11162 
    self.success = success
11163 
 
11164 
  def read(self, iprot):
11165 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11166 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11167 
      return
11168 
    iprot.readStructBegin()
11169 
    while True:
11170 
      (fname, ftype, fid) = iprot.readFieldBegin()
11171 
      if ftype == TType.STOP:
11172 
        break
11173 
      if fid == 0:
11174 
        if ftype == TType.LIST:
11175 
          self.success = []
6000 mandeep.dh 11176 
          (_etype199, _size196) = iprot.readListBegin()
11177 
          for _i200 in xrange(_size196):
11178 
            _elem201 = Order()
11179 
            _elem201.read(iprot)
11180 
            self.success.append(_elem201)
5386 phani.kuma 11181 
          iprot.readListEnd()
11182 
        else:
11183 
          iprot.skip(ftype)
11184 
      else:
11185 
        iprot.skip(ftype)
11186 
      iprot.readFieldEnd()
11187 
    iprot.readStructEnd()
11188 
 
11189 
  def write(self, oprot):
11190 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11191 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11192 
      return
11193 
    oprot.writeStructBegin('getOrderListForVendor_result')
11194 
    if self.success is not None:
11195 
      oprot.writeFieldBegin('success', TType.LIST, 0)
11196 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
6000 mandeep.dh 11197 
      for iter202 in self.success:
11198 
        iter202.write(oprot)
5386 phani.kuma 11199 
      oprot.writeListEnd()
11200 
      oprot.writeFieldEnd()
11201 
    oprot.writeFieldStop()
11202 
    oprot.writeStructEnd()
11203 
 
11204 
  def validate(self):
11205 
    return
11206 
 
11207 
 
11208 
  def __repr__(self):
11209 
    L = ['%s=%r' % (key, value)
11210 
      for key, value in self.__dict__.iteritems()]
11211 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11212 
 
11213 
  def __eq__(self, other):
11214 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11215 
 
11216 
  def __ne__(self, other):
11217 
    return not (self == other)
11218 
 
3064 chandransh 11219 
class getOrderForCustomer_args:
94 ashish 11220 
  """
11221 
  Attributes:
3064 chandransh 11222 
   - orderId
483 rajveer 11223 
   - customerId
94 ashish 11224 
  """
11225 
 
11226 
  thrift_spec = (
11227 
    None, # 0
3064 chandransh 11228 
    (1, TType.I64, 'orderId', None, None, ), # 1
11229 
    (2, TType.I64, 'customerId', None, None, ), # 2
94 ashish 11230 
  )
11231 
 
3064 chandransh 11232 
  def __init__(self, orderId=None, customerId=None,):
11233 
    self.orderId = orderId
483 rajveer 11234 
    self.customerId = customerId
94 ashish 11235 
 
11236 
  def read(self, iprot):
11237 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11238 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11239 
      return
11240 
    iprot.readStructBegin()
11241 
    while True:
11242 
      (fname, ftype, fid) = iprot.readFieldBegin()
11243 
      if ftype == TType.STOP:
11244 
        break
11245 
      if fid == 1:
11246 
        if ftype == TType.I64:
3064 chandransh 11247 
          self.orderId = iprot.readI64();
94 ashish 11248 
        else:
11249 
          iprot.skip(ftype)
11250 
      elif fid == 2:
11251 
        if ftype == TType.I64:
3064 chandransh 11252 
          self.customerId = iprot.readI64();
94 ashish 11253 
        else:
11254 
          iprot.skip(ftype)
11255 
      else:
11256 
        iprot.skip(ftype)
11257 
      iprot.readFieldEnd()
11258 
    iprot.readStructEnd()
11259 
 
11260 
  def write(self, oprot):
11261 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11262 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11263 
      return
3064 chandransh 11264 
    oprot.writeStructBegin('getOrderForCustomer_args')
3431 rajveer 11265 
    if self.orderId is not None:
3064 chandransh 11266 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
11267 
      oprot.writeI64(self.orderId)
11268 
      oprot.writeFieldEnd()
3431 rajveer 11269 
    if self.customerId is not None:
3064 chandransh 11270 
      oprot.writeFieldBegin('customerId', TType.I64, 2)
483 rajveer 11271 
      oprot.writeI64(self.customerId)
94 ashish 11272 
      oprot.writeFieldEnd()
11273 
    oprot.writeFieldStop()
11274 
    oprot.writeStructEnd()
11275 
 
3431 rajveer 11276 
  def validate(self):
11277 
    return
11278 
 
11279 
 
94 ashish 11280 
  def __repr__(self):
11281 
    L = ['%s=%r' % (key, value)
11282 
      for key, value in self.__dict__.iteritems()]
11283 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11284 
 
11285 
  def __eq__(self, other):
11286 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11287 
 
11288 
  def __ne__(self, other):
11289 
    return not (self == other)
11290 
 
3064 chandransh 11291 
class getOrderForCustomer_result:
94 ashish 11292 
  """
11293 
  Attributes:
11294 
   - success
11295 
   - ex
11296 
  """
11297 
 
11298 
  thrift_spec = (
3064 chandransh 11299 
    (0, TType.STRUCT, 'success', (Order, Order.thrift_spec), None, ), # 0
94 ashish 11300 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
11301 
  )
11302 
 
11303 
  def __init__(self, success=None, ex=None,):
11304 
    self.success = success
11305 
    self.ex = ex
11306 
 
11307 
  def read(self, iprot):
11308 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11309 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11310 
      return
11311 
    iprot.readStructBegin()
11312 
    while True:
11313 
      (fname, ftype, fid) = iprot.readFieldBegin()
11314 
      if ftype == TType.STOP:
11315 
        break
11316 
      if fid == 0:
3064 chandransh 11317 
        if ftype == TType.STRUCT:
11318 
          self.success = Order()
11319 
          self.success.read(iprot)
94 ashish 11320 
        else:
11321 
          iprot.skip(ftype)
11322 
      elif fid == 1:
11323 
        if ftype == TType.STRUCT:
11324 
          self.ex = TransactionServiceException()
11325 
          self.ex.read(iprot)
11326 
        else:
11327 
          iprot.skip(ftype)
11328 
      else:
11329 
        iprot.skip(ftype)
11330 
      iprot.readFieldEnd()
11331 
    iprot.readStructEnd()
11332 
 
11333 
  def write(self, oprot):
11334 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11335 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11336 
      return
3064 chandransh 11337 
    oprot.writeStructBegin('getOrderForCustomer_result')
3431 rajveer 11338 
    if self.success is not None:
3064 chandransh 11339 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
11340 
      self.success.write(oprot)
94 ashish 11341 
      oprot.writeFieldEnd()
3431 rajveer 11342 
    if self.ex is not None:
94 ashish 11343 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
11344 
      self.ex.write(oprot)
11345 
      oprot.writeFieldEnd()
11346 
    oprot.writeFieldStop()
11347 
    oprot.writeStructEnd()
11348 
 
3431 rajveer 11349 
  def validate(self):
11350 
    return
11351 
 
11352 
 
94 ashish 11353 
  def __repr__(self):
11354 
    L = ['%s=%r' % (key, value)
11355 
      for key, value in self.__dict__.iteritems()]
11356 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11357 
 
11358 
  def __eq__(self, other):
11359 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11360 
 
11361 
  def __ne__(self, other):
11362 
    return not (self == other)
11363 
 
3064 chandransh 11364 
class getAlerts_args:
94 ashish 11365 
  """
11366 
  Attributes:
4394 rajveer 11367 
   - type
4444 rajveer 11368 
   - warehouseId
4394 rajveer 11369 
   - status
11370 
   - timestamp
94 ashish 11371 
  """
11372 
 
11373 
  thrift_spec = (
11374 
    None, # 0
4394 rajveer 11375 
    (1, TType.I64, 'type', None, None, ), # 1
4444 rajveer 11376 
    (2, TType.I64, 'warehouseId', None, None, ), # 2
11377 
    (3, TType.I64, 'status', None, None, ), # 3
11378 
    (4, TType.I64, 'timestamp', None, None, ), # 4
94 ashish 11379 
  )
11380 
 
4444 rajveer 11381 
  def __init__(self, type=None, warehouseId=None, status=None, timestamp=None,):
4394 rajveer 11382 
    self.type = type
4444 rajveer 11383 
    self.warehouseId = warehouseId
4394 rajveer 11384 
    self.status = status
11385 
    self.timestamp = timestamp
94 ashish 11386 
 
11387 
  def read(self, iprot):
11388 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11389 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11390 
      return
11391 
    iprot.readStructBegin()
11392 
    while True:
11393 
      (fname, ftype, fid) = iprot.readFieldBegin()
11394 
      if ftype == TType.STOP:
11395 
        break
11396 
      if fid == 1:
3064 chandransh 11397 
        if ftype == TType.I64:
4394 rajveer 11398 
          self.type = iprot.readI64();
94 ashish 11399 
        else:
11400 
          iprot.skip(ftype)
3064 chandransh 11401 
      elif fid == 2:
4394 rajveer 11402 
        if ftype == TType.I64:
4444 rajveer 11403 
          self.warehouseId = iprot.readI64();
3064 chandransh 11404 
        else:
11405 
          iprot.skip(ftype)
4394 rajveer 11406 
      elif fid == 3:
11407 
        if ftype == TType.I64:
4444 rajveer 11408 
          self.status = iprot.readI64();
11409 
        else:
11410 
          iprot.skip(ftype)
11411 
      elif fid == 4:
11412 
        if ftype == TType.I64:
4394 rajveer 11413 
          self.timestamp = iprot.readI64();
11414 
        else:
11415 
          iprot.skip(ftype)
94 ashish 11416 
      else:
11417 
        iprot.skip(ftype)
11418 
      iprot.readFieldEnd()
11419 
    iprot.readStructEnd()
11420 
 
11421 
  def write(self, oprot):
11422 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11423 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11424 
      return
3064 chandransh 11425 
    oprot.writeStructBegin('getAlerts_args')
4394 rajveer 11426 
    if self.type is not None:
11427 
      oprot.writeFieldBegin('type', TType.I64, 1)
11428 
      oprot.writeI64(self.type)
94 ashish 11429 
      oprot.writeFieldEnd()
4444 rajveer 11430 
    if self.warehouseId is not None:
11431 
      oprot.writeFieldBegin('warehouseId', TType.I64, 2)
11432 
      oprot.writeI64(self.warehouseId)
11433 
      oprot.writeFieldEnd()
4394 rajveer 11434 
    if self.status is not None:
4444 rajveer 11435 
      oprot.writeFieldBegin('status', TType.I64, 3)
4394 rajveer 11436 
      oprot.writeI64(self.status)
3064 chandransh 11437 
      oprot.writeFieldEnd()
4394 rajveer 11438 
    if self.timestamp is not None:
4444 rajveer 11439 
      oprot.writeFieldBegin('timestamp', TType.I64, 4)
4394 rajveer 11440 
      oprot.writeI64(self.timestamp)
11441 
      oprot.writeFieldEnd()
94 ashish 11442 
    oprot.writeFieldStop()
11443 
    oprot.writeStructEnd()
11444 
 
3431 rajveer 11445 
  def validate(self):
11446 
    return
11447 
 
11448 
 
94 ashish 11449 
  def __repr__(self):
11450 
    L = ['%s=%r' % (key, value)
11451 
      for key, value in self.__dict__.iteritems()]
11452 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11453 
 
11454 
  def __eq__(self, other):
11455 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11456 
 
11457 
  def __ne__(self, other):
11458 
    return not (self == other)
11459 
 
3064 chandransh 11460 
class getAlerts_result:
94 ashish 11461 
  """
11462 
  Attributes:
11463 
   - success
11464 
  """
11465 
 
11466 
  thrift_spec = (
3064 chandransh 11467 
    (0, TType.LIST, 'success', (TType.STRUCT,(Alert, Alert.thrift_spec)), None, ), # 0
94 ashish 11468 
  )
11469 
 
3064 chandransh 11470 
  def __init__(self, success=None,):
94 ashish 11471 
    self.success = success
11472 
 
11473 
  def read(self, iprot):
11474 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11475 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11476 
      return
11477 
    iprot.readStructBegin()
11478 
    while True:
11479 
      (fname, ftype, fid) = iprot.readFieldBegin()
11480 
      if ftype == TType.STOP:
11481 
        break
11482 
      if fid == 0:
3064 chandransh 11483 
        if ftype == TType.LIST:
11484 
          self.success = []
6000 mandeep.dh 11485 
          (_etype206, _size203) = iprot.readListBegin()
11486 
          for _i207 in xrange(_size203):
11487 
            _elem208 = Alert()
11488 
            _elem208.read(iprot)
11489 
            self.success.append(_elem208)
3064 chandransh 11490 
          iprot.readListEnd()
94 ashish 11491 
        else:
11492 
          iprot.skip(ftype)
11493 
      else:
11494 
        iprot.skip(ftype)
11495 
      iprot.readFieldEnd()
11496 
    iprot.readStructEnd()
11497 
 
11498 
  def write(self, oprot):
11499 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11500 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11501 
      return
3064 chandransh 11502 
    oprot.writeStructBegin('getAlerts_result')
3431 rajveer 11503 
    if self.success is not None:
3064 chandransh 11504 
      oprot.writeFieldBegin('success', TType.LIST, 0)
11505 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
6000 mandeep.dh 11506 
      for iter209 in self.success:
11507 
        iter209.write(oprot)
3064 chandransh 11508 
      oprot.writeListEnd()
94 ashish 11509 
      oprot.writeFieldEnd()
11510 
    oprot.writeFieldStop()
11511 
    oprot.writeStructEnd()
11512 
 
3431 rajveer 11513 
  def validate(self):
11514 
    return
11515 
 
11516 
 
94 ashish 11517 
  def __repr__(self):
11518 
    L = ['%s=%r' % (key, value)
11519 
      for key, value in self.__dict__.iteritems()]
11520 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11521 
 
11522 
  def __eq__(self, other):
11523 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11524 
 
11525 
  def __ne__(self, other):
11526 
    return not (self == other)
11527 
 
4394 rajveer 11528 
class addAlert_args:
94 ashish 11529 
  """
11530 
  Attributes:
3064 chandransh 11531 
   - type
4444 rajveer 11532 
   - warehouseId
4394 rajveer 11533 
   - description
94 ashish 11534 
  """
11535 
 
11536 
  thrift_spec = (
11537 
    None, # 0
4394 rajveer 11538 
    (1, TType.I64, 'type', None, None, ), # 1
4444 rajveer 11539 
    (2, TType.I64, 'warehouseId', None, None, ), # 2
11540 
    (3, TType.STRING, 'description', None, None, ), # 3
94 ashish 11541 
  )
11542 
 
4444 rajveer 11543 
  def __init__(self, type=None, warehouseId=None, description=None,):
3064 chandransh 11544 
    self.type = type
4444 rajveer 11545 
    self.warehouseId = warehouseId
4394 rajveer 11546 
    self.description = description
94 ashish 11547 
 
11548 
  def read(self, iprot):
11549 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11550 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11551 
      return
11552 
    iprot.readStructBegin()
11553 
    while True:
11554 
      (fname, ftype, fid) = iprot.readFieldBegin()
11555 
      if ftype == TType.STOP:
11556 
        break
11557 
      if fid == 1:
11558 
        if ftype == TType.I64:
4394 rajveer 11559 
          self.type = iprot.readI64();
94 ashish 11560 
        else:
11561 
          iprot.skip(ftype)
3064 chandransh 11562 
      elif fid == 2:
4444 rajveer 11563 
        if ftype == TType.I64:
11564 
          self.warehouseId = iprot.readI64();
11565 
        else:
11566 
          iprot.skip(ftype)
11567 
      elif fid == 3:
3064 chandransh 11568 
        if ftype == TType.STRING:
4394 rajveer 11569 
          self.description = iprot.readString();
3064 chandransh 11570 
        else:
11571 
          iprot.skip(ftype)
94 ashish 11572 
      else:
11573 
        iprot.skip(ftype)
11574 
      iprot.readFieldEnd()
11575 
    iprot.readStructEnd()
11576 
 
11577 
  def write(self, oprot):
11578 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11579 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11580 
      return
4394 rajveer 11581 
    oprot.writeStructBegin('addAlert_args')
3431 rajveer 11582 
    if self.type is not None:
4394 rajveer 11583 
      oprot.writeFieldBegin('type', TType.I64, 1)
3064 chandransh 11584 
      oprot.writeI64(self.type)
11585 
      oprot.writeFieldEnd()
4444 rajveer 11586 
    if self.warehouseId is not None:
11587 
      oprot.writeFieldBegin('warehouseId', TType.I64, 2)
11588 
      oprot.writeI64(self.warehouseId)
11589 
      oprot.writeFieldEnd()
4394 rajveer 11590 
    if self.description is not None:
4444 rajveer 11591 
      oprot.writeFieldBegin('description', TType.STRING, 3)
4394 rajveer 11592 
      oprot.writeString(self.description)
3064 chandransh 11593 
      oprot.writeFieldEnd()
94 ashish 11594 
    oprot.writeFieldStop()
11595 
    oprot.writeStructEnd()
11596 
 
3431 rajveer 11597 
  def validate(self):
11598 
    return
11599 
 
11600 
 
94 ashish 11601 
  def __repr__(self):
11602 
    L = ['%s=%r' % (key, value)
11603 
      for key, value in self.__dict__.iteritems()]
11604 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11605 
 
11606 
  def __eq__(self, other):
11607 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11608 
 
11609 
  def __ne__(self, other):
11610 
    return not (self == other)
11611 
 
4394 rajveer 11612 
class addAlert_result:
3064 chandransh 11613 
 
11614 
  thrift_spec = (
11615 
  )
11616 
 
11617 
  def read(self, iprot):
11618 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11619 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11620 
      return
11621 
    iprot.readStructBegin()
11622 
    while True:
11623 
      (fname, ftype, fid) = iprot.readFieldBegin()
11624 
      if ftype == TType.STOP:
11625 
        break
11626 
      else:
11627 
        iprot.skip(ftype)
11628 
      iprot.readFieldEnd()
11629 
    iprot.readStructEnd()
11630 
 
11631 
  def write(self, oprot):
11632 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11633 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11634 
      return
4394 rajveer 11635 
    oprot.writeStructBegin('addAlert_result')
3064 chandransh 11636 
    oprot.writeFieldStop()
11637 
    oprot.writeStructEnd()
11638 
 
3431 rajveer 11639 
  def validate(self):
11640 
    return
11641 
 
11642 
 
3064 chandransh 11643 
  def __repr__(self):
11644 
    L = ['%s=%r' % (key, value)
11645 
      for key, value in self.__dict__.iteritems()]
11646 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11647 
 
11648 
  def __eq__(self, other):
11649 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11650 
 
11651 
  def __ne__(self, other):
11652 
    return not (self == other)
11653 
 
4444 rajveer 11654 
class markAlertsAsSeen_args:
11655 
  """
11656 
  Attributes:
11657 
   - warehouseId
11658 
  """
11659 
 
11660 
  thrift_spec = (
11661 
    None, # 0
11662 
    (1, TType.I64, 'warehouseId', None, None, ), # 1
11663 
  )
11664 
 
11665 
  def __init__(self, warehouseId=None,):
11666 
    self.warehouseId = warehouseId
11667 
 
11668 
  def read(self, iprot):
11669 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11670 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11671 
      return
11672 
    iprot.readStructBegin()
11673 
    while True:
11674 
      (fname, ftype, fid) = iprot.readFieldBegin()
11675 
      if ftype == TType.STOP:
11676 
        break
11677 
      if fid == 1:
11678 
        if ftype == TType.I64:
11679 
          self.warehouseId = iprot.readI64();
11680 
        else:
11681 
          iprot.skip(ftype)
11682 
      else:
11683 
        iprot.skip(ftype)
11684 
      iprot.readFieldEnd()
11685 
    iprot.readStructEnd()
11686 
 
11687 
  def write(self, oprot):
11688 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11689 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11690 
      return
11691 
    oprot.writeStructBegin('markAlertsAsSeen_args')
11692 
    if self.warehouseId is not None:
11693 
      oprot.writeFieldBegin('warehouseId', TType.I64, 1)
11694 
      oprot.writeI64(self.warehouseId)
11695 
      oprot.writeFieldEnd()
11696 
    oprot.writeFieldStop()
11697 
    oprot.writeStructEnd()
11698 
 
11699 
  def validate(self):
11700 
    return
11701 
 
11702 
 
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 
 
11714 
class markAlertsAsSeen_result:
11715 
 
11716 
  thrift_spec = (
11717 
  )
11718 
 
11719 
  def read(self, iprot):
11720 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11721 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11722 
      return
11723 
    iprot.readStructBegin()
11724 
    while True:
11725 
      (fname, ftype, fid) = iprot.readFieldBegin()
11726 
      if ftype == TType.STOP:
11727 
        break
11728 
      else:
11729 
        iprot.skip(ftype)
11730 
      iprot.readFieldEnd()
11731 
    iprot.readStructEnd()
11732 
 
11733 
  def write(self, oprot):
11734 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11735 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11736 
      return
11737 
    oprot.writeStructBegin('markAlertsAsSeen_result')
11738 
    oprot.writeFieldStop()
11739 
    oprot.writeStructEnd()
11740 
 
11741 
  def validate(self):
11742 
    return
11743 
 
11744 
 
11745 
  def __repr__(self):
11746 
    L = ['%s=%r' % (key, value)
11747 
      for key, value in self.__dict__.iteritems()]
11748 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11749 
 
11750 
  def __eq__(self, other):
11751 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11752 
 
11753 
  def __ne__(self, other):
11754 
    return not (self == other)
11755 
 
3064 chandransh 11756 
class getValidOrderCount_args:
11757 
 
11758 
  thrift_spec = (
11759 
  )
11760 
 
11761 
  def read(self, iprot):
11762 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11763 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11764 
      return
11765 
    iprot.readStructBegin()
11766 
    while True:
11767 
      (fname, ftype, fid) = iprot.readFieldBegin()
11768 
      if ftype == TType.STOP:
11769 
        break
11770 
      else:
11771 
        iprot.skip(ftype)
11772 
      iprot.readFieldEnd()
11773 
    iprot.readStructEnd()
11774 
 
11775 
  def write(self, oprot):
11776 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11777 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11778 
      return
11779 
    oprot.writeStructBegin('getValidOrderCount_args')
11780 
    oprot.writeFieldStop()
11781 
    oprot.writeStructEnd()
11782 
 
3431 rajveer 11783 
  def validate(self):
11784 
    return
11785 
 
11786 
 
3064 chandransh 11787 
  def __repr__(self):
11788 
    L = ['%s=%r' % (key, value)
11789 
      for key, value in self.__dict__.iteritems()]
11790 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11791 
 
11792 
  def __eq__(self, other):
11793 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11794 
 
11795 
  def __ne__(self, other):
11796 
    return not (self == other)
11797 
 
11798 
class getValidOrderCount_result:
94 ashish 11799 
  """
11800 
  Attributes:
11801 
   - success
11802 
  """
11803 
 
11804 
  thrift_spec = (
3064 chandransh 11805 
    (0, TType.I64, 'success', None, None, ), # 0
94 ashish 11806 
  )
11807 
 
3064 chandransh 11808 
  def __init__(self, success=None,):
94 ashish 11809 
    self.success = success
11810 
 
11811 
  def read(self, iprot):
11812 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11813 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11814 
      return
11815 
    iprot.readStructBegin()
11816 
    while True:
11817 
      (fname, ftype, fid) = iprot.readFieldBegin()
11818 
      if ftype == TType.STOP:
11819 
        break
11820 
      if fid == 0:
3064 chandransh 11821 
        if ftype == TType.I64:
11822 
          self.success = iprot.readI64();
94 ashish 11823 
        else:
11824 
          iprot.skip(ftype)
11825 
      else:
11826 
        iprot.skip(ftype)
11827 
      iprot.readFieldEnd()
11828 
    iprot.readStructEnd()
11829 
 
11830 
  def write(self, oprot):
11831 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11832 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11833 
      return
3064 chandransh 11834 
    oprot.writeStructBegin('getValidOrderCount_result')
3431 rajveer 11835 
    if self.success is not None:
3064 chandransh 11836 
      oprot.writeFieldBegin('success', TType.I64, 0)
11837 
      oprot.writeI64(self.success)
94 ashish 11838 
      oprot.writeFieldEnd()
11839 
    oprot.writeFieldStop()
11840 
    oprot.writeStructEnd()
11841 
 
3431 rajveer 11842 
  def validate(self):
11843 
    return
11844 
 
11845 
 
94 ashish 11846 
  def __repr__(self):
11847 
    L = ['%s=%r' % (key, value)
11848 
      for key, value in self.__dict__.iteritems()]
11849 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11850 
 
11851 
  def __eq__(self, other):
11852 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11853 
 
11854 
  def __ne__(self, other):
11855 
    return not (self == other)
11856 
 
3064 chandransh 11857 
class getNoOfCustomersWithSuccessfulTransaction_args:
11858 
 
11859 
  thrift_spec = (
11860 
  )
11861 
 
11862 
  def read(self, iprot):
11863 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11864 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11865 
      return
11866 
    iprot.readStructBegin()
11867 
    while True:
11868 
      (fname, ftype, fid) = iprot.readFieldBegin()
11869 
      if ftype == TType.STOP:
11870 
        break
11871 
      else:
11872 
        iprot.skip(ftype)
11873 
      iprot.readFieldEnd()
11874 
    iprot.readStructEnd()
11875 
 
11876 
  def write(self, oprot):
11877 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11878 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11879 
      return
11880 
    oprot.writeStructBegin('getNoOfCustomersWithSuccessfulTransaction_args')
11881 
    oprot.writeFieldStop()
11882 
    oprot.writeStructEnd()
11883 
 
3431 rajveer 11884 
  def validate(self):
11885 
    return
11886 
 
11887 
 
3064 chandransh 11888 
  def __repr__(self):
11889 
    L = ['%s=%r' % (key, value)
11890 
      for key, value in self.__dict__.iteritems()]
11891 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11892 
 
11893 
  def __eq__(self, other):
11894 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11895 
 
11896 
  def __ne__(self, other):
11897 
    return not (self == other)
11898 
 
11899 
class getNoOfCustomersWithSuccessfulTransaction_result:
94 ashish 11900 
  """
11901 
  Attributes:
3064 chandransh 11902 
   - success
94 ashish 11903 
  """
11904 
 
11905 
  thrift_spec = (
3064 chandransh 11906 
    (0, TType.I64, 'success', None, None, ), # 0
94 ashish 11907 
  )
11908 
 
3064 chandransh 11909 
  def __init__(self, success=None,):
11910 
    self.success = success
94 ashish 11911 
 
11912 
  def read(self, iprot):
11913 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11914 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11915 
      return
11916 
    iprot.readStructBegin()
11917 
    while True:
11918 
      (fname, ftype, fid) = iprot.readFieldBegin()
11919 
      if ftype == TType.STOP:
11920 
        break
3064 chandransh 11921 
      if fid == 0:
94 ashish 11922 
        if ftype == TType.I64:
3064 chandransh 11923 
          self.success = iprot.readI64();
94 ashish 11924 
        else:
11925 
          iprot.skip(ftype)
11926 
      else:
11927 
        iprot.skip(ftype)
11928 
      iprot.readFieldEnd()
11929 
    iprot.readStructEnd()
11930 
 
11931 
  def write(self, oprot):
11932 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11933 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11934 
      return
3064 chandransh 11935 
    oprot.writeStructBegin('getNoOfCustomersWithSuccessfulTransaction_result')
3431 rajveer 11936 
    if self.success is not None:
3064 chandransh 11937 
      oprot.writeFieldBegin('success', TType.I64, 0)
11938 
      oprot.writeI64(self.success)
94 ashish 11939 
      oprot.writeFieldEnd()
11940 
    oprot.writeFieldStop()
11941 
    oprot.writeStructEnd()
11942 
 
3431 rajveer 11943 
  def validate(self):
11944 
    return
11945 
 
11946 
 
94 ashish 11947 
  def __repr__(self):
11948 
    L = ['%s=%r' % (key, value)
11949 
      for key, value in self.__dict__.iteritems()]
11950 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11951 
 
11952 
  def __eq__(self, other):
11953 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11954 
 
11955 
  def __ne__(self, other):
11956 
    return not (self == other)
11957 
 
3064 chandransh 11958 
class getValidOrdersAmountRange_args:
11959 
 
11960 
  thrift_spec = (
11961 
  )
11962 
 
11963 
  def read(self, iprot):
11964 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11965 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11966 
      return
11967 
    iprot.readStructBegin()
11968 
    while True:
11969 
      (fname, ftype, fid) = iprot.readFieldBegin()
11970 
      if ftype == TType.STOP:
11971 
        break
11972 
      else:
11973 
        iprot.skip(ftype)
11974 
      iprot.readFieldEnd()
11975 
    iprot.readStructEnd()
11976 
 
11977 
  def write(self, oprot):
11978 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11979 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11980 
      return
11981 
    oprot.writeStructBegin('getValidOrdersAmountRange_args')
11982 
    oprot.writeFieldStop()
11983 
    oprot.writeStructEnd()
11984 
 
3431 rajveer 11985 
  def validate(self):
11986 
    return
11987 
 
11988 
 
3064 chandransh 11989 
  def __repr__(self):
11990 
    L = ['%s=%r' % (key, value)
11991 
      for key, value in self.__dict__.iteritems()]
11992 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11993 
 
11994 
  def __eq__(self, other):
11995 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11996 
 
11997 
  def __ne__(self, other):
11998 
    return not (self == other)
11999 
 
12000 
class getValidOrdersAmountRange_result:
94 ashish 12001 
  """
12002 
  Attributes:
12003 
   - success
12004 
  """
12005 
 
12006 
  thrift_spec = (
3064 chandransh 12007 
    (0, TType.LIST, 'success', (TType.DOUBLE,None), None, ), # 0
94 ashish 12008 
  )
12009 
 
3064 chandransh 12010 
  def __init__(self, success=None,):
94 ashish 12011 
    self.success = success
12012 
 
12013 
  def read(self, iprot):
12014 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12015 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12016 
      return
12017 
    iprot.readStructBegin()
12018 
    while True:
12019 
      (fname, ftype, fid) = iprot.readFieldBegin()
12020 
      if ftype == TType.STOP:
12021 
        break
12022 
      if fid == 0:
483 rajveer 12023 
        if ftype == TType.LIST:
12024 
          self.success = []
6000 mandeep.dh 12025 
          (_etype213, _size210) = iprot.readListBegin()
12026 
          for _i214 in xrange(_size210):
12027 
            _elem215 = iprot.readDouble();
12028 
            self.success.append(_elem215)
483 rajveer 12029 
          iprot.readListEnd()
94 ashish 12030 
        else:
12031 
          iprot.skip(ftype)
12032 
      else:
12033 
        iprot.skip(ftype)
12034 
      iprot.readFieldEnd()
12035 
    iprot.readStructEnd()
12036 
 
12037 
  def write(self, oprot):
12038 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12039 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12040 
      return
3064 chandransh 12041 
    oprot.writeStructBegin('getValidOrdersAmountRange_result')
3431 rajveer 12042 
    if self.success is not None:
483 rajveer 12043 
      oprot.writeFieldBegin('success', TType.LIST, 0)
3064 chandransh 12044 
      oprot.writeListBegin(TType.DOUBLE, len(self.success))
6000 mandeep.dh 12045 
      for iter216 in self.success:
12046 
        oprot.writeDouble(iter216)
483 rajveer 12047 
      oprot.writeListEnd()
94 ashish 12048 
      oprot.writeFieldEnd()
12049 
    oprot.writeFieldStop()
12050 
    oprot.writeStructEnd()
12051 
 
3431 rajveer 12052 
  def validate(self):
12053 
    return
12054 
 
12055 
 
94 ashish 12056 
  def __repr__(self):
12057 
    L = ['%s=%r' % (key, value)
12058 
      for key, value in self.__dict__.iteritems()]
12059 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12060 
 
12061 
  def __eq__(self, other):
12062 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12063 
 
12064 
  def __ne__(self, other):
12065 
    return not (self == other)
12066 
 
3064 chandransh 12067 
class getValidOrders_args:
1528 ankur.sing 12068 
  """
12069 
  Attributes:
3064 chandransh 12070 
   - limit
5874 rajveer 12071 
   - onlyStore
1528 ankur.sing 12072 
  """
12073 
 
12074 
  thrift_spec = (
12075 
    None, # 0
3064 chandransh 12076 
    (1, TType.I64, 'limit', None, None, ), # 1
5874 rajveer 12077 
    (2, TType.BOOL, 'onlyStore', None, None, ), # 2
1528 ankur.sing 12078 
  )
12079 
 
5874 rajveer 12080 
  def __init__(self, limit=None, onlyStore=None,):
3064 chandransh 12081 
    self.limit = limit
5874 rajveer 12082 
    self.onlyStore = onlyStore
1528 ankur.sing 12083 
 
12084 
  def read(self, iprot):
12085 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12086 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12087 
      return
12088 
    iprot.readStructBegin()
12089 
    while True:
12090 
      (fname, ftype, fid) = iprot.readFieldBegin()
12091 
      if ftype == TType.STOP:
12092 
        break
12093 
      if fid == 1:
12094 
        if ftype == TType.I64:
3064 chandransh 12095 
          self.limit = iprot.readI64();
1528 ankur.sing 12096 
        else:
12097 
          iprot.skip(ftype)
5874 rajveer 12098 
      elif fid == 2:
12099 
        if ftype == TType.BOOL:
12100 
          self.onlyStore = iprot.readBool();
12101 
        else:
12102 
          iprot.skip(ftype)
1528 ankur.sing 12103 
      else:
12104 
        iprot.skip(ftype)
12105 
      iprot.readFieldEnd()
12106 
    iprot.readStructEnd()
12107 
 
12108 
  def write(self, oprot):
12109 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12110 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12111 
      return
3064 chandransh 12112 
    oprot.writeStructBegin('getValidOrders_args')
3431 rajveer 12113 
    if self.limit is not None:
3064 chandransh 12114 
      oprot.writeFieldBegin('limit', TType.I64, 1)
12115 
      oprot.writeI64(self.limit)
1528 ankur.sing 12116 
      oprot.writeFieldEnd()
5874 rajveer 12117 
    if self.onlyStore is not None:
12118 
      oprot.writeFieldBegin('onlyStore', TType.BOOL, 2)
12119 
      oprot.writeBool(self.onlyStore)
12120 
      oprot.writeFieldEnd()
1528 ankur.sing 12121 
    oprot.writeFieldStop()
12122 
    oprot.writeStructEnd()
12123 
 
3431 rajveer 12124 
  def validate(self):
12125 
    return
12126 
 
12127 
 
1528 ankur.sing 12128 
  def __repr__(self):
12129 
    L = ['%s=%r' % (key, value)
12130 
      for key, value in self.__dict__.iteritems()]
12131 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12132 
 
12133 
  def __eq__(self, other):
12134 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12135 
 
12136 
  def __ne__(self, other):
12137 
    return not (self == other)
12138 
 
3064 chandransh 12139 
class getValidOrders_result:
1528 ankur.sing 12140 
  """
12141 
  Attributes:
12142 
   - success
12143 
  """
12144 
 
12145 
  thrift_spec = (
3064 chandransh 12146 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
1528 ankur.sing 12147 
  )
12148 
 
3064 chandransh 12149 
  def __init__(self, success=None,):
1528 ankur.sing 12150 
    self.success = success
12151 
 
12152 
  def read(self, iprot):
12153 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12154 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12155 
      return
12156 
    iprot.readStructBegin()
12157 
    while True:
12158 
      (fname, ftype, fid) = iprot.readFieldBegin()
12159 
      if ftype == TType.STOP:
12160 
        break
12161 
      if fid == 0:
3064 chandransh 12162 
        if ftype == TType.LIST:
12163 
          self.success = []
6000 mandeep.dh 12164 
          (_etype220, _size217) = iprot.readListBegin()
12165 
          for _i221 in xrange(_size217):
12166 
            _elem222 = Order()
12167 
            _elem222.read(iprot)
12168 
            self.success.append(_elem222)
3064 chandransh 12169 
          iprot.readListEnd()
1528 ankur.sing 12170 
        else:
12171 
          iprot.skip(ftype)
12172 
      else:
12173 
        iprot.skip(ftype)
12174 
      iprot.readFieldEnd()
12175 
    iprot.readStructEnd()
12176 
 
12177 
  def write(self, oprot):
12178 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12179 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12180 
      return
3064 chandransh 12181 
    oprot.writeStructBegin('getValidOrders_result')
3431 rajveer 12182 
    if self.success is not None:
3064 chandransh 12183 
      oprot.writeFieldBegin('success', TType.LIST, 0)
12184 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
6000 mandeep.dh 12185 
      for iter223 in self.success:
12186 
        iter223.write(oprot)
3064 chandransh 12187 
      oprot.writeListEnd()
1528 ankur.sing 12188 
      oprot.writeFieldEnd()
12189 
    oprot.writeFieldStop()
12190 
    oprot.writeStructEnd()
12191 
 
3431 rajveer 12192 
  def validate(self):
12193 
    return
12194 
 
12195 
 
1528 ankur.sing 12196 
  def __repr__(self):
12197 
    L = ['%s=%r' % (key, value)
12198 
      for key, value in self.__dict__.iteritems()]
12199 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12200 
 
12201 
  def __eq__(self, other):
12202 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12203 
 
12204 
  def __ne__(self, other):
12205 
    return not (self == other)
12206 
 
1220 chandransh 12207 
class batchOrders_args:
12208 
  """
12209 
  Attributes:
12210 
   - warehouseId
12211 
  """
12212 
 
12213 
  thrift_spec = (
12214 
    None, # 0
12215 
    (1, TType.I64, 'warehouseId', None, None, ), # 1
12216 
  )
12217 
 
12218 
  def __init__(self, warehouseId=None,):
12219 
    self.warehouseId = warehouseId
12220 
 
12221 
  def read(self, iprot):
12222 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12223 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12224 
      return
12225 
    iprot.readStructBegin()
12226 
    while True:
12227 
      (fname, ftype, fid) = iprot.readFieldBegin()
12228 
      if ftype == TType.STOP:
12229 
        break
12230 
      if fid == 1:
12231 
        if ftype == TType.I64:
12232 
          self.warehouseId = iprot.readI64();
12233 
        else:
12234 
          iprot.skip(ftype)
12235 
      else:
12236 
        iprot.skip(ftype)
12237 
      iprot.readFieldEnd()
12238 
    iprot.readStructEnd()
12239 
 
12240 
  def write(self, oprot):
12241 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12242 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12243 
      return
12244 
    oprot.writeStructBegin('batchOrders_args')
3431 rajveer 12245 
    if self.warehouseId is not None:
1220 chandransh 12246 
      oprot.writeFieldBegin('warehouseId', TType.I64, 1)
12247 
      oprot.writeI64(self.warehouseId)
12248 
      oprot.writeFieldEnd()
12249 
    oprot.writeFieldStop()
12250 
    oprot.writeStructEnd()
12251 
 
3431 rajveer 12252 
  def validate(self):
12253 
    return
12254 
 
12255 
 
1220 chandransh 12256 
  def __repr__(self):
12257 
    L = ['%s=%r' % (key, value)
12258 
      for key, value in self.__dict__.iteritems()]
12259 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12260 
 
12261 
  def __eq__(self, other):
12262 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12263 
 
12264 
  def __ne__(self, other):
12265 
    return not (self == other)
12266 
 
12267 
class batchOrders_result:
12268 
  """
12269 
  Attributes:
12270 
   - success
12271 
   - ex
12272 
  """
12273 
 
12274 
  thrift_spec = (
12275 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
12276 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
12277 
  )
12278 
 
12279 
  def __init__(self, success=None, ex=None,):
12280 
    self.success = success
12281 
    self.ex = ex
12282 
 
12283 
  def read(self, iprot):
12284 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12285 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12286 
      return
12287 
    iprot.readStructBegin()
12288 
    while True:
12289 
      (fname, ftype, fid) = iprot.readFieldBegin()
12290 
      if ftype == TType.STOP:
12291 
        break
12292 
      if fid == 0:
12293 
        if ftype == TType.LIST:
12294 
          self.success = []
6000 mandeep.dh 12295 
          (_etype227, _size224) = iprot.readListBegin()
12296 
          for _i228 in xrange(_size224):
12297 
            _elem229 = Order()
12298 
            _elem229.read(iprot)
12299 
            self.success.append(_elem229)
1220 chandransh 12300 
          iprot.readListEnd()
12301 
        else:
12302 
          iprot.skip(ftype)
12303 
      elif fid == 1:
12304 
        if ftype == TType.STRUCT:
12305 
          self.ex = TransactionServiceException()
12306 
          self.ex.read(iprot)
12307 
        else:
12308 
          iprot.skip(ftype)
12309 
      else:
12310 
        iprot.skip(ftype)
12311 
      iprot.readFieldEnd()
12312 
    iprot.readStructEnd()
12313 
 
12314 
  def write(self, oprot):
12315 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12316 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12317 
      return
12318 
    oprot.writeStructBegin('batchOrders_result')
3431 rajveer 12319 
    if self.success is not None:
1220 chandransh 12320 
      oprot.writeFieldBegin('success', TType.LIST, 0)
12321 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
6000 mandeep.dh 12322 
      for iter230 in self.success:
12323 
        iter230.write(oprot)
1220 chandransh 12324 
      oprot.writeListEnd()
12325 
      oprot.writeFieldEnd()
3431 rajveer 12326 
    if self.ex is not None:
1220 chandransh 12327 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
12328 
      self.ex.write(oprot)
12329 
      oprot.writeFieldEnd()
12330 
    oprot.writeFieldStop()
12331 
    oprot.writeStructEnd()
12332 
 
3431 rajveer 12333 
  def validate(self):
12334 
    return
12335 
 
12336 
 
1220 chandransh 12337 
  def __repr__(self):
12338 
    L = ['%s=%r' % (key, value)
12339 
      for key, value in self.__dict__.iteritems()]
12340 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12341 
 
12342 
  def __eq__(self, other):
12343 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12344 
 
12345 
  def __ne__(self, other):
12346 
    return not (self == other)
12347 
 
1208 chandransh 12348 
class markOrderAsOutOfStock_args:
12349 
  """
12350 
  Attributes:
12351 
   - orderId
12352 
  """
12353 
 
12354 
  thrift_spec = (
12355 
    None, # 0
12356 
    (1, TType.I64, 'orderId', None, None, ), # 1
12357 
  )
12358 
 
12359 
  def __init__(self, orderId=None,):
12360 
    self.orderId = orderId
12361 
 
12362 
  def read(self, iprot):
12363 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12364 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12365 
      return
12366 
    iprot.readStructBegin()
12367 
    while True:
12368 
      (fname, ftype, fid) = iprot.readFieldBegin()
12369 
      if ftype == TType.STOP:
12370 
        break
12371 
      if fid == 1:
12372 
        if ftype == TType.I64:
12373 
          self.orderId = iprot.readI64();
12374 
        else:
12375 
          iprot.skip(ftype)
12376 
      else:
12377 
        iprot.skip(ftype)
12378 
      iprot.readFieldEnd()
12379 
    iprot.readStructEnd()
12380 
 
12381 
  def write(self, oprot):
12382 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12383 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12384 
      return
12385 
    oprot.writeStructBegin('markOrderAsOutOfStock_args')
3431 rajveer 12386 
    if self.orderId is not None:
1208 chandransh 12387 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
12388 
      oprot.writeI64(self.orderId)
12389 
      oprot.writeFieldEnd()
12390 
    oprot.writeFieldStop()
12391 
    oprot.writeStructEnd()
12392 
 
3431 rajveer 12393 
  def validate(self):
12394 
    return
12395 
 
12396 
 
1208 chandransh 12397 
  def __repr__(self):
12398 
    L = ['%s=%r' % (key, value)
12399 
      for key, value in self.__dict__.iteritems()]
12400 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12401 
 
12402 
  def __eq__(self, other):
12403 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12404 
 
12405 
  def __ne__(self, other):
12406 
    return not (self == other)
12407 
 
12408 
class markOrderAsOutOfStock_result:
12409 
  """
12410 
  Attributes:
12411 
   - success
12412 
   - ex
12413 
  """
12414 
 
12415 
  thrift_spec = (
12416 
    (0, TType.BOOL, 'success', None, None, ), # 0
12417 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
12418 
  )
12419 
 
12420 
  def __init__(self, success=None, ex=None,):
12421 
    self.success = success
12422 
    self.ex = ex
12423 
 
12424 
  def read(self, iprot):
12425 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12426 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12427 
      return
12428 
    iprot.readStructBegin()
12429 
    while True:
12430 
      (fname, ftype, fid) = iprot.readFieldBegin()
12431 
      if ftype == TType.STOP:
12432 
        break
12433 
      if fid == 0:
12434 
        if ftype == TType.BOOL:
12435 
          self.success = iprot.readBool();
12436 
        else:
12437 
          iprot.skip(ftype)
12438 
      elif fid == 1:
12439 
        if ftype == TType.STRUCT:
12440 
          self.ex = TransactionServiceException()
12441 
          self.ex.read(iprot)
12442 
        else:
12443 
          iprot.skip(ftype)
12444 
      else:
12445 
        iprot.skip(ftype)
12446 
      iprot.readFieldEnd()
12447 
    iprot.readStructEnd()
12448 
 
12449 
  def write(self, oprot):
12450 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12451 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12452 
      return
12453 
    oprot.writeStructBegin('markOrderAsOutOfStock_result')
3431 rajveer 12454 
    if self.success is not None:
1208 chandransh 12455 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
12456 
      oprot.writeBool(self.success)
12457 
      oprot.writeFieldEnd()
3431 rajveer 12458 
    if self.ex is not None:
1208 chandransh 12459 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
12460 
      self.ex.write(oprot)
12461 
      oprot.writeFieldEnd()
12462 
    oprot.writeFieldStop()
12463 
    oprot.writeStructEnd()
12464 
 
3431 rajveer 12465 
  def validate(self):
12466 
    return
12467 
 
12468 
 
1208 chandransh 12469 
  def __repr__(self):
12470 
    L = ['%s=%r' % (key, value)
12471 
      for key, value in self.__dict__.iteritems()]
12472 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12473 
 
12474 
  def __eq__(self, other):
12475 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12476 
 
12477 
  def __ne__(self, other):
12478 
    return not (self == other)
12479 
 
3064 chandransh 12480 
class verifyOrder_args:
759 chandransh 12481 
  """
12482 
  Attributes:
3064 chandransh 12483 
   - orderId
759 chandransh 12484 
  """
12485 
 
12486 
  thrift_spec = (
12487 
    None, # 0
3064 chandransh 12488 
    (1, TType.I64, 'orderId', None, None, ), # 1
759 chandransh 12489 
  )
12490 
 
3064 chandransh 12491 
  def __init__(self, orderId=None,):
12492 
    self.orderId = orderId
759 chandransh 12493 
 
12494 
  def read(self, iprot):
12495 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12496 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12497 
      return
12498 
    iprot.readStructBegin()
12499 
    while True:
12500 
      (fname, ftype, fid) = iprot.readFieldBegin()
12501 
      if ftype == TType.STOP:
12502 
        break
12503 
      if fid == 1:
12504 
        if ftype == TType.I64:
3064 chandransh 12505 
          self.orderId = iprot.readI64();
759 chandransh 12506 
        else:
12507 
          iprot.skip(ftype)
12508 
      else:
12509 
        iprot.skip(ftype)
12510 
      iprot.readFieldEnd()
12511 
    iprot.readStructEnd()
12512 
 
12513 
  def write(self, oprot):
12514 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12515 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12516 
      return
3064 chandransh 12517 
    oprot.writeStructBegin('verifyOrder_args')
3431 rajveer 12518 
    if self.orderId is not None:
3064 chandransh 12519 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
12520 
      oprot.writeI64(self.orderId)
759 chandransh 12521 
      oprot.writeFieldEnd()
12522 
    oprot.writeFieldStop()
12523 
    oprot.writeStructEnd()
12524 
 
3431 rajveer 12525 
  def validate(self):
12526 
    return
12527 
 
12528 
 
759 chandransh 12529 
  def __repr__(self):
12530 
    L = ['%s=%r' % (key, value)
12531 
      for key, value in self.__dict__.iteritems()]
12532 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12533 
 
12534 
  def __eq__(self, other):
12535 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12536 
 
12537 
  def __ne__(self, other):
12538 
    return not (self == other)
12539 
 
3064 chandransh 12540 
class verifyOrder_result:
759 chandransh 12541 
  """
12542 
  Attributes:
12543 
   - success
12544 
   - ex
12545 
  """
12546 
 
12547 
  thrift_spec = (
12548 
    (0, TType.BOOL, 'success', None, None, ), # 0
12549 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
12550 
  )
12551 
 
12552 
  def __init__(self, success=None, ex=None,):
12553 
    self.success = success
12554 
    self.ex = ex
12555 
 
12556 
  def read(self, iprot):
12557 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12558 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12559 
      return
12560 
    iprot.readStructBegin()
12561 
    while True:
12562 
      (fname, ftype, fid) = iprot.readFieldBegin()
12563 
      if ftype == TType.STOP:
12564 
        break
12565 
      if fid == 0:
12566 
        if ftype == TType.BOOL:
12567 
          self.success = iprot.readBool();
12568 
        else:
12569 
          iprot.skip(ftype)
12570 
      elif fid == 1:
12571 
        if ftype == TType.STRUCT:
12572 
          self.ex = TransactionServiceException()
12573 
          self.ex.read(iprot)
12574 
        else:
12575 
          iprot.skip(ftype)
12576 
      else:
12577 
        iprot.skip(ftype)
12578 
      iprot.readFieldEnd()
12579 
    iprot.readStructEnd()
12580 
 
12581 
  def write(self, oprot):
12582 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12583 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12584 
      return
3064 chandransh 12585 
    oprot.writeStructBegin('verifyOrder_result')
3431 rajveer 12586 
    if self.success is not None:
759 chandransh 12587 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
12588 
      oprot.writeBool(self.success)
12589 
      oprot.writeFieldEnd()
3431 rajveer 12590 
    if self.ex is not None:
759 chandransh 12591 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
12592 
      self.ex.write(oprot)
12593 
      oprot.writeFieldEnd()
12594 
    oprot.writeFieldStop()
12595 
    oprot.writeStructEnd()
12596 
 
3431 rajveer 12597 
  def validate(self):
12598 
    return
12599 
 
12600 
 
759 chandransh 12601 
  def __repr__(self):
12602 
    L = ['%s=%r' % (key, value)
12603 
      for key, value in self.__dict__.iteritems()]
12604 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12605 
 
12606 
  def __eq__(self, other):
12607 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12608 
 
12609 
  def __ne__(self, other):
12610 
    return not (self == other)
12611 
 
3064 chandransh 12612 
class acceptOrder_args:
1113 chandransh 12613 
  """
12614 
  Attributes:
3064 chandransh 12615 
   - orderId
1113 chandransh 12616 
  """
12617 
 
12618 
  thrift_spec = (
12619 
    None, # 0
3064 chandransh 12620 
    (1, TType.I64, 'orderId', None, None, ), # 1
1113 chandransh 12621 
  )
12622 
 
3064 chandransh 12623 
  def __init__(self, orderId=None,):
12624 
    self.orderId = orderId
1113 chandransh 12625 
 
12626 
  def read(self, iprot):
12627 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12628 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12629 
      return
12630 
    iprot.readStructBegin()
12631 
    while True:
12632 
      (fname, ftype, fid) = iprot.readFieldBegin()
12633 
      if ftype == TType.STOP:
12634 
        break
12635 
      if fid == 1:
12636 
        if ftype == TType.I64:
3064 chandransh 12637 
          self.orderId = iprot.readI64();
1113 chandransh 12638 
        else:
12639 
          iprot.skip(ftype)
12640 
      else:
12641 
        iprot.skip(ftype)
12642 
      iprot.readFieldEnd()
12643 
    iprot.readStructEnd()
12644 
 
12645 
  def write(self, oprot):
12646 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12647 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12648 
      return
3064 chandransh 12649 
    oprot.writeStructBegin('acceptOrder_args')
3431 rajveer 12650 
    if self.orderId is not None:
3064 chandransh 12651 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
12652 
      oprot.writeI64(self.orderId)
1113 chandransh 12653 
      oprot.writeFieldEnd()
12654 
    oprot.writeFieldStop()
12655 
    oprot.writeStructEnd()
12656 
 
3431 rajveer 12657 
  def validate(self):
12658 
    return
12659 
 
12660 
 
1113 chandransh 12661 
  def __repr__(self):
12662 
    L = ['%s=%r' % (key, value)
12663 
      for key, value in self.__dict__.iteritems()]
12664 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12665 
 
12666 
  def __eq__(self, other):
12667 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12668 
 
12669 
  def __ne__(self, other):
12670 
    return not (self == other)
12671 
 
3064 chandransh 12672 
class acceptOrder_result:
1113 chandransh 12673 
  """
12674 
  Attributes:
12675 
   - success
12676 
   - ex
12677 
  """
12678 
 
12679 
  thrift_spec = (
3064 chandransh 12680 
    (0, TType.BOOL, 'success', None, None, ), # 0
1113 chandransh 12681 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
12682 
  )
12683 
 
12684 
  def __init__(self, success=None, ex=None,):
12685 
    self.success = success
12686 
    self.ex = ex
12687 
 
12688 
  def read(self, iprot):
12689 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12690 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12691 
      return
12692 
    iprot.readStructBegin()
12693 
    while True:
12694 
      (fname, ftype, fid) = iprot.readFieldBegin()
12695 
      if ftype == TType.STOP:
12696 
        break
12697 
      if fid == 0:
3064 chandransh 12698 
        if ftype == TType.BOOL:
12699 
          self.success = iprot.readBool();
1113 chandransh 12700 
        else:
12701 
          iprot.skip(ftype)
12702 
      elif fid == 1:
12703 
        if ftype == TType.STRUCT:
12704 
          self.ex = TransactionServiceException()
12705 
          self.ex.read(iprot)
12706 
        else:
12707 
          iprot.skip(ftype)
12708 
      else:
12709 
        iprot.skip(ftype)
12710 
      iprot.readFieldEnd()
12711 
    iprot.readStructEnd()
12712 
 
12713 
  def write(self, oprot):
12714 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12715 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12716 
      return
3064 chandransh 12717 
    oprot.writeStructBegin('acceptOrder_result')
3431 rajveer 12718 
    if self.success is not None:
3064 chandransh 12719 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
12720 
      oprot.writeBool(self.success)
1113 chandransh 12721 
      oprot.writeFieldEnd()
3431 rajveer 12722 
    if self.ex is not None:
1113 chandransh 12723 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
12724 
      self.ex.write(oprot)
12725 
      oprot.writeFieldEnd()
12726 
    oprot.writeFieldStop()
12727 
    oprot.writeStructEnd()
12728 
 
3431 rajveer 12729 
  def validate(self):
12730 
    return
12731 
 
12732 
 
1113 chandransh 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 
 
3064 chandransh 12744 
class addBillingDetails_args:
1135 chandransh 12745 
  """
12746 
  Attributes:
3064 chandransh 12747 
   - orderId
12748 
   - invoice_number
4658 mandeep.dh 12749 
   - serialNumber
4283 anupam.sin 12750 
   - itemNumber
3064 chandransh 12751 
   - billed_by
4264 rajveer 12752 
   - jacketNumber
4283 anupam.sin 12753 
   - billingType
5110 mandeep.dh 12754 
   - fulfilmentWarehouseId
4763 rajveer 12755 
   - authorize
1135 chandransh 12756 
  """
12757 
 
12758 
  thrift_spec = (
12759 
    None, # 0
3064 chandransh 12760 
    (1, TType.I64, 'orderId', None, None, ), # 1
12761 
    (2, TType.STRING, 'invoice_number', None, None, ), # 2
5411 rajveer 12762 
    (3, TType.LIST, 'serialNumber', (TType.STRING,None), None, ), # 3
12763 
    (4, TType.LIST, 'itemNumber', (TType.STRING,None), None, ), # 4
4283 anupam.sin 12764 
    (5, TType.STRING, 'billed_by', None, None, ), # 5
12765 
    (6, TType.I64, 'jacketNumber', None, None, ), # 6
12766 
    (7, TType.I64, 'billingType', None, None, ), # 7
5110 mandeep.dh 12767 
    (8, TType.I64, 'fulfilmentWarehouseId', None, None, ), # 8
4763 rajveer 12768 
    (9, TType.BOOL, 'authorize', None, None, ), # 9
1135 chandransh 12769 
  )
12770 
 
5110 mandeep.dh 12771 
  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 12772 
    self.orderId = orderId
12773 
    self.invoice_number = invoice_number
4658 mandeep.dh 12774 
    self.serialNumber = serialNumber
4283 anupam.sin 12775 
    self.itemNumber = itemNumber
3064 chandransh 12776 
    self.billed_by = billed_by
4264 rajveer 12777 
    self.jacketNumber = jacketNumber
4283 anupam.sin 12778 
    self.billingType = billingType
5110 mandeep.dh 12779 
    self.fulfilmentWarehouseId = fulfilmentWarehouseId
4763 rajveer 12780 
    self.authorize = authorize
1135 chandransh 12781 
 
12782 
  def read(self, iprot):
12783 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12784 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12785 
      return
12786 
    iprot.readStructBegin()
12787 
    while True:
12788 
      (fname, ftype, fid) = iprot.readFieldBegin()
12789 
      if ftype == TType.STOP:
12790 
        break
12791 
      if fid == 1:
12792 
        if ftype == TType.I64:
3064 chandransh 12793 
          self.orderId = iprot.readI64();
1135 chandransh 12794 
        else:
12795 
          iprot.skip(ftype)
12796 
      elif fid == 2:
3064 chandransh 12797 
        if ftype == TType.STRING:
12798 
          self.invoice_number = iprot.readString();
1135 chandransh 12799 
        else:
12800 
          iprot.skip(ftype)
3064 chandransh 12801 
      elif fid == 3:
5411 rajveer 12802 
        if ftype == TType.LIST:
12803 
          self.serialNumber = []
6000 mandeep.dh 12804 
          (_etype234, _size231) = iprot.readListBegin()
12805 
          for _i235 in xrange(_size231):
12806 
            _elem236 = iprot.readString();
12807 
            self.serialNumber.append(_elem236)
5411 rajveer 12808 
          iprot.readListEnd()
3064 chandransh 12809 
        else:
12810 
          iprot.skip(ftype)
12811 
      elif fid == 4:
5411 rajveer 12812 
        if ftype == TType.LIST:
12813 
          self.itemNumber = []
6000 mandeep.dh 12814 
          (_etype240, _size237) = iprot.readListBegin()
12815 
          for _i241 in xrange(_size237):
12816 
            _elem242 = iprot.readString();
12817 
            self.itemNumber.append(_elem242)
5411 rajveer 12818 
          iprot.readListEnd()
3064 chandransh 12819 
        else:
12820 
          iprot.skip(ftype)
12821 
      elif fid == 5:
12822 
        if ftype == TType.STRING:
4283 anupam.sin 12823 
          self.billed_by = iprot.readString();
3064 chandransh 12824 
        else:
12825 
          iprot.skip(ftype)
12826 
      elif fid == 6:
12827 
        if ftype == TType.I64:
4283 anupam.sin 12828 
          self.jacketNumber = iprot.readI64();
12829 
        else:
12830 
          iprot.skip(ftype)
12831 
      elif fid == 7:
12832 
        if ftype == TType.I64:
3064 chandransh 12833 
          self.billingType = iprot.readI64();
12834 
        else:
12835 
          iprot.skip(ftype)
4283 anupam.sin 12836 
      elif fid == 8:
12837 
        if ftype == TType.I64:
5110 mandeep.dh 12838 
          self.fulfilmentWarehouseId = iprot.readI64();
4283 anupam.sin 12839 
        else:
12840 
          iprot.skip(ftype)
4763 rajveer 12841 
      elif fid == 9:
12842 
        if ftype == TType.BOOL:
12843 
          self.authorize = iprot.readBool();
12844 
        else:
12845 
          iprot.skip(ftype)
1246 chandransh 12846 
      else:
12847 
        iprot.skip(ftype)
12848 
      iprot.readFieldEnd()
12849 
    iprot.readStructEnd()
12850 
 
12851 
  def write(self, oprot):
12852 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12853 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12854 
      return
4283 anupam.sin 12855 
    oprot.writeStructBegin('addBillingDetails_args')
3431 rajveer 12856 
    if self.orderId is not None:
3064 chandransh 12857 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
12858 
      oprot.writeI64(self.orderId)
1246 chandransh 12859 
      oprot.writeFieldEnd()
4283 anupam.sin 12860 
    if self.invoice_number is not None:
12861 
      oprot.writeFieldBegin('invoice_number', TType.STRING, 2)
12862 
      oprot.writeString(self.invoice_number)
1246 chandransh 12863 
      oprot.writeFieldEnd()
4658 mandeep.dh 12864 
    if self.serialNumber is not None:
5411 rajveer 12865 
      oprot.writeFieldBegin('serialNumber', TType.LIST, 3)
12866 
      oprot.writeListBegin(TType.STRING, len(self.serialNumber))
6000 mandeep.dh 12867 
      for iter243 in self.serialNumber:
12868 
        oprot.writeString(iter243)
5411 rajveer 12869 
      oprot.writeListEnd()
3064 chandransh 12870 
      oprot.writeFieldEnd()
3431 rajveer 12871 
    if self.itemNumber is not None:
5411 rajveer 12872 
      oprot.writeFieldBegin('itemNumber', TType.LIST, 4)
12873 
      oprot.writeListBegin(TType.STRING, len(self.itemNumber))
6000 mandeep.dh 12874 
      for iter244 in self.itemNumber:
12875 
        oprot.writeString(iter244)
5411 rajveer 12876 
      oprot.writeListEnd()
3064 chandransh 12877 
      oprot.writeFieldEnd()
4283 anupam.sin 12878 
    if self.billed_by is not None:
12879 
      oprot.writeFieldBegin('billed_by', TType.STRING, 5)
12880 
      oprot.writeString(self.billed_by)
3064 chandransh 12881 
      oprot.writeFieldEnd()
4283 anupam.sin 12882 
    if self.jacketNumber is not None:
12883 
      oprot.writeFieldBegin('jacketNumber', TType.I64, 6)
12884 
      oprot.writeI64(self.jacketNumber)
12885 
      oprot.writeFieldEnd()
3431 rajveer 12886 
    if self.billingType is not None:
4283 anupam.sin 12887 
      oprot.writeFieldBegin('billingType', TType.I64, 7)
3064 chandransh 12888 
      oprot.writeI64(self.billingType)
12889 
      oprot.writeFieldEnd()
5110 mandeep.dh 12890 
    if self.fulfilmentWarehouseId is not None:
12891 
      oprot.writeFieldBegin('fulfilmentWarehouseId', TType.I64, 8)
12892 
      oprot.writeI64(self.fulfilmentWarehouseId)
4283 anupam.sin 12893 
      oprot.writeFieldEnd()
4763 rajveer 12894 
    if self.authorize is not None:
12895 
      oprot.writeFieldBegin('authorize', TType.BOOL, 9)
12896 
      oprot.writeBool(self.authorize)
12897 
      oprot.writeFieldEnd()
1246 chandransh 12898 
    oprot.writeFieldStop()
12899 
    oprot.writeStructEnd()
12900 
 
3431 rajveer 12901 
  def validate(self):
12902 
    return
12903 
 
12904 
 
1246 chandransh 12905 
  def __repr__(self):
12906 
    L = ['%s=%r' % (key, value)
12907 
      for key, value in self.__dict__.iteritems()]
12908 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12909 
 
12910 
  def __eq__(self, other):
12911 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12912 
 
12913 
  def __ne__(self, other):
12914 
    return not (self == other)
12915 
 
4283 anupam.sin 12916 
class addBillingDetails_result:
1246 chandransh 12917 
  """
12918 
  Attributes:
3064 chandransh 12919 
   - success
1246 chandransh 12920 
   - ex
12921 
  """
12922 
 
12923 
  thrift_spec = (
3064 chandransh 12924 
    (0, TType.BOOL, 'success', None, None, ), # 0
1246 chandransh 12925 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
12926 
  )
12927 
 
3064 chandransh 12928 
  def __init__(self, success=None, ex=None,):
12929 
    self.success = success
1246 chandransh 12930 
    self.ex = ex
12931 
 
12932 
  def read(self, iprot):
12933 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12934 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12935 
      return
12936 
    iprot.readStructBegin()
12937 
    while True:
12938 
      (fname, ftype, fid) = iprot.readFieldBegin()
12939 
      if ftype == TType.STOP:
12940 
        break
3064 chandransh 12941 
      if fid == 0:
12942 
        if ftype == TType.BOOL:
12943 
          self.success = iprot.readBool();
12944 
        else:
12945 
          iprot.skip(ftype)
12946 
      elif fid == 1:
1246 chandransh 12947 
        if ftype == TType.STRUCT:
12948 
          self.ex = TransactionServiceException()
12949 
          self.ex.read(iprot)
12950 
        else:
12951 
          iprot.skip(ftype)
12952 
      else:
12953 
        iprot.skip(ftype)
12954 
      iprot.readFieldEnd()
12955 
    iprot.readStructEnd()
12956 
 
12957 
  def write(self, oprot):
12958 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12959 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12960 
      return
4283 anupam.sin 12961 
    oprot.writeStructBegin('addBillingDetails_result')
3431 rajveer 12962 
    if self.success is not None:
3064 chandransh 12963 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
12964 
      oprot.writeBool(self.success)
12965 
      oprot.writeFieldEnd()
3431 rajveer 12966 
    if self.ex is not None:
1246 chandransh 12967 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
12968 
      self.ex.write(oprot)
12969 
      oprot.writeFieldEnd()
12970 
    oprot.writeFieldStop()
12971 
    oprot.writeStructEnd()
12972 
 
3431 rajveer 12973 
  def validate(self):
12974 
    return
12975 
 
12976 
 
1246 chandransh 12977 
  def __repr__(self):
12978 
    L = ['%s=%r' % (key, value)
12979 
      for key, value in self.__dict__.iteritems()]
12980 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12981 
 
12982 
  def __eq__(self, other):
12983 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12984 
 
12985 
  def __ne__(self, other):
12986 
    return not (self == other)
12987 
 
4579 rajveer 12988 
class addInvoiceNumber_args:
12989 
  """
12990 
  Attributes:
12991 
   - orderId
12992 
   - invoiceNumber
4763 rajveer 12993 
   - color
4579 rajveer 12994 
  """
12995 
 
12996 
  thrift_spec = (
12997 
    None, # 0
12998 
    (1, TType.I64, 'orderId', None, None, ), # 1
12999 
    (2, TType.STRING, 'invoiceNumber', None, None, ), # 2
4763 rajveer 13000 
    (3, TType.STRING, 'color', None, None, ), # 3
4579 rajveer 13001 
  )
13002 
 
4763 rajveer 13003 
  def __init__(self, orderId=None, invoiceNumber=None, color=None,):
4579 rajveer 13004 
    self.orderId = orderId
13005 
    self.invoiceNumber = invoiceNumber
4763 rajveer 13006 
    self.color = color
4579 rajveer 13007 
 
13008 
  def read(self, iprot):
13009 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13010 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13011 
      return
13012 
    iprot.readStructBegin()
13013 
    while True:
13014 
      (fname, ftype, fid) = iprot.readFieldBegin()
13015 
      if ftype == TType.STOP:
13016 
        break
13017 
      if fid == 1:
13018 
        if ftype == TType.I64:
13019 
          self.orderId = iprot.readI64();
13020 
        else:
13021 
          iprot.skip(ftype)
13022 
      elif fid == 2:
13023 
        if ftype == TType.STRING:
13024 
          self.invoiceNumber = iprot.readString();
13025 
        else:
13026 
          iprot.skip(ftype)
4763 rajveer 13027 
      elif fid == 3:
13028 
        if ftype == TType.STRING:
13029 
          self.color = iprot.readString();
13030 
        else:
13031 
          iprot.skip(ftype)
4579 rajveer 13032 
      else:
13033 
        iprot.skip(ftype)
13034 
      iprot.readFieldEnd()
13035 
    iprot.readStructEnd()
13036 
 
13037 
  def write(self, oprot):
13038 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13039 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13040 
      return
13041 
    oprot.writeStructBegin('addInvoiceNumber_args')
13042 
    if self.orderId is not None:
13043 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
13044 
      oprot.writeI64(self.orderId)
13045 
      oprot.writeFieldEnd()
13046 
    if self.invoiceNumber is not None:
13047 
      oprot.writeFieldBegin('invoiceNumber', TType.STRING, 2)
13048 
      oprot.writeString(self.invoiceNumber)
13049 
      oprot.writeFieldEnd()
4763 rajveer 13050 
    if self.color is not None:
13051 
      oprot.writeFieldBegin('color', TType.STRING, 3)
13052 
      oprot.writeString(self.color)
13053 
      oprot.writeFieldEnd()
4579 rajveer 13054 
    oprot.writeFieldStop()
13055 
    oprot.writeStructEnd()
13056 
 
13057 
  def validate(self):
13058 
    return
13059 
 
13060 
 
13061 
  def __repr__(self):
13062 
    L = ['%s=%r' % (key, value)
13063 
      for key, value in self.__dict__.iteritems()]
13064 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13065 
 
13066 
  def __eq__(self, other):
13067 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13068 
 
13069 
  def __ne__(self, other):
13070 
    return not (self == other)
13071 
 
13072 
class addInvoiceNumber_result:
13073 
  """
13074 
  Attributes:
13075 
   - ex
13076 
  """
13077 
 
13078 
  thrift_spec = (
13079 
    None, # 0
13080 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
13081 
  )
13082 
 
13083 
  def __init__(self, ex=None,):
13084 
    self.ex = ex
13085 
 
13086 
  def read(self, iprot):
13087 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13088 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13089 
      return
13090 
    iprot.readStructBegin()
13091 
    while True:
13092 
      (fname, ftype, fid) = iprot.readFieldBegin()
13093 
      if ftype == TType.STOP:
13094 
        break
13095 
      if fid == 1:
13096 
        if ftype == TType.STRUCT:
13097 
          self.ex = TransactionServiceException()
13098 
          self.ex.read(iprot)
13099 
        else:
13100 
          iprot.skip(ftype)
13101 
      else:
13102 
        iprot.skip(ftype)
13103 
      iprot.readFieldEnd()
13104 
    iprot.readStructEnd()
13105 
 
13106 
  def write(self, oprot):
13107 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13108 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13109 
      return
13110 
    oprot.writeStructBegin('addInvoiceNumber_result')
13111 
    if self.ex is not None:
13112 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
13113 
      self.ex.write(oprot)
13114 
      oprot.writeFieldEnd()
13115 
    oprot.writeFieldStop()
13116 
    oprot.writeStructEnd()
13117 
 
13118 
  def validate(self):
13119 
    return
13120 
 
13121 
 
13122 
  def __repr__(self):
13123 
    L = ['%s=%r' % (key, value)
13124 
      for key, value in self.__dict__.iteritems()]
13125 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13126 
 
13127 
  def __eq__(self, other):
13128 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13129 
 
13130 
  def __ne__(self, other):
13131 
    return not (self == other)
13132 
 
4910 phani.kuma 13133 
class markOrdersAsShippedFromWarehouse_args:
1408 ankur.sing 13134 
  """
13135 
  Attributes:
3064 chandransh 13136 
   - warehouseId
1408 ankur.sing 13137 
   - providerId
3064 chandransh 13138 
   - cod
4910 phani.kuma 13139 
   - orderIds
1408 ankur.sing 13140 
  """
13141 
 
13142 
  thrift_spec = (
13143 
    None, # 0
3064 chandransh 13144 
    (1, TType.I64, 'warehouseId', None, None, ), # 1
13145 
    (2, TType.I64, 'providerId', None, None, ), # 2
13146 
    (3, TType.BOOL, 'cod', None, None, ), # 3
4910 phani.kuma 13147 
    (4, TType.LIST, 'orderIds', (TType.I64,None), None, ), # 4
1408 ankur.sing 13148 
  )
13149 
 
4910 phani.kuma 13150 
  def __init__(self, warehouseId=None, providerId=None, cod=None, orderIds=None,):
3064 chandransh 13151 
    self.warehouseId = warehouseId
1408 ankur.sing 13152 
    self.providerId = providerId
3064 chandransh 13153 
    self.cod = cod
4910 phani.kuma 13154 
    self.orderIds = orderIds
1408 ankur.sing 13155 
 
13156 
  def read(self, iprot):
13157 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13158 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13159 
      return
13160 
    iprot.readStructBegin()
13161 
    while True:
13162 
      (fname, ftype, fid) = iprot.readFieldBegin()
13163 
      if ftype == TType.STOP:
13164 
        break
13165 
      if fid == 1:
13166 
        if ftype == TType.I64:
3064 chandransh 13167 
          self.warehouseId = iprot.readI64();
1408 ankur.sing 13168 
        else:
13169 
          iprot.skip(ftype)
13170 
      elif fid == 2:
13171 
        if ftype == TType.I64:
3064 chandransh 13172 
          self.providerId = iprot.readI64();
1408 ankur.sing 13173 
        else:
13174 
          iprot.skip(ftype)
3064 chandransh 13175 
      elif fid == 3:
13176 
        if ftype == TType.BOOL:
13177 
          self.cod = iprot.readBool();
13178 
        else:
13179 
          iprot.skip(ftype)
4910 phani.kuma 13180 
      elif fid == 4:
13181 
        if ftype == TType.LIST:
13182 
          self.orderIds = []
6000 mandeep.dh 13183 
          (_etype248, _size245) = iprot.readListBegin()
13184 
          for _i249 in xrange(_size245):
13185 
            _elem250 = iprot.readI64();
13186 
            self.orderIds.append(_elem250)
4910 phani.kuma 13187 
          iprot.readListEnd()
13188 
        else:
13189 
          iprot.skip(ftype)
1408 ankur.sing 13190 
      else:
13191 
        iprot.skip(ftype)
13192 
      iprot.readFieldEnd()
13193 
    iprot.readStructEnd()
13194 
 
13195 
  def write(self, oprot):
13196 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13197 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13198 
      return
4910 phani.kuma 13199 
    oprot.writeStructBegin('markOrdersAsShippedFromWarehouse_args')
3431 rajveer 13200 
    if self.warehouseId is not None:
3064 chandransh 13201 
      oprot.writeFieldBegin('warehouseId', TType.I64, 1)
13202 
      oprot.writeI64(self.warehouseId)
13203 
      oprot.writeFieldEnd()
3431 rajveer 13204 
    if self.providerId is not None:
3064 chandransh 13205 
      oprot.writeFieldBegin('providerId', TType.I64, 2)
1408 ankur.sing 13206 
      oprot.writeI64(self.providerId)
13207 
      oprot.writeFieldEnd()
3431 rajveer 13208 
    if self.cod is not None:
3064 chandransh 13209 
      oprot.writeFieldBegin('cod', TType.BOOL, 3)
13210 
      oprot.writeBool(self.cod)
1408 ankur.sing 13211 
      oprot.writeFieldEnd()
4910 phani.kuma 13212 
    if self.orderIds is not None:
13213 
      oprot.writeFieldBegin('orderIds', TType.LIST, 4)
13214 
      oprot.writeListBegin(TType.I64, len(self.orderIds))
6000 mandeep.dh 13215 
      for iter251 in self.orderIds:
13216 
        oprot.writeI64(iter251)
4910 phani.kuma 13217 
      oprot.writeListEnd()
13218 
      oprot.writeFieldEnd()
1408 ankur.sing 13219 
    oprot.writeFieldStop()
13220 
    oprot.writeStructEnd()
13221 
 
3431 rajveer 13222 
  def validate(self):
13223 
    return
13224 
 
13225 
 
1408 ankur.sing 13226 
  def __repr__(self):
13227 
    L = ['%s=%r' % (key, value)
13228 
      for key, value in self.__dict__.iteritems()]
13229 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13230 
 
13231 
  def __eq__(self, other):
13232 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13233 
 
13234 
  def __ne__(self, other):
13235 
    return not (self == other)
13236 
 
4910 phani.kuma 13237 
class markOrdersAsShippedFromWarehouse_result:
1408 ankur.sing 13238 
  """
13239 
  Attributes:
13240 
   - success
3064 chandransh 13241 
   - ex
1408 ankur.sing 13242 
  """
13243 
 
13244 
  thrift_spec = (
3064 chandransh 13245 
    (0, TType.BOOL, 'success', None, None, ), # 0
13246 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
1408 ankur.sing 13247 
  )
13248 
 
3064 chandransh 13249 
  def __init__(self, success=None, ex=None,):
1408 ankur.sing 13250 
    self.success = success
3064 chandransh 13251 
    self.ex = ex
1408 ankur.sing 13252 
 
13253 
  def read(self, iprot):
13254 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13255 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13256 
      return
13257 
    iprot.readStructBegin()
13258 
    while True:
13259 
      (fname, ftype, fid) = iprot.readFieldBegin()
13260 
      if ftype == TType.STOP:
13261 
        break
13262 
      if fid == 0:
3064 chandransh 13263 
        if ftype == TType.BOOL:
13264 
          self.success = iprot.readBool();
1408 ankur.sing 13265 
        else:
13266 
          iprot.skip(ftype)
3064 chandransh 13267 
      elif fid == 1:
13268 
        if ftype == TType.STRUCT:
13269 
          self.ex = TransactionServiceException()
13270 
          self.ex.read(iprot)
13271 
        else:
13272 
          iprot.skip(ftype)
1408 ankur.sing 13273 
      else:
13274 
        iprot.skip(ftype)
13275 
      iprot.readFieldEnd()
13276 
    iprot.readStructEnd()
13277 
 
13278 
  def write(self, oprot):
13279 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13280 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13281 
      return
4910 phani.kuma 13282 
    oprot.writeStructBegin('markOrdersAsShippedFromWarehouse_result')
3431 rajveer 13283 
    if self.success is not None:
3064 chandransh 13284 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
13285 
      oprot.writeBool(self.success)
1408 ankur.sing 13286 
      oprot.writeFieldEnd()
3431 rajveer 13287 
    if self.ex is not None:
3064 chandransh 13288 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
13289 
      self.ex.write(oprot)
13290 
      oprot.writeFieldEnd()
1408 ankur.sing 13291 
    oprot.writeFieldStop()
13292 
    oprot.writeStructEnd()
13293 
 
3431 rajveer 13294 
  def validate(self):
13295 
    return
13296 
 
13297 
 
1408 ankur.sing 13298 
  def __repr__(self):
13299 
    L = ['%s=%r' % (key, value)
13300 
      for key, value in self.__dict__.iteritems()]
13301 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13302 
 
13303 
  def __eq__(self, other):
13304 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13305 
 
13306 
  def __ne__(self, other):
13307 
    return not (self == other)
13308 
 
5676 rajveer 13309 
class markOrdersAsReturnedFromStore_args:
13310 
  """
13311 
  Attributes:
13312 
   - providerId
13313 
   - orderIds
5713 rajveer 13314 
   - awbs
5676 rajveer 13315 
  """
13316 
 
13317 
  thrift_spec = (
13318 
    None, # 0
13319 
    (1, TType.I64, 'providerId', None, None, ), # 1
13320 
    (2, TType.LIST, 'orderIds', (TType.I64,None), None, ), # 2
5713 rajveer 13321 
    (3, TType.LIST, 'awbs', (TType.STRING,None), None, ), # 3
5676 rajveer 13322 
  )
13323 
 
5713 rajveer 13324 
  def __init__(self, providerId=None, orderIds=None, awbs=None,):
5676 rajveer 13325 
    self.providerId = providerId
13326 
    self.orderIds = orderIds
5713 rajveer 13327 
    self.awbs = awbs
5676 rajveer 13328 
 
13329 
  def read(self, iprot):
13330 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13331 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13332 
      return
13333 
    iprot.readStructBegin()
13334 
    while True:
13335 
      (fname, ftype, fid) = iprot.readFieldBegin()
13336 
      if ftype == TType.STOP:
13337 
        break
13338 
      if fid == 1:
13339 
        if ftype == TType.I64:
13340 
          self.providerId = iprot.readI64();
13341 
        else:
13342 
          iprot.skip(ftype)
13343 
      elif fid == 2:
13344 
        if ftype == TType.LIST:
13345 
          self.orderIds = []
6000 mandeep.dh 13346 
          (_etype255, _size252) = iprot.readListBegin()
13347 
          for _i256 in xrange(_size252):
13348 
            _elem257 = iprot.readI64();
13349 
            self.orderIds.append(_elem257)
5676 rajveer 13350 
          iprot.readListEnd()
13351 
        else:
13352 
          iprot.skip(ftype)
5713 rajveer 13353 
      elif fid == 3:
13354 
        if ftype == TType.LIST:
13355 
          self.awbs = []
6000 mandeep.dh 13356 
          (_etype261, _size258) = iprot.readListBegin()
13357 
          for _i262 in xrange(_size258):
13358 
            _elem263 = iprot.readString();
13359 
            self.awbs.append(_elem263)
5713 rajveer 13360 
          iprot.readListEnd()
13361 
        else:
13362 
          iprot.skip(ftype)
5676 rajveer 13363 
      else:
13364 
        iprot.skip(ftype)
13365 
      iprot.readFieldEnd()
13366 
    iprot.readStructEnd()
13367 
 
13368 
  def write(self, oprot):
13369 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13370 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13371 
      return
13372 
    oprot.writeStructBegin('markOrdersAsReturnedFromStore_args')
13373 
    if self.providerId is not None:
13374 
      oprot.writeFieldBegin('providerId', TType.I64, 1)
13375 
      oprot.writeI64(self.providerId)
13376 
      oprot.writeFieldEnd()
13377 
    if self.orderIds is not None:
13378 
      oprot.writeFieldBegin('orderIds', TType.LIST, 2)
13379 
      oprot.writeListBegin(TType.I64, len(self.orderIds))
6000 mandeep.dh 13380 
      for iter264 in self.orderIds:
13381 
        oprot.writeI64(iter264)
5676 rajveer 13382 
      oprot.writeListEnd()
13383 
      oprot.writeFieldEnd()
5713 rajveer 13384 
    if self.awbs is not None:
13385 
      oprot.writeFieldBegin('awbs', TType.LIST, 3)
13386 
      oprot.writeListBegin(TType.STRING, len(self.awbs))
6000 mandeep.dh 13387 
      for iter265 in self.awbs:
13388 
        oprot.writeString(iter265)
5713 rajveer 13389 
      oprot.writeListEnd()
13390 
      oprot.writeFieldEnd()
5676 rajveer 13391 
    oprot.writeFieldStop()
13392 
    oprot.writeStructEnd()
13393 
 
13394 
  def validate(self):
13395 
    return
13396 
 
13397 
 
13398 
  def __repr__(self):
13399 
    L = ['%s=%r' % (key, value)
13400 
      for key, value in self.__dict__.iteritems()]
13401 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13402 
 
13403 
  def __eq__(self, other):
13404 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13405 
 
13406 
  def __ne__(self, other):
13407 
    return not (self == other)
13408 
 
13409 
class markOrdersAsReturnedFromStore_result:
13410 
  """
13411 
  Attributes:
13412 
   - success
13413 
   - ex
13414 
  """
13415 
 
13416 
  thrift_spec = (
13417 
    (0, TType.BOOL, 'success', None, None, ), # 0
13418 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
13419 
  )
13420 
 
13421 
  def __init__(self, success=None, ex=None,):
13422 
    self.success = success
13423 
    self.ex = ex
13424 
 
13425 
  def read(self, iprot):
13426 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13427 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13428 
      return
13429 
    iprot.readStructBegin()
13430 
    while True:
13431 
      (fname, ftype, fid) = iprot.readFieldBegin()
13432 
      if ftype == TType.STOP:
13433 
        break
13434 
      if fid == 0:
13435 
        if ftype == TType.BOOL:
13436 
          self.success = iprot.readBool();
13437 
        else:
13438 
          iprot.skip(ftype)
13439 
      elif fid == 1:
13440 
        if ftype == TType.STRUCT:
13441 
          self.ex = TransactionServiceException()
13442 
          self.ex.read(iprot)
13443 
        else:
13444 
          iprot.skip(ftype)
13445 
      else:
13446 
        iprot.skip(ftype)
13447 
      iprot.readFieldEnd()
13448 
    iprot.readStructEnd()
13449 
 
13450 
  def write(self, oprot):
13451 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13452 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13453 
      return
13454 
    oprot.writeStructBegin('markOrdersAsReturnedFromStore_result')
13455 
    if self.success is not None:
13456 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
13457 
      oprot.writeBool(self.success)
13458 
      oprot.writeFieldEnd()
13459 
    if self.ex is not None:
13460 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
13461 
      self.ex.write(oprot)
13462 
      oprot.writeFieldEnd()
13463 
    oprot.writeFieldStop()
13464 
    oprot.writeStructEnd()
13465 
 
13466 
  def validate(self):
13467 
    return
13468 
 
13469 
 
13470 
  def __repr__(self):
13471 
    L = ['%s=%r' % (key, value)
13472 
      for key, value in self.__dict__.iteritems()]
13473 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13474 
 
13475 
  def __eq__(self, other):
13476 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13477 
 
13478 
  def __ne__(self, other):
13479 
    return not (self == other)
13480 
 
4910 phani.kuma 13481 
class markOrdersAsPickedUp_args:
4410 rajveer 13482 
  """
13483 
  Attributes:
13484 
   - providerId
4910 phani.kuma 13485 
   - pickupDetails
4410 rajveer 13486 
  """
13487 
 
13488 
  thrift_spec = (
13489 
    None, # 0
4910 phani.kuma 13490 
    (1, TType.I64, 'providerId', None, None, ), # 1
13491 
    (2, TType.MAP, 'pickupDetails', (TType.STRING,None,TType.STRING,None), None, ), # 2
4410 rajveer 13492 
  )
13493 
 
4910 phani.kuma 13494 
  def __init__(self, providerId=None, pickupDetails=None,):
4410 rajveer 13495 
    self.providerId = providerId
4910 phani.kuma 13496 
    self.pickupDetails = pickupDetails
4410 rajveer 13497 
 
13498 
  def read(self, iprot):
13499 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13500 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13501 
      return
13502 
    iprot.readStructBegin()
13503 
    while True:
13504 
      (fname, ftype, fid) = iprot.readFieldBegin()
13505 
      if ftype == TType.STOP:
13506 
        break
13507 
      if fid == 1:
13508 
        if ftype == TType.I64:
4910 phani.kuma 13509 
          self.providerId = iprot.readI64();
4410 rajveer 13510 
        else:
13511 
          iprot.skip(ftype)
13512 
      elif fid == 2:
4910 phani.kuma 13513 
        if ftype == TType.MAP:
13514 
          self.pickupDetails = {}
6000 mandeep.dh 13515 
          (_ktype267, _vtype268, _size266 ) = iprot.readMapBegin()
13516 
          for _i270 in xrange(_size266):
13517 
            _key271 = iprot.readString();
13518 
            _val272 = iprot.readString();
13519 
            self.pickupDetails[_key271] = _val272
4910 phani.kuma 13520 
          iprot.readMapEnd()
4410 rajveer 13521 
        else:
13522 
          iprot.skip(ftype)
13523 
      else:
13524 
        iprot.skip(ftype)
13525 
      iprot.readFieldEnd()
13526 
    iprot.readStructEnd()
13527 
 
13528 
  def write(self, oprot):
13529 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13530 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13531 
      return
4910 phani.kuma 13532 
    oprot.writeStructBegin('markOrdersAsPickedUp_args')
4410 rajveer 13533 
    if self.providerId is not None:
4910 phani.kuma 13534 
      oprot.writeFieldBegin('providerId', TType.I64, 1)
4410 rajveer 13535 
      oprot.writeI64(self.providerId)
13536 
      oprot.writeFieldEnd()
4910 phani.kuma 13537 
    if self.pickupDetails is not None:
13538 
      oprot.writeFieldBegin('pickupDetails', TType.MAP, 2)
13539 
      oprot.writeMapBegin(TType.STRING, TType.STRING, len(self.pickupDetails))
6000 mandeep.dh 13540 
      for kiter273,viter274 in self.pickupDetails.items():
13541 
        oprot.writeString(kiter273)
13542 
        oprot.writeString(viter274)
4910 phani.kuma 13543 
      oprot.writeMapEnd()
4410 rajveer 13544 
      oprot.writeFieldEnd()
13545 
    oprot.writeFieldStop()
13546 
    oprot.writeStructEnd()
13547 
 
13548 
  def validate(self):
13549 
    return
13550 
 
13551 
 
13552 
  def __repr__(self):
13553 
    L = ['%s=%r' % (key, value)
13554 
      for key, value in self.__dict__.iteritems()]
13555 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13556 
 
13557 
  def __eq__(self, other):
13558 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13559 
 
13560 
  def __ne__(self, other):
13561 
    return not (self == other)
13562 
 
4910 phani.kuma 13563 
class markOrdersAsPickedUp_result:
4410 rajveer 13564 
  """
13565 
  Attributes:
13566 
   - ex
13567 
  """
13568 
 
13569 
  thrift_spec = (
4910 phani.kuma 13570 
    None, # 0
4410 rajveer 13571 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
13572 
  )
13573 
 
4910 phani.kuma 13574 
  def __init__(self, ex=None,):
4410 rajveer 13575 
    self.ex = ex
13576 
 
13577 
  def read(self, iprot):
13578 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13579 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13580 
      return
13581 
    iprot.readStructBegin()
13582 
    while True:
13583 
      (fname, ftype, fid) = iprot.readFieldBegin()
13584 
      if ftype == TType.STOP:
13585 
        break
4910 phani.kuma 13586 
      if fid == 1:
4410 rajveer 13587 
        if ftype == TType.STRUCT:
13588 
          self.ex = TransactionServiceException()
13589 
          self.ex.read(iprot)
13590 
        else:
13591 
          iprot.skip(ftype)
13592 
      else:
13593 
        iprot.skip(ftype)
13594 
      iprot.readFieldEnd()
13595 
    iprot.readStructEnd()
13596 
 
13597 
  def write(self, oprot):
13598 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13599 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13600 
      return
4910 phani.kuma 13601 
    oprot.writeStructBegin('markOrdersAsPickedUp_result')
4410 rajveer 13602 
    if self.ex is not None:
13603 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
13604 
      self.ex.write(oprot)
13605 
      oprot.writeFieldEnd()
13606 
    oprot.writeFieldStop()
13607 
    oprot.writeStructEnd()
13608 
 
13609 
  def validate(self):
13610 
    return
13611 
 
13612 
 
13613 
  def __repr__(self):
13614 
    L = ['%s=%r' % (key, value)
13615 
      for key, value in self.__dict__.iteritems()]
13616 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13617 
 
13618 
  def __eq__(self, other):
13619 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13620 
 
13621 
  def __ne__(self, other):
13622 
    return not (self == other)
13623 
 
4910 phani.kuma 13624 
class getOrdersNotPickedUp_args:
304 ashish 13625 
  """
13626 
  Attributes:
3064 chandransh 13627 
   - providerId
304 ashish 13628 
  """
94 ashish 13629 
 
304 ashish 13630 
  thrift_spec = (
13631 
    None, # 0
3064 chandransh 13632 
    (1, TType.I64, 'providerId', None, None, ), # 1
304 ashish 13633 
  )
13634 
 
4910 phani.kuma 13635 
  def __init__(self, providerId=None,):
3064 chandransh 13636 
    self.providerId = providerId
304 ashish 13637 
 
13638 
  def read(self, iprot):
13639 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13640 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13641 
      return
13642 
    iprot.readStructBegin()
13643 
    while True:
13644 
      (fname, ftype, fid) = iprot.readFieldBegin()
13645 
      if ftype == TType.STOP:
13646 
        break
13647 
      if fid == 1:
13648 
        if ftype == TType.I64:
3064 chandransh 13649 
          self.providerId = iprot.readI64();
304 ashish 13650 
        else:
13651 
          iprot.skip(ftype)
13652 
      else:
13653 
        iprot.skip(ftype)
13654 
      iprot.readFieldEnd()
13655 
    iprot.readStructEnd()
13656 
 
13657 
  def write(self, oprot):
13658 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13659 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13660 
      return
4910 phani.kuma 13661 
    oprot.writeStructBegin('getOrdersNotPickedUp_args')
3431 rajveer 13662 
    if self.providerId is not None:
3064 chandransh 13663 
      oprot.writeFieldBegin('providerId', TType.I64, 1)
13664 
      oprot.writeI64(self.providerId)
304 ashish 13665 
      oprot.writeFieldEnd()
13666 
    oprot.writeFieldStop()
13667 
    oprot.writeStructEnd()
13668 
 
3431 rajveer 13669 
  def validate(self):
13670 
    return
13671 
 
13672 
 
304 ashish 13673 
  def __repr__(self):
13674 
    L = ['%s=%r' % (key, value)
13675 
      for key, value in self.__dict__.iteritems()]
13676 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13677 
 
13678 
  def __eq__(self, other):
13679 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13680 
 
13681 
  def __ne__(self, other):
13682 
    return not (self == other)
13683 
 
4910 phani.kuma 13684 
class getOrdersNotPickedUp_result:
304 ashish 13685 
  """
13686 
  Attributes:
13687 
   - success
13688 
  """
13689 
 
13690 
  thrift_spec = (
3064 chandransh 13691 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
304 ashish 13692 
  )
13693 
 
4910 phani.kuma 13694 
  def __init__(self, success=None,):
304 ashish 13695 
    self.success = success
13696 
 
13697 
  def read(self, iprot):
13698 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13699 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13700 
      return
13701 
    iprot.readStructBegin()
13702 
    while True:
13703 
      (fname, ftype, fid) = iprot.readFieldBegin()
13704 
      if ftype == TType.STOP:
13705 
        break
13706 
      if fid == 0:
13707 
        if ftype == TType.LIST:
13708 
          self.success = []
6000 mandeep.dh 13709 
          (_etype278, _size275) = iprot.readListBegin()
13710 
          for _i279 in xrange(_size275):
13711 
            _elem280 = Order()
13712 
            _elem280.read(iprot)
13713 
            self.success.append(_elem280)
304 ashish 13714 
          iprot.readListEnd()
13715 
        else:
13716 
          iprot.skip(ftype)
13717 
      else:
13718 
        iprot.skip(ftype)
13719 
      iprot.readFieldEnd()
13720 
    iprot.readStructEnd()
13721 
 
13722 
  def write(self, oprot):
13723 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13724 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13725 
      return
4910 phani.kuma 13726 
    oprot.writeStructBegin('getOrdersNotPickedUp_result')
3431 rajveer 13727 
    if self.success is not None:
304 ashish 13728 
      oprot.writeFieldBegin('success', TType.LIST, 0)
13729 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
6000 mandeep.dh 13730 
      for iter281 in self.success:
13731 
        iter281.write(oprot)
304 ashish 13732 
      oprot.writeListEnd()
13733 
      oprot.writeFieldEnd()
13734 
    oprot.writeFieldStop()
13735 
    oprot.writeStructEnd()
13736 
 
3431 rajveer 13737 
  def validate(self):
13738 
    return
13739 
 
13740 
 
304 ashish 13741 
  def __repr__(self):
13742 
    L = ['%s=%r' % (key, value)
13743 
      for key, value in self.__dict__.iteritems()]
13744 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13745 
 
13746 
  def __eq__(self, other):
13747 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13748 
 
13749 
  def __ne__(self, other):
13750 
    return not (self == other)
13751 
 
3064 chandransh 13752 
class markOrdersAsDelivered_args:
304 ashish 13753 
  """
13754 
  Attributes:
3064 chandransh 13755 
   - providerId
13756 
   - deliveredOrders
304 ashish 13757 
  """
13758 
 
13759 
  thrift_spec = (
13760 
    None, # 0
3064 chandransh 13761 
    (1, TType.I64, 'providerId', None, None, ), # 1
13762 
    (2, TType.MAP, 'deliveredOrders', (TType.STRING,None,TType.STRING,None), None, ), # 2
304 ashish 13763 
  )
13764 
 
3064 chandransh 13765 
  def __init__(self, providerId=None, deliveredOrders=None,):
13766 
    self.providerId = providerId
13767 
    self.deliveredOrders = deliveredOrders
304 ashish 13768 
 
13769 
  def read(self, iprot):
13770 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13771 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13772 
      return
13773 
    iprot.readStructBegin()
13774 
    while True:
13775 
      (fname, ftype, fid) = iprot.readFieldBegin()
13776 
      if ftype == TType.STOP:
13777 
        break
13778 
      if fid == 1:
13779 
        if ftype == TType.I64:
3064 chandransh 13780 
          self.providerId = iprot.readI64();
304 ashish 13781 
        else:
13782 
          iprot.skip(ftype)
13783 
      elif fid == 2:
3064 chandransh 13784 
        if ftype == TType.MAP:
13785 
          self.deliveredOrders = {}
6000 mandeep.dh 13786 
          (_ktype283, _vtype284, _size282 ) = iprot.readMapBegin()
13787 
          for _i286 in xrange(_size282):
13788 
            _key287 = iprot.readString();
13789 
            _val288 = iprot.readString();
13790 
            self.deliveredOrders[_key287] = _val288
3064 chandransh 13791 
          iprot.readMapEnd()
304 ashish 13792 
        else:
13793 
          iprot.skip(ftype)
13794 
      else:
13795 
        iprot.skip(ftype)
13796 
      iprot.readFieldEnd()
13797 
    iprot.readStructEnd()
13798 
 
13799 
  def write(self, oprot):
13800 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13801 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13802 
      return
3064 chandransh 13803 
    oprot.writeStructBegin('markOrdersAsDelivered_args')
3431 rajveer 13804 
    if self.providerId is not None:
3064 chandransh 13805 
      oprot.writeFieldBegin('providerId', TType.I64, 1)
13806 
      oprot.writeI64(self.providerId)
304 ashish 13807 
      oprot.writeFieldEnd()
3431 rajveer 13808 
    if self.deliveredOrders is not None:
3064 chandransh 13809 
      oprot.writeFieldBegin('deliveredOrders', TType.MAP, 2)
13810 
      oprot.writeMapBegin(TType.STRING, TType.STRING, len(self.deliveredOrders))
6000 mandeep.dh 13811 
      for kiter289,viter290 in self.deliveredOrders.items():
13812 
        oprot.writeString(kiter289)
13813 
        oprot.writeString(viter290)
3064 chandransh 13814 
      oprot.writeMapEnd()
304 ashish 13815 
      oprot.writeFieldEnd()
13816 
    oprot.writeFieldStop()
13817 
    oprot.writeStructEnd()
13818 
 
3431 rajveer 13819 
  def validate(self):
13820 
    return
13821 
 
13822 
 
304 ashish 13823 
  def __repr__(self):
13824 
    L = ['%s=%r' % (key, value)
13825 
      for key, value in self.__dict__.iteritems()]
13826 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13827 
 
13828 
  def __eq__(self, other):
13829 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13830 
 
13831 
  def __ne__(self, other):
13832 
    return not (self == other)
13833 
 
3064 chandransh 13834 
class markOrdersAsDelivered_result:
13835 
  """
13836 
  Attributes:
13837 
   - ex
13838 
  """
304 ashish 13839 
 
13840 
  thrift_spec = (
3064 chandransh 13841 
    None, # 0
13842 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
304 ashish 13843 
  )
13844 
 
3064 chandransh 13845 
  def __init__(self, ex=None,):
13846 
    self.ex = ex
304 ashish 13847 
 
1596 ankur.sing 13848 
  def read(self, iprot):
13849 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13850 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13851 
      return
13852 
    iprot.readStructBegin()
13853 
    while True:
13854 
      (fname, ftype, fid) = iprot.readFieldBegin()
13855 
      if ftype == TType.STOP:
13856 
        break
3064 chandransh 13857 
      if fid == 1:
13858 
        if ftype == TType.STRUCT:
13859 
          self.ex = TransactionServiceException()
13860 
          self.ex.read(iprot)
13861 
        else:
13862 
          iprot.skip(ftype)
1596 ankur.sing 13863 
      else:
13864 
        iprot.skip(ftype)
13865 
      iprot.readFieldEnd()
13866 
    iprot.readStructEnd()
13867 
 
13868 
  def write(self, oprot):
13869 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13870 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13871 
      return
3064 chandransh 13872 
    oprot.writeStructBegin('markOrdersAsDelivered_result')
3431 rajveer 13873 
    if self.ex is not None:
3064 chandransh 13874 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
13875 
      self.ex.write(oprot)
13876 
      oprot.writeFieldEnd()
1596 ankur.sing 13877 
    oprot.writeFieldStop()
13878 
    oprot.writeStructEnd()
13879 
 
3431 rajveer 13880 
  def validate(self):
13881 
    return
13882 
 
13883 
 
1596 ankur.sing 13884 
  def __repr__(self):
13885 
    L = ['%s=%r' % (key, value)
13886 
      for key, value in self.__dict__.iteritems()]
13887 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13888 
 
13889 
  def __eq__(self, other):
13890 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13891 
 
13892 
  def __ne__(self, other):
13893 
    return not (self == other)
13894 
 
4910 phani.kuma 13895 
class markAsRTOrders_args:
1596 ankur.sing 13896 
  """
13897 
  Attributes:
3064 chandransh 13898 
   - providerId
13899 
   - returnedOrders
1596 ankur.sing 13900 
  """
13901 
 
13902 
  thrift_spec = (
3064 chandransh 13903 
    None, # 0
13904 
    (1, TType.I64, 'providerId', None, None, ), # 1
13905 
    (2, TType.MAP, 'returnedOrders', (TType.STRING,None,TType.STRING,None), None, ), # 2
1596 ankur.sing 13906 
  )
13907 
 
3064 chandransh 13908 
  def __init__(self, providerId=None, returnedOrders=None,):
13909 
    self.providerId = providerId
13910 
    self.returnedOrders = returnedOrders
1596 ankur.sing 13911 
 
13912 
  def read(self, iprot):
13913 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13914 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13915 
      return
13916 
    iprot.readStructBegin()
13917 
    while True:
13918 
      (fname, ftype, fid) = iprot.readFieldBegin()
13919 
      if ftype == TType.STOP:
13920 
        break
3064 chandransh 13921 
      if fid == 1:
1596 ankur.sing 13922 
        if ftype == TType.I64:
3064 chandransh 13923 
          self.providerId = iprot.readI64();
1596 ankur.sing 13924 
        else:
13925 
          iprot.skip(ftype)
3064 chandransh 13926 
      elif fid == 2:
13927 
        if ftype == TType.MAP:
13928 
          self.returnedOrders = {}
6000 mandeep.dh 13929 
          (_ktype292, _vtype293, _size291 ) = iprot.readMapBegin()
13930 
          for _i295 in xrange(_size291):
13931 
            _key296 = iprot.readString();
13932 
            _val297 = iprot.readString();
13933 
            self.returnedOrders[_key296] = _val297
3064 chandransh 13934 
          iprot.readMapEnd()
13935 
        else:
13936 
          iprot.skip(ftype)
1596 ankur.sing 13937 
      else:
13938 
        iprot.skip(ftype)
13939 
      iprot.readFieldEnd()
13940 
    iprot.readStructEnd()
13941 
 
13942 
  def write(self, oprot):
13943 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13944 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13945 
      return
4910 phani.kuma 13946 
    oprot.writeStructBegin('markAsRTOrders_args')
3431 rajveer 13947 
    if self.providerId is not None:
3064 chandransh 13948 
      oprot.writeFieldBegin('providerId', TType.I64, 1)
13949 
      oprot.writeI64(self.providerId)
1596 ankur.sing 13950 
      oprot.writeFieldEnd()
3431 rajveer 13951 
    if self.returnedOrders is not None:
3064 chandransh 13952 
      oprot.writeFieldBegin('returnedOrders', TType.MAP, 2)
13953 
      oprot.writeMapBegin(TType.STRING, TType.STRING, len(self.returnedOrders))
6000 mandeep.dh 13954 
      for kiter298,viter299 in self.returnedOrders.items():
13955 
        oprot.writeString(kiter298)
13956 
        oprot.writeString(viter299)
3064 chandransh 13957 
      oprot.writeMapEnd()
13958 
      oprot.writeFieldEnd()
1596 ankur.sing 13959 
    oprot.writeFieldStop()
13960 
    oprot.writeStructEnd()
13961 
 
3431 rajveer 13962 
  def validate(self):
13963 
    return
13964 
 
13965 
 
1596 ankur.sing 13966 
  def __repr__(self):
13967 
    L = ['%s=%r' % (key, value)
13968 
      for key, value in self.__dict__.iteritems()]
13969 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13970 
 
13971 
  def __eq__(self, other):
13972 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13973 
 
13974 
  def __ne__(self, other):
13975 
    return not (self == other)
13976 
 
4910 phani.kuma 13977 
class markAsRTOrders_result:
3064 chandransh 13978 
  """
13979 
  Attributes:
13980 
   - ex
13981 
  """
1596 ankur.sing 13982 
 
1627 ankur.sing 13983 
  thrift_spec = (
3064 chandransh 13984 
    None, # 0
13985 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
1627 ankur.sing 13986 
  )
13987 
 
3064 chandransh 13988 
  def __init__(self, ex=None,):
13989 
    self.ex = ex
13990 
 
1627 ankur.sing 13991 
  def read(self, iprot):
13992 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13993 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13994 
      return
13995 
    iprot.readStructBegin()
13996 
    while True:
13997 
      (fname, ftype, fid) = iprot.readFieldBegin()
13998 
      if ftype == TType.STOP:
13999 
        break
3064 chandransh 14000 
      if fid == 1:
14001 
        if ftype == TType.STRUCT:
14002 
          self.ex = TransactionServiceException()
14003 
          self.ex.read(iprot)
14004 
        else:
14005 
          iprot.skip(ftype)
1627 ankur.sing 14006 
      else:
14007 
        iprot.skip(ftype)
14008 
      iprot.readFieldEnd()
14009 
    iprot.readStructEnd()
14010 
 
14011 
  def write(self, oprot):
14012 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14013 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14014 
      return
4910 phani.kuma 14015 
    oprot.writeStructBegin('markAsRTOrders_result')
3431 rajveer 14016 
    if self.ex is not None:
3064 chandransh 14017 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
14018 
      self.ex.write(oprot)
14019 
      oprot.writeFieldEnd()
1627 ankur.sing 14020 
    oprot.writeFieldStop()
14021 
    oprot.writeStructEnd()
14022 
 
3431 rajveer 14023 
  def validate(self):
14024 
    return
14025 
 
14026 
 
1627 ankur.sing 14027 
  def __repr__(self):
14028 
    L = ['%s=%r' % (key, value)
14029 
      for key, value in self.__dict__.iteritems()]
14030 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14031 
 
14032 
  def __eq__(self, other):
14033 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14034 
 
14035 
  def __ne__(self, other):
14036 
    return not (self == other)
14037 
 
4910 phani.kuma 14038 
class getRTOrders_args:
14039 
  """
14040 
  Attributes:
14041 
   - providerId
14042 
  """
14043 
 
14044 
  thrift_spec = (
14045 
    None, # 0
14046 
    (1, TType.I64, 'providerId', None, None, ), # 1
14047 
  )
14048 
 
14049 
  def __init__(self, providerId=None,):
14050 
    self.providerId = providerId
14051 
 
14052 
  def read(self, iprot):
14053 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14054 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14055 
      return
14056 
    iprot.readStructBegin()
14057 
    while True:
14058 
      (fname, ftype, fid) = iprot.readFieldBegin()
14059 
      if ftype == TType.STOP:
14060 
        break
14061 
      if fid == 1:
14062 
        if ftype == TType.I64:
14063 
          self.providerId = iprot.readI64();
14064 
        else:
14065 
          iprot.skip(ftype)
14066 
      else:
14067 
        iprot.skip(ftype)
14068 
      iprot.readFieldEnd()
14069 
    iprot.readStructEnd()
14070 
 
14071 
  def write(self, oprot):
14072 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14073 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14074 
      return
14075 
    oprot.writeStructBegin('getRTOrders_args')
14076 
    if self.providerId is not None:
14077 
      oprot.writeFieldBegin('providerId', TType.I64, 1)
14078 
      oprot.writeI64(self.providerId)
14079 
      oprot.writeFieldEnd()
14080 
    oprot.writeFieldStop()
14081 
    oprot.writeStructEnd()
14082 
 
14083 
  def validate(self):
14084 
    return
14085 
 
14086 
 
14087 
  def __repr__(self):
14088 
    L = ['%s=%r' % (key, value)
14089 
      for key, value in self.__dict__.iteritems()]
14090 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14091 
 
14092 
  def __eq__(self, other):
14093 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14094 
 
14095 
  def __ne__(self, other):
14096 
    return not (self == other)
14097 
 
14098 
class getRTOrders_result:
14099 
  """
14100 
  Attributes:
14101 
   - success
14102 
  """
14103 
 
14104 
  thrift_spec = (
14105 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
14106 
  )
14107 
 
14108 
  def __init__(self, success=None,):
14109 
    self.success = success
14110 
 
14111 
  def read(self, iprot):
14112 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14113 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14114 
      return
14115 
    iprot.readStructBegin()
14116 
    while True:
14117 
      (fname, ftype, fid) = iprot.readFieldBegin()
14118 
      if ftype == TType.STOP:
14119 
        break
14120 
      if fid == 0:
14121 
        if ftype == TType.LIST:
14122 
          self.success = []
6000 mandeep.dh 14123 
          (_etype303, _size300) = iprot.readListBegin()
14124 
          for _i304 in xrange(_size300):
14125 
            _elem305 = Order()
14126 
            _elem305.read(iprot)
14127 
            self.success.append(_elem305)
4910 phani.kuma 14128 
          iprot.readListEnd()
14129 
        else:
14130 
          iprot.skip(ftype)
14131 
      else:
14132 
        iprot.skip(ftype)
14133 
      iprot.readFieldEnd()
14134 
    iprot.readStructEnd()
14135 
 
14136 
  def write(self, oprot):
14137 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14138 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14139 
      return
14140 
    oprot.writeStructBegin('getRTOrders_result')
14141 
    if self.success is not None:
14142 
      oprot.writeFieldBegin('success', TType.LIST, 0)
14143 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
6000 mandeep.dh 14144 
      for iter306 in self.success:
14145 
        iter306.write(oprot)
4910 phani.kuma 14146 
      oprot.writeListEnd()
14147 
      oprot.writeFieldEnd()
14148 
    oprot.writeFieldStop()
14149 
    oprot.writeStructEnd()
14150 
 
14151 
  def validate(self):
14152 
    return
14153 
 
14154 
 
14155 
  def __repr__(self):
14156 
    L = ['%s=%r' % (key, value)
14157 
      for key, value in self.__dict__.iteritems()]
14158 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14159 
 
14160 
  def __eq__(self, other):
14161 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14162 
 
14163 
  def __ne__(self, other):
14164 
    return not (self == other)
14165 
 
3064 chandransh 14166 
class updateNonDeliveryReason_args:
1627 ankur.sing 14167 
  """
14168 
  Attributes:
3064 chandransh 14169 
   - providerId
14170 
   - undeliveredOrders
1627 ankur.sing 14171 
  """
14172 
 
14173 
  thrift_spec = (
3064 chandransh 14174 
    None, # 0
14175 
    (1, TType.I64, 'providerId', None, None, ), # 1
14176 
    (2, TType.MAP, 'undeliveredOrders', (TType.STRING,None,TType.STRING,None), None, ), # 2
1627 ankur.sing 14177 
  )
14178 
 
3064 chandransh 14179 
  def __init__(self, providerId=None, undeliveredOrders=None,):
14180 
    self.providerId = providerId
14181 
    self.undeliveredOrders = undeliveredOrders
1627 ankur.sing 14182 
 
14183 
  def read(self, iprot):
14184 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14185 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14186 
      return
14187 
    iprot.readStructBegin()
14188 
    while True:
14189 
      (fname, ftype, fid) = iprot.readFieldBegin()
14190 
      if ftype == TType.STOP:
14191 
        break
3064 chandransh 14192 
      if fid == 1:
1627 ankur.sing 14193 
        if ftype == TType.I64:
3064 chandransh 14194 
          self.providerId = iprot.readI64();
1627 ankur.sing 14195 
        else:
14196 
          iprot.skip(ftype)
3064 chandransh 14197 
      elif fid == 2:
14198 
        if ftype == TType.MAP:
14199 
          self.undeliveredOrders = {}
6000 mandeep.dh 14200 
          (_ktype308, _vtype309, _size307 ) = iprot.readMapBegin()
14201 
          for _i311 in xrange(_size307):
14202 
            _key312 = iprot.readString();
14203 
            _val313 = iprot.readString();
14204 
            self.undeliveredOrders[_key312] = _val313
3064 chandransh 14205 
          iprot.readMapEnd()
14206 
        else:
14207 
          iprot.skip(ftype)
1627 ankur.sing 14208 
      else:
14209 
        iprot.skip(ftype)
14210 
      iprot.readFieldEnd()
14211 
    iprot.readStructEnd()
14212 
 
14213 
  def write(self, oprot):
14214 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14215 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14216 
      return
3064 chandransh 14217 
    oprot.writeStructBegin('updateNonDeliveryReason_args')
3431 rajveer 14218 
    if self.providerId is not None:
3064 chandransh 14219 
      oprot.writeFieldBegin('providerId', TType.I64, 1)
14220 
      oprot.writeI64(self.providerId)
1627 ankur.sing 14221 
      oprot.writeFieldEnd()
3431 rajveer 14222 
    if self.undeliveredOrders is not None:
3064 chandransh 14223 
      oprot.writeFieldBegin('undeliveredOrders', TType.MAP, 2)
14224 
      oprot.writeMapBegin(TType.STRING, TType.STRING, len(self.undeliveredOrders))
6000 mandeep.dh 14225 
      for kiter314,viter315 in self.undeliveredOrders.items():
14226 
        oprot.writeString(kiter314)
14227 
        oprot.writeString(viter315)
3064 chandransh 14228 
      oprot.writeMapEnd()
14229 
      oprot.writeFieldEnd()
1627 ankur.sing 14230 
    oprot.writeFieldStop()
14231 
    oprot.writeStructEnd()
14232 
 
3431 rajveer 14233 
  def validate(self):
14234 
    return
14235 
 
14236 
 
1627 ankur.sing 14237 
  def __repr__(self):
14238 
    L = ['%s=%r' % (key, value)
14239 
      for key, value in self.__dict__.iteritems()]
14240 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14241 
 
14242 
  def __eq__(self, other):
14243 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14244 
 
14245 
  def __ne__(self, other):
14246 
    return not (self == other)
14247 
 
3064 chandransh 14248 
class updateNonDeliveryReason_result:
1627 ankur.sing 14249 
  """
14250 
  Attributes:
3064 chandransh 14251 
   - ex
1627 ankur.sing 14252 
  """
14253 
 
14254 
  thrift_spec = (
4910 phani.kuma 14255 
    None, # 0
3064 chandransh 14256 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
1627 ankur.sing 14257 
  )
14258 
 
4910 phani.kuma 14259 
  def __init__(self, ex=None,):
3064 chandransh 14260 
    self.ex = ex
1627 ankur.sing 14261 
 
14262 
  def read(self, iprot):
14263 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14264 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14265 
      return
14266 
    iprot.readStructBegin()
14267 
    while True:
14268 
      (fname, ftype, fid) = iprot.readFieldBegin()
14269 
      if ftype == TType.STOP:
14270 
        break
4910 phani.kuma 14271 
      if fid == 1:
14272 
        if ftype == TType.STRUCT:
14273 
          self.ex = TransactionServiceException()
14274 
          self.ex.read(iprot)
14275 
        else:
14276 
          iprot.skip(ftype)
14277 
      else:
14278 
        iprot.skip(ftype)
14279 
      iprot.readFieldEnd()
14280 
    iprot.readStructEnd()
14281 
 
14282 
  def write(self, oprot):
14283 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14284 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14285 
      return
14286 
    oprot.writeStructBegin('updateNonDeliveryReason_result')
14287 
    if self.ex is not None:
14288 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
14289 
      self.ex.write(oprot)
14290 
      oprot.writeFieldEnd()
14291 
    oprot.writeFieldStop()
14292 
    oprot.writeStructEnd()
14293 
 
14294 
  def validate(self):
14295 
    return
14296 
 
14297 
 
14298 
  def __repr__(self):
14299 
    L = ['%s=%r' % (key, value)
14300 
      for key, value in self.__dict__.iteritems()]
14301 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14302 
 
14303 
  def __eq__(self, other):
14304 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14305 
 
14306 
  def __ne__(self, other):
14307 
    return not (self == other)
14308 
 
14309 
class getNonDeliveredOrdersbyCourier_args:
14310 
  """
14311 
  Attributes:
14312 
   - providerId
14313 
  """
14314 
 
14315 
  thrift_spec = (
14316 
    None, # 0
14317 
    (1, TType.I64, 'providerId', None, None, ), # 1
14318 
  )
14319 
 
14320 
  def __init__(self, providerId=None,):
14321 
    self.providerId = providerId
14322 
 
14323 
  def read(self, iprot):
14324 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14325 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14326 
      return
14327 
    iprot.readStructBegin()
14328 
    while True:
14329 
      (fname, ftype, fid) = iprot.readFieldBegin()
14330 
      if ftype == TType.STOP:
14331 
        break
14332 
      if fid == 1:
14333 
        if ftype == TType.I64:
14334 
          self.providerId = iprot.readI64();
14335 
        else:
14336 
          iprot.skip(ftype)
14337 
      else:
14338 
        iprot.skip(ftype)
14339 
      iprot.readFieldEnd()
14340 
    iprot.readStructEnd()
14341 
 
14342 
  def write(self, oprot):
14343 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14344 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14345 
      return
14346 
    oprot.writeStructBegin('getNonDeliveredOrdersbyCourier_args')
14347 
    if self.providerId is not None:
14348 
      oprot.writeFieldBegin('providerId', TType.I64, 1)
14349 
      oprot.writeI64(self.providerId)
14350 
      oprot.writeFieldEnd()
14351 
    oprot.writeFieldStop()
14352 
    oprot.writeStructEnd()
14353 
 
14354 
  def validate(self):
14355 
    return
14356 
 
14357 
 
14358 
  def __repr__(self):
14359 
    L = ['%s=%r' % (key, value)
14360 
      for key, value in self.__dict__.iteritems()]
14361 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14362 
 
14363 
  def __eq__(self, other):
14364 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14365 
 
14366 
  def __ne__(self, other):
14367 
    return not (self == other)
14368 
 
14369 
class getNonDeliveredOrdersbyCourier_result:
14370 
  """
14371 
  Attributes:
14372 
   - success
14373 
  """
14374 
 
14375 
  thrift_spec = (
14376 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
14377 
  )
14378 
 
14379 
  def __init__(self, success=None,):
14380 
    self.success = success
14381 
 
14382 
  def read(self, iprot):
14383 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14384 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14385 
      return
14386 
    iprot.readStructBegin()
14387 
    while True:
14388 
      (fname, ftype, fid) = iprot.readFieldBegin()
14389 
      if ftype == TType.STOP:
14390 
        break
4581 phani.kuma 14391 
      if fid == 0:
14392 
        if ftype == TType.LIST:
14393 
          self.success = []
6000 mandeep.dh 14394 
          (_etype319, _size316) = iprot.readListBegin()
14395 
          for _i320 in xrange(_size316):
14396 
            _elem321 = Order()
14397 
            _elem321.read(iprot)
14398 
            self.success.append(_elem321)
4581 phani.kuma 14399 
          iprot.readListEnd()
14400 
        else:
14401 
          iprot.skip(ftype)
4910 phani.kuma 14402 
      else:
14403 
        iprot.skip(ftype)
14404 
      iprot.readFieldEnd()
14405 
    iprot.readStructEnd()
14406 
 
14407 
  def write(self, oprot):
14408 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14409 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14410 
      return
14411 
    oprot.writeStructBegin('getNonDeliveredOrdersbyCourier_result')
14412 
    if self.success is not None:
14413 
      oprot.writeFieldBegin('success', TType.LIST, 0)
14414 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
6000 mandeep.dh 14415 
      for iter322 in self.success:
14416 
        iter322.write(oprot)
4910 phani.kuma 14417 
      oprot.writeListEnd()
14418 
      oprot.writeFieldEnd()
14419 
    oprot.writeFieldStop()
14420 
    oprot.writeStructEnd()
14421 
 
14422 
  def validate(self):
14423 
    return
14424 
 
14425 
 
14426 
  def __repr__(self):
14427 
    L = ['%s=%r' % (key, value)
14428 
      for key, value in self.__dict__.iteritems()]
14429 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14430 
 
14431 
  def __eq__(self, other):
14432 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14433 
 
14434 
  def __ne__(self, other):
14435 
    return not (self == other)
14436 
 
14437 
class markOrdersAsLocalConnected_args:
14438 
  """
14439 
  Attributes:
14440 
   - providerId
14441 
   - local_connected_orders
14442 
  """
14443 
 
14444 
  thrift_spec = (
14445 
    None, # 0
14446 
    (1, TType.I64, 'providerId', None, None, ), # 1
14447 
    (2, TType.MAP, 'local_connected_orders', (TType.STRING,None,TType.STRING,None), None, ), # 2
14448 
  )
14449 
 
14450 
  def __init__(self, providerId=None, local_connected_orders=None,):
14451 
    self.providerId = providerId
14452 
    self.local_connected_orders = local_connected_orders
14453 
 
14454 
  def read(self, iprot):
14455 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14456 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14457 
      return
14458 
    iprot.readStructBegin()
14459 
    while True:
14460 
      (fname, ftype, fid) = iprot.readFieldBegin()
14461 
      if ftype == TType.STOP:
14462 
        break
14463 
      if fid == 1:
14464 
        if ftype == TType.I64:
14465 
          self.providerId = iprot.readI64();
14466 
        else:
14467 
          iprot.skip(ftype)
14468 
      elif fid == 2:
14469 
        if ftype == TType.MAP:
14470 
          self.local_connected_orders = {}
6000 mandeep.dh 14471 
          (_ktype324, _vtype325, _size323 ) = iprot.readMapBegin()
14472 
          for _i327 in xrange(_size323):
14473 
            _key328 = iprot.readString();
14474 
            _val329 = iprot.readString();
14475 
            self.local_connected_orders[_key328] = _val329
4910 phani.kuma 14476 
          iprot.readMapEnd()
14477 
        else:
14478 
          iprot.skip(ftype)
14479 
      else:
14480 
        iprot.skip(ftype)
14481 
      iprot.readFieldEnd()
14482 
    iprot.readStructEnd()
14483 
 
14484 
  def write(self, oprot):
14485 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14486 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14487 
      return
14488 
    oprot.writeStructBegin('markOrdersAsLocalConnected_args')
14489 
    if self.providerId is not None:
14490 
      oprot.writeFieldBegin('providerId', TType.I64, 1)
14491 
      oprot.writeI64(self.providerId)
14492 
      oprot.writeFieldEnd()
14493 
    if self.local_connected_orders is not None:
14494 
      oprot.writeFieldBegin('local_connected_orders', TType.MAP, 2)
14495 
      oprot.writeMapBegin(TType.STRING, TType.STRING, len(self.local_connected_orders))
6000 mandeep.dh 14496 
      for kiter330,viter331 in self.local_connected_orders.items():
14497 
        oprot.writeString(kiter330)
14498 
        oprot.writeString(viter331)
4910 phani.kuma 14499 
      oprot.writeMapEnd()
14500 
      oprot.writeFieldEnd()
14501 
    oprot.writeFieldStop()
14502 
    oprot.writeStructEnd()
14503 
 
14504 
  def validate(self):
14505 
    return
14506 
 
14507 
 
14508 
  def __repr__(self):
14509 
    L = ['%s=%r' % (key, value)
14510 
      for key, value in self.__dict__.iteritems()]
14511 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14512 
 
14513 
  def __eq__(self, other):
14514 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14515 
 
14516 
  def __ne__(self, other):
14517 
    return not (self == other)
14518 
 
14519 
class markOrdersAsLocalConnected_result:
14520 
  """
14521 
  Attributes:
14522 
   - ex
14523 
  """
14524 
 
14525 
  thrift_spec = (
14526 
    None, # 0
14527 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
14528 
  )
14529 
 
14530 
  def __init__(self, ex=None,):
14531 
    self.ex = ex
14532 
 
14533 
  def read(self, iprot):
14534 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14535 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14536 
      return
14537 
    iprot.readStructBegin()
14538 
    while True:
14539 
      (fname, ftype, fid) = iprot.readFieldBegin()
14540 
      if ftype == TType.STOP:
14541 
        break
14542 
      if fid == 1:
3064 chandransh 14543 
        if ftype == TType.STRUCT:
14544 
          self.ex = TransactionServiceException()
14545 
          self.ex.read(iprot)
1627 ankur.sing 14546 
        else:
14547 
          iprot.skip(ftype)
14548 
      else:
14549 
        iprot.skip(ftype)
14550 
      iprot.readFieldEnd()
14551 
    iprot.readStructEnd()
14552 
 
14553 
  def write(self, oprot):
14554 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14555 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14556 
      return
4910 phani.kuma 14557 
    oprot.writeStructBegin('markOrdersAsLocalConnected_result')
14558 
    if self.ex is not None:
14559 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
14560 
      self.ex.write(oprot)
14561 
      oprot.writeFieldEnd()
14562 
    oprot.writeFieldStop()
14563 
    oprot.writeStructEnd()
14564 
 
14565 
  def validate(self):
14566 
    return
14567 
 
14568 
 
14569 
  def __repr__(self):
14570 
    L = ['%s=%r' % (key, value)
14571 
      for key, value in self.__dict__.iteritems()]
14572 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14573 
 
14574 
  def __eq__(self, other):
14575 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14576 
 
14577 
  def __ne__(self, other):
14578 
    return not (self == other)
14579 
 
14580 
class getOrdersNotLocalConnected_args:
14581 
  """
14582 
  Attributes:
14583 
   - providerId
14584 
  """
14585 
 
14586 
  thrift_spec = (
14587 
    None, # 0
14588 
    (1, TType.I64, 'providerId', None, None, ), # 1
14589 
  )
14590 
 
14591 
  def __init__(self, providerId=None,):
14592 
    self.providerId = providerId
14593 
 
14594 
  def read(self, iprot):
14595 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14596 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14597 
      return
14598 
    iprot.readStructBegin()
14599 
    while True:
14600 
      (fname, ftype, fid) = iprot.readFieldBegin()
14601 
      if ftype == TType.STOP:
14602 
        break
14603 
      if fid == 1:
14604 
        if ftype == TType.I64:
14605 
          self.providerId = iprot.readI64();
14606 
        else:
14607 
          iprot.skip(ftype)
14608 
      else:
14609 
        iprot.skip(ftype)
14610 
      iprot.readFieldEnd()
14611 
    iprot.readStructEnd()
14612 
 
14613 
  def write(self, oprot):
14614 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14615 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14616 
      return
14617 
    oprot.writeStructBegin('getOrdersNotLocalConnected_args')
14618 
    if self.providerId is not None:
14619 
      oprot.writeFieldBegin('providerId', TType.I64, 1)
14620 
      oprot.writeI64(self.providerId)
14621 
      oprot.writeFieldEnd()
14622 
    oprot.writeFieldStop()
14623 
    oprot.writeStructEnd()
14624 
 
14625 
  def validate(self):
14626 
    return
14627 
 
14628 
 
14629 
  def __repr__(self):
14630 
    L = ['%s=%r' % (key, value)
14631 
      for key, value in self.__dict__.iteritems()]
14632 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14633 
 
14634 
  def __eq__(self, other):
14635 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14636 
 
14637 
  def __ne__(self, other):
14638 
    return not (self == other)
14639 
 
14640 
class getOrdersNotLocalConnected_result:
14641 
  """
14642 
  Attributes:
14643 
   - success
14644 
  """
14645 
 
14646 
  thrift_spec = (
14647 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
14648 
  )
14649 
 
14650 
  def __init__(self, success=None,):
14651 
    self.success = success
14652 
 
14653 
  def read(self, iprot):
14654 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14655 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14656 
      return
14657 
    iprot.readStructBegin()
14658 
    while True:
14659 
      (fname, ftype, fid) = iprot.readFieldBegin()
14660 
      if ftype == TType.STOP:
14661 
        break
14662 
      if fid == 0:
14663 
        if ftype == TType.LIST:
14664 
          self.success = []
6000 mandeep.dh 14665 
          (_etype335, _size332) = iprot.readListBegin()
14666 
          for _i336 in xrange(_size332):
14667 
            _elem337 = Order()
14668 
            _elem337.read(iprot)
14669 
            self.success.append(_elem337)
4910 phani.kuma 14670 
          iprot.readListEnd()
14671 
        else:
14672 
          iprot.skip(ftype)
14673 
      else:
14674 
        iprot.skip(ftype)
14675 
      iprot.readFieldEnd()
14676 
    iprot.readStructEnd()
14677 
 
14678 
  def write(self, oprot):
14679 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14680 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14681 
      return
14682 
    oprot.writeStructBegin('getOrdersNotLocalConnected_result')
4581 phani.kuma 14683 
    if self.success is not None:
14684 
      oprot.writeFieldBegin('success', TType.LIST, 0)
14685 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
6000 mandeep.dh 14686 
      for iter338 in self.success:
14687 
        iter338.write(oprot)
4581 phani.kuma 14688 
      oprot.writeListEnd()
14689 
      oprot.writeFieldEnd()
4910 phani.kuma 14690 
    oprot.writeFieldStop()
14691 
    oprot.writeStructEnd()
14692 
 
14693 
  def validate(self):
14694 
    return
14695 
 
14696 
 
14697 
  def __repr__(self):
14698 
    L = ['%s=%r' % (key, value)
14699 
      for key, value in self.__dict__.iteritems()]
14700 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14701 
 
14702 
  def __eq__(self, other):
14703 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14704 
 
14705 
  def __ne__(self, other):
14706 
    return not (self == other)
14707 
 
14708 
class markOrdersAsDestinationCityReached_args:
14709 
  """
14710 
  Attributes:
14711 
   - providerId
14712 
   - destination_city_reached_orders
14713 
  """
14714 
 
14715 
  thrift_spec = (
14716 
    None, # 0
14717 
    (1, TType.I64, 'providerId', None, None, ), # 1
14718 
    (2, TType.MAP, 'destination_city_reached_orders', (TType.STRING,None,TType.STRING,None), None, ), # 2
14719 
  )
14720 
 
14721 
  def __init__(self, providerId=None, destination_city_reached_orders=None,):
14722 
    self.providerId = providerId
14723 
    self.destination_city_reached_orders = destination_city_reached_orders
14724 
 
14725 
  def read(self, iprot):
14726 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14727 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14728 
      return
14729 
    iprot.readStructBegin()
14730 
    while True:
14731 
      (fname, ftype, fid) = iprot.readFieldBegin()
14732 
      if ftype == TType.STOP:
14733 
        break
14734 
      if fid == 1:
14735 
        if ftype == TType.I64:
14736 
          self.providerId = iprot.readI64();
14737 
        else:
14738 
          iprot.skip(ftype)
14739 
      elif fid == 2:
14740 
        if ftype == TType.MAP:
14741 
          self.destination_city_reached_orders = {}
6000 mandeep.dh 14742 
          (_ktype340, _vtype341, _size339 ) = iprot.readMapBegin()
14743 
          for _i343 in xrange(_size339):
14744 
            _key344 = iprot.readString();
14745 
            _val345 = iprot.readString();
14746 
            self.destination_city_reached_orders[_key344] = _val345
4910 phani.kuma 14747 
          iprot.readMapEnd()
14748 
        else:
14749 
          iprot.skip(ftype)
14750 
      else:
14751 
        iprot.skip(ftype)
14752 
      iprot.readFieldEnd()
14753 
    iprot.readStructEnd()
14754 
 
14755 
  def write(self, oprot):
14756 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14757 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14758 
      return
14759 
    oprot.writeStructBegin('markOrdersAsDestinationCityReached_args')
14760 
    if self.providerId is not None:
14761 
      oprot.writeFieldBegin('providerId', TType.I64, 1)
14762 
      oprot.writeI64(self.providerId)
14763 
      oprot.writeFieldEnd()
14764 
    if self.destination_city_reached_orders is not None:
14765 
      oprot.writeFieldBegin('destination_city_reached_orders', TType.MAP, 2)
14766 
      oprot.writeMapBegin(TType.STRING, TType.STRING, len(self.destination_city_reached_orders))
6000 mandeep.dh 14767 
      for kiter346,viter347 in self.destination_city_reached_orders.items():
14768 
        oprot.writeString(kiter346)
14769 
        oprot.writeString(viter347)
4910 phani.kuma 14770 
      oprot.writeMapEnd()
14771 
      oprot.writeFieldEnd()
14772 
    oprot.writeFieldStop()
14773 
    oprot.writeStructEnd()
14774 
 
14775 
  def validate(self):
14776 
    return
14777 
 
14778 
 
14779 
  def __repr__(self):
14780 
    L = ['%s=%r' % (key, value)
14781 
      for key, value in self.__dict__.iteritems()]
14782 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14783 
 
14784 
  def __eq__(self, other):
14785 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14786 
 
14787 
  def __ne__(self, other):
14788 
    return not (self == other)
14789 
 
14790 
class markOrdersAsDestinationCityReached_result:
14791 
  """
14792 
  Attributes:
14793 
   - ex
14794 
  """
14795 
 
14796 
  thrift_spec = (
14797 
    None, # 0
14798 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
14799 
  )
14800 
 
14801 
  def __init__(self, ex=None,):
14802 
    self.ex = ex
14803 
 
14804 
  def read(self, iprot):
14805 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14806 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14807 
      return
14808 
    iprot.readStructBegin()
14809 
    while True:
14810 
      (fname, ftype, fid) = iprot.readFieldBegin()
14811 
      if ftype == TType.STOP:
14812 
        break
14813 
      if fid == 1:
14814 
        if ftype == TType.STRUCT:
14815 
          self.ex = TransactionServiceException()
14816 
          self.ex.read(iprot)
14817 
        else:
14818 
          iprot.skip(ftype)
14819 
      else:
14820 
        iprot.skip(ftype)
14821 
      iprot.readFieldEnd()
14822 
    iprot.readStructEnd()
14823 
 
14824 
  def write(self, oprot):
14825 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14826 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14827 
      return
14828 
    oprot.writeStructBegin('markOrdersAsDestinationCityReached_result')
3431 rajveer 14829 
    if self.ex is not None:
3064 chandransh 14830 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
14831 
      self.ex.write(oprot)
1627 ankur.sing 14832 
      oprot.writeFieldEnd()
14833 
    oprot.writeFieldStop()
14834 
    oprot.writeStructEnd()
14835 
 
3431 rajveer 14836 
  def validate(self):
14837 
    return
14838 
 
14839 
 
1627 ankur.sing 14840 
  def __repr__(self):
14841 
    L = ['%s=%r' % (key, value)
14842 
      for key, value in self.__dict__.iteritems()]
14843 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14844 
 
14845 
  def __eq__(self, other):
14846 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14847 
 
14848 
  def __ne__(self, other):
14849 
    return not (self == other)
14850 
 
4910 phani.kuma 14851 
class markOrdersAsFirstDeliveryAttempted_args:
14852 
  """
14853 
  Attributes:
14854 
   - providerId
14855 
   - first_atdl_orders
14856 
  """
14857 
 
14858 
  thrift_spec = (
14859 
    None, # 0
14860 
    (1, TType.I64, 'providerId', None, None, ), # 1
14861 
    (2, TType.MAP, 'first_atdl_orders', (TType.STRING,None,TType.STRING,None), None, ), # 2
14862 
  )
14863 
 
14864 
  def __init__(self, providerId=None, first_atdl_orders=None,):
14865 
    self.providerId = providerId
14866 
    self.first_atdl_orders = first_atdl_orders
14867 
 
14868 
  def read(self, iprot):
14869 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14870 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14871 
      return
14872 
    iprot.readStructBegin()
14873 
    while True:
14874 
      (fname, ftype, fid) = iprot.readFieldBegin()
14875 
      if ftype == TType.STOP:
14876 
        break
14877 
      if fid == 1:
14878 
        if ftype == TType.I64:
14879 
          self.providerId = iprot.readI64();
14880 
        else:
14881 
          iprot.skip(ftype)
14882 
      elif fid == 2:
14883 
        if ftype == TType.MAP:
14884 
          self.first_atdl_orders = {}
6000 mandeep.dh 14885 
          (_ktype349, _vtype350, _size348 ) = iprot.readMapBegin()
14886 
          for _i352 in xrange(_size348):
14887 
            _key353 = iprot.readString();
14888 
            _val354 = iprot.readString();
14889 
            self.first_atdl_orders[_key353] = _val354
4910 phani.kuma 14890 
          iprot.readMapEnd()
14891 
        else:
14892 
          iprot.skip(ftype)
14893 
      else:
14894 
        iprot.skip(ftype)
14895 
      iprot.readFieldEnd()
14896 
    iprot.readStructEnd()
14897 
 
14898 
  def write(self, oprot):
14899 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14900 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14901 
      return
14902 
    oprot.writeStructBegin('markOrdersAsFirstDeliveryAttempted_args')
14903 
    if self.providerId is not None:
14904 
      oprot.writeFieldBegin('providerId', TType.I64, 1)
14905 
      oprot.writeI64(self.providerId)
14906 
      oprot.writeFieldEnd()
14907 
    if self.first_atdl_orders is not None:
14908 
      oprot.writeFieldBegin('first_atdl_orders', TType.MAP, 2)
14909 
      oprot.writeMapBegin(TType.STRING, TType.STRING, len(self.first_atdl_orders))
6000 mandeep.dh 14910 
      for kiter355,viter356 in self.first_atdl_orders.items():
14911 
        oprot.writeString(kiter355)
14912 
        oprot.writeString(viter356)
4910 phani.kuma 14913 
      oprot.writeMapEnd()
14914 
      oprot.writeFieldEnd()
14915 
    oprot.writeFieldStop()
14916 
    oprot.writeStructEnd()
14917 
 
14918 
  def validate(self):
14919 
    return
14920 
 
14921 
 
14922 
  def __repr__(self):
14923 
    L = ['%s=%r' % (key, value)
14924 
      for key, value in self.__dict__.iteritems()]
14925 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14926 
 
14927 
  def __eq__(self, other):
14928 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14929 
 
14930 
  def __ne__(self, other):
14931 
    return not (self == other)
14932 
 
14933 
class markOrdersAsFirstDeliveryAttempted_result:
14934 
  """
14935 
  Attributes:
14936 
   - ex
14937 
  """
14938 
 
14939 
  thrift_spec = (
14940 
    None, # 0
14941 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
14942 
  )
14943 
 
14944 
  def __init__(self, ex=None,):
14945 
    self.ex = ex
14946 
 
14947 
  def read(self, iprot):
14948 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14949 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14950 
      return
14951 
    iprot.readStructBegin()
14952 
    while True:
14953 
      (fname, ftype, fid) = iprot.readFieldBegin()
14954 
      if ftype == TType.STOP:
14955 
        break
14956 
      if fid == 1:
14957 
        if ftype == TType.STRUCT:
14958 
          self.ex = TransactionServiceException()
14959 
          self.ex.read(iprot)
14960 
        else:
14961 
          iprot.skip(ftype)
14962 
      else:
14963 
        iprot.skip(ftype)
14964 
      iprot.readFieldEnd()
14965 
    iprot.readStructEnd()
14966 
 
14967 
  def write(self, oprot):
14968 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14969 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14970 
      return
14971 
    oprot.writeStructBegin('markOrdersAsFirstDeliveryAttempted_result')
14972 
    if self.ex is not None:
14973 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
14974 
      self.ex.write(oprot)
14975 
      oprot.writeFieldEnd()
14976 
    oprot.writeFieldStop()
14977 
    oprot.writeStructEnd()
14978 
 
14979 
  def validate(self):
14980 
    return
14981 
 
14982 
 
14983 
  def __repr__(self):
14984 
    L = ['%s=%r' % (key, value)
14985 
      for key, value in self.__dict__.iteritems()]
14986 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14987 
 
14988 
  def __eq__(self, other):
14989 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14990 
 
14991 
  def __ne__(self, other):
14992 
    return not (self == other)
14993 
 
3064 chandransh 14994 
class getUndeliveredOrders_args:
1886 ankur.sing 14995 
  """
14996 
  Attributes:
3064 chandransh 14997 
   - providerId
14998 
   - warehouseId
1886 ankur.sing 14999 
  """
1627 ankur.sing 15000 
 
1886 ankur.sing 15001 
  thrift_spec = (
15002 
    None, # 0
3064 chandransh 15003 
    (1, TType.I64, 'providerId', None, None, ), # 1
15004 
    (2, TType.I64, 'warehouseId', None, None, ), # 2
1886 ankur.sing 15005 
  )
15006 
 
3064 chandransh 15007 
  def __init__(self, providerId=None, warehouseId=None,):
15008 
    self.providerId = providerId
15009 
    self.warehouseId = warehouseId
1886 ankur.sing 15010 
 
15011 
  def read(self, iprot):
15012 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15013 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15014 
      return
15015 
    iprot.readStructBegin()
15016 
    while True:
15017 
      (fname, ftype, fid) = iprot.readFieldBegin()
15018 
      if ftype == TType.STOP:
15019 
        break
15020 
      if fid == 1:
15021 
        if ftype == TType.I64:
3064 chandransh 15022 
          self.providerId = iprot.readI64();
1886 ankur.sing 15023 
        else:
15024 
          iprot.skip(ftype)
3064 chandransh 15025 
      elif fid == 2:
15026 
        if ftype == TType.I64:
15027 
          self.warehouseId = iprot.readI64();
15028 
        else:
15029 
          iprot.skip(ftype)
1886 ankur.sing 15030 
      else:
15031 
        iprot.skip(ftype)
15032 
      iprot.readFieldEnd()
15033 
    iprot.readStructEnd()
15034 
 
15035 
  def write(self, oprot):
15036 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15037 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15038 
      return
3064 chandransh 15039 
    oprot.writeStructBegin('getUndeliveredOrders_args')
3431 rajveer 15040 
    if self.providerId is not None:
3064 chandransh 15041 
      oprot.writeFieldBegin('providerId', TType.I64, 1)
15042 
      oprot.writeI64(self.providerId)
1886 ankur.sing 15043 
      oprot.writeFieldEnd()
3431 rajveer 15044 
    if self.warehouseId is not None:
3064 chandransh 15045 
      oprot.writeFieldBegin('warehouseId', TType.I64, 2)
15046 
      oprot.writeI64(self.warehouseId)
15047 
      oprot.writeFieldEnd()
1886 ankur.sing 15048 
    oprot.writeFieldStop()
15049 
    oprot.writeStructEnd()
15050 
 
3431 rajveer 15051 
  def validate(self):
15052 
    return
15053 
 
15054 
 
1886 ankur.sing 15055 
  def __repr__(self):
15056 
    L = ['%s=%r' % (key, value)
15057 
      for key, value in self.__dict__.iteritems()]
15058 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15059 
 
15060 
  def __eq__(self, other):
15061 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15062 
 
15063 
  def __ne__(self, other):
15064 
    return not (self == other)
15065 
 
3064 chandransh 15066 
class getUndeliveredOrders_result:
1886 ankur.sing 15067 
  """
15068 
  Attributes:
15069 
   - success
15070 
  """
15071 
 
15072 
  thrift_spec = (
15073 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
15074 
  )
15075 
 
15076 
  def __init__(self, success=None,):
15077 
    self.success = success
15078 
 
15079 
  def read(self, iprot):
15080 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15081 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15082 
      return
15083 
    iprot.readStructBegin()
15084 
    while True:
15085 
      (fname, ftype, fid) = iprot.readFieldBegin()
15086 
      if ftype == TType.STOP:
15087 
        break
15088 
      if fid == 0:
15089 
        if ftype == TType.LIST:
15090 
          self.success = []
6000 mandeep.dh 15091 
          (_etype360, _size357) = iprot.readListBegin()
15092 
          for _i361 in xrange(_size357):
15093 
            _elem362 = Order()
15094 
            _elem362.read(iprot)
15095 
            self.success.append(_elem362)
1886 ankur.sing 15096 
          iprot.readListEnd()
15097 
        else:
15098 
          iprot.skip(ftype)
15099 
      else:
15100 
        iprot.skip(ftype)
15101 
      iprot.readFieldEnd()
15102 
    iprot.readStructEnd()
15103 
 
15104 
  def write(self, oprot):
15105 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15106 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15107 
      return
3064 chandransh 15108 
    oprot.writeStructBegin('getUndeliveredOrders_result')
3431 rajveer 15109 
    if self.success is not None:
1886 ankur.sing 15110 
      oprot.writeFieldBegin('success', TType.LIST, 0)
15111 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
6000 mandeep.dh 15112 
      for iter363 in self.success:
15113 
        iter363.write(oprot)
1886 ankur.sing 15114 
      oprot.writeListEnd()
15115 
      oprot.writeFieldEnd()
15116 
    oprot.writeFieldStop()
15117 
    oprot.writeStructEnd()
15118 
 
3431 rajveer 15119 
  def validate(self):
15120 
    return
15121 
 
15122 
 
1886 ankur.sing 15123 
  def __repr__(self):
15124 
    L = ['%s=%r' % (key, value)
15125 
      for key, value in self.__dict__.iteritems()]
15126 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15127 
 
15128 
  def __eq__(self, other):
15129 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15130 
 
15131 
  def __ne__(self, other):
15132 
    return not (self == other)
15133 
 
4783 phani.kuma 15134 
class getUndeliveredOrdersExpectedDeliveryDateNotMet_args:
15135 
 
15136 
  thrift_spec = (
15137 
  )
15138 
 
15139 
  def read(self, iprot):
15140 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15141 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15142 
      return
15143 
    iprot.readStructBegin()
15144 
    while True:
15145 
      (fname, ftype, fid) = iprot.readFieldBegin()
15146 
      if ftype == TType.STOP:
15147 
        break
15148 
      else:
15149 
        iprot.skip(ftype)
15150 
      iprot.readFieldEnd()
15151 
    iprot.readStructEnd()
15152 
 
15153 
  def write(self, oprot):
15154 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15155 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15156 
      return
15157 
    oprot.writeStructBegin('getUndeliveredOrdersExpectedDeliveryDateNotMet_args')
15158 
    oprot.writeFieldStop()
15159 
    oprot.writeStructEnd()
15160 
 
15161 
  def validate(self):
15162 
    return
15163 
 
15164 
 
15165 
  def __repr__(self):
15166 
    L = ['%s=%r' % (key, value)
15167 
      for key, value in self.__dict__.iteritems()]
15168 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15169 
 
15170 
  def __eq__(self, other):
15171 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15172 
 
15173 
  def __ne__(self, other):
15174 
    return not (self == other)
15175 
 
15176 
class getUndeliveredOrdersExpectedDeliveryDateNotMet_result:
15177 
  """
15178 
  Attributes:
15179 
   - success
15180 
  """
15181 
 
15182 
  thrift_spec = (
15183 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
15184 
  )
15185 
 
15186 
  def __init__(self, success=None,):
15187 
    self.success = success
15188 
 
15189 
  def read(self, iprot):
15190 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15191 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15192 
      return
15193 
    iprot.readStructBegin()
15194 
    while True:
15195 
      (fname, ftype, fid) = iprot.readFieldBegin()
15196 
      if ftype == TType.STOP:
15197 
        break
15198 
      if fid == 0:
15199 
        if ftype == TType.LIST:
15200 
          self.success = []
6000 mandeep.dh 15201 
          (_etype367, _size364) = iprot.readListBegin()
15202 
          for _i368 in xrange(_size364):
15203 
            _elem369 = Order()
15204 
            _elem369.read(iprot)
15205 
            self.success.append(_elem369)
4783 phani.kuma 15206 
          iprot.readListEnd()
15207 
        else:
15208 
          iprot.skip(ftype)
15209 
      else:
15210 
        iprot.skip(ftype)
15211 
      iprot.readFieldEnd()
15212 
    iprot.readStructEnd()
15213 
 
15214 
  def write(self, oprot):
15215 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15216 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15217 
      return
15218 
    oprot.writeStructBegin('getUndeliveredOrdersExpectedDeliveryDateNotMet_result')
15219 
    if self.success is not None:
15220 
      oprot.writeFieldBegin('success', TType.LIST, 0)
15221 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
6000 mandeep.dh 15222 
      for iter370 in self.success:
15223 
        iter370.write(oprot)
4783 phani.kuma 15224 
      oprot.writeListEnd()
15225 
      oprot.writeFieldEnd()
15226 
    oprot.writeFieldStop()
15227 
    oprot.writeStructEnd()
15228 
 
15229 
  def validate(self):
15230 
    return
15231 
 
15232 
 
15233 
  def __repr__(self):
15234 
    L = ['%s=%r' % (key, value)
15235 
      for key, value in self.__dict__.iteritems()]
15236 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15237 
 
15238 
  def __eq__(self, other):
15239 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15240 
 
15241 
  def __ne__(self, other):
15242 
    return not (self == other)
15243 
 
2536 chandransh 15244 
class toggleDOAFlag_args:
15245 
  """
15246 
  Attributes:
15247 
   - orderId
15248 
  """
1886 ankur.sing 15249 
 
2536 chandransh 15250 
  thrift_spec = (
15251 
    None, # 0
15252 
    (1, TType.I64, 'orderId', None, None, ), # 1
15253 
  )
15254 
 
15255 
  def __init__(self, orderId=None,):
15256 
    self.orderId = orderId
15257 
 
15258 
  def read(self, iprot):
15259 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15260 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15261 
      return
15262 
    iprot.readStructBegin()
15263 
    while True:
15264 
      (fname, ftype, fid) = iprot.readFieldBegin()
15265 
      if ftype == TType.STOP:
15266 
        break
15267 
      if fid == 1:
15268 
        if ftype == TType.I64:
15269 
          self.orderId = iprot.readI64();
15270 
        else:
15271 
          iprot.skip(ftype)
15272 
      else:
15273 
        iprot.skip(ftype)
15274 
      iprot.readFieldEnd()
15275 
    iprot.readStructEnd()
15276 
 
15277 
  def write(self, oprot):
15278 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15279 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15280 
      return
15281 
    oprot.writeStructBegin('toggleDOAFlag_args')
3431 rajveer 15282 
    if self.orderId is not None:
2536 chandransh 15283 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
15284 
      oprot.writeI64(self.orderId)
15285 
      oprot.writeFieldEnd()
15286 
    oprot.writeFieldStop()
15287 
    oprot.writeStructEnd()
15288 
 
3431 rajveer 15289 
  def validate(self):
15290 
    return
15291 
 
15292 
 
2536 chandransh 15293 
  def __repr__(self):
15294 
    L = ['%s=%r' % (key, value)
15295 
      for key, value in self.__dict__.iteritems()]
15296 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15297 
 
15298 
  def __eq__(self, other):
15299 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15300 
 
15301 
  def __ne__(self, other):
15302 
    return not (self == other)
15303 
 
15304 
class toggleDOAFlag_result:
15305 
  """
15306 
  Attributes:
15307 
   - success
15308 
   - ex
15309 
  """
15310 
 
15311 
  thrift_spec = (
15312 
    (0, TType.BOOL, 'success', None, None, ), # 0
15313 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
15314 
  )
15315 
 
15316 
  def __init__(self, success=None, ex=None,):
15317 
    self.success = success
15318 
    self.ex = ex
15319 
 
15320 
  def read(self, iprot):
15321 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15322 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15323 
      return
15324 
    iprot.readStructBegin()
15325 
    while True:
15326 
      (fname, ftype, fid) = iprot.readFieldBegin()
15327 
      if ftype == TType.STOP:
15328 
        break
15329 
      if fid == 0:
15330 
        if ftype == TType.BOOL:
15331 
          self.success = iprot.readBool();
15332 
        else:
15333 
          iprot.skip(ftype)
15334 
      elif fid == 1:
15335 
        if ftype == TType.STRUCT:
15336 
          self.ex = TransactionServiceException()
15337 
          self.ex.read(iprot)
15338 
        else:
15339 
          iprot.skip(ftype)
15340 
      else:
15341 
        iprot.skip(ftype)
15342 
      iprot.readFieldEnd()
15343 
    iprot.readStructEnd()
15344 
 
15345 
  def write(self, oprot):
15346 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15347 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15348 
      return
15349 
    oprot.writeStructBegin('toggleDOAFlag_result')
3431 rajveer 15350 
    if self.success is not None:
2536 chandransh 15351 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
15352 
      oprot.writeBool(self.success)
15353 
      oprot.writeFieldEnd()
3431 rajveer 15354 
    if self.ex is not None:
2536 chandransh 15355 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
15356 
      self.ex.write(oprot)
15357 
      oprot.writeFieldEnd()
15358 
    oprot.writeFieldStop()
15359 
    oprot.writeStructEnd()
15360 
 
3431 rajveer 15361 
  def validate(self):
15362 
    return
15363 
 
15364 
 
2536 chandransh 15365 
  def __repr__(self):
15366 
    L = ['%s=%r' % (key, value)
15367 
      for key, value in self.__dict__.iteritems()]
15368 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15369 
 
15370 
  def __eq__(self, other):
15371 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15372 
 
15373 
  def __ne__(self, other):
15374 
    return not (self == other)
15375 
 
4712 rajveer 15376 
class markOrderAsDelivered_args:
15377 
  """
15378 
  Attributes:
15379 
   - orderId
15380 
   - deliveryTimestamp
15381 
   - receiver
15382 
  """
15383 
 
15384 
  thrift_spec = None
15385 
  def __init__(self, orderId=None, deliveryTimestamp=None, receiver=None,):
15386 
    self.orderId = orderId
15387 
    self.deliveryTimestamp = deliveryTimestamp
15388 
    self.receiver = receiver
15389 
 
15390 
  def read(self, iprot):
15391 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15392 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15393 
      return
15394 
    iprot.readStructBegin()
15395 
    while True:
15396 
      (fname, ftype, fid) = iprot.readFieldBegin()
15397 
      if ftype == TType.STOP:
15398 
        break
15399 
      if fid == 1:
15400 
        if ftype == TType.I64:
15401 
          self.orderId = iprot.readI64();
15402 
        else:
15403 
          iprot.skip(ftype)
15404 
      elif fid == 2:
15405 
        if ftype == TType.I64:
15406 
          self.deliveryTimestamp = iprot.readI64();
15407 
        else:
15408 
          iprot.skip(ftype)
15409 
      elif fid == -1:
15410 
        if ftype == TType.STRING:
15411 
          self.receiver = iprot.readString();
15412 
        else:
15413 
          iprot.skip(ftype)
15414 
      else:
15415 
        iprot.skip(ftype)
15416 
      iprot.readFieldEnd()
15417 
    iprot.readStructEnd()
15418 
 
15419 
  def write(self, oprot):
15420 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15421 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15422 
      return
15423 
    oprot.writeStructBegin('markOrderAsDelivered_args')
15424 
    if self.receiver is not None:
15425 
      oprot.writeFieldBegin('receiver', TType.STRING, -1)
15426 
      oprot.writeString(self.receiver)
15427 
      oprot.writeFieldEnd()
15428 
    if self.orderId is not None:
15429 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
15430 
      oprot.writeI64(self.orderId)
15431 
      oprot.writeFieldEnd()
15432 
    if self.deliveryTimestamp is not None:
15433 
      oprot.writeFieldBegin('deliveryTimestamp', TType.I64, 2)
15434 
      oprot.writeI64(self.deliveryTimestamp)
15435 
      oprot.writeFieldEnd()
15436 
    oprot.writeFieldStop()
15437 
    oprot.writeStructEnd()
15438 
 
15439 
  def validate(self):
15440 
    return
15441 
 
15442 
 
15443 
  def __repr__(self):
15444 
    L = ['%s=%r' % (key, value)
15445 
      for key, value in self.__dict__.iteritems()]
15446 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15447 
 
15448 
  def __eq__(self, other):
15449 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15450 
 
15451 
  def __ne__(self, other):
15452 
    return not (self == other)
15453 
 
15454 
class markOrderAsDelivered_result:
15455 
  """
15456 
  Attributes:
15457 
   - ex
15458 
  """
15459 
 
15460 
  thrift_spec = (
15461 
    None, # 0
15462 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
15463 
  )
15464 
 
15465 
  def __init__(self, ex=None,):
15466 
    self.ex = ex
15467 
 
15468 
  def read(self, iprot):
15469 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15470 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15471 
      return
15472 
    iprot.readStructBegin()
15473 
    while True:
15474 
      (fname, ftype, fid) = iprot.readFieldBegin()
15475 
      if ftype == TType.STOP:
15476 
        break
15477 
      if fid == 1:
15478 
        if ftype == TType.STRUCT:
15479 
          self.ex = TransactionServiceException()
15480 
          self.ex.read(iprot)
15481 
        else:
15482 
          iprot.skip(ftype)
15483 
      else:
15484 
        iprot.skip(ftype)
15485 
      iprot.readFieldEnd()
15486 
    iprot.readStructEnd()
15487 
 
15488 
  def write(self, oprot):
15489 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15490 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15491 
      return
15492 
    oprot.writeStructBegin('markOrderAsDelivered_result')
15493 
    if self.ex is not None:
15494 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
15495 
      self.ex.write(oprot)
15496 
      oprot.writeFieldEnd()
15497 
    oprot.writeFieldStop()
15498 
    oprot.writeStructEnd()
15499 
 
15500 
  def validate(self):
15501 
    return
15502 
 
15503 
 
15504 
  def __repr__(self):
15505 
    L = ['%s=%r' % (key, value)
15506 
      for key, value in self.__dict__.iteritems()]
15507 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15508 
 
15509 
  def __eq__(self, other):
15510 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15511 
 
15512 
  def __ne__(self, other):
15513 
    return not (self == other)
15514 
 
5553 rajveer 15515 
class markOrderAsReceivedAtStore_args:
15516 
  """
15517 
  Attributes:
15518 
   - orderId
15519 
   - deliveryTimestamp
15520 
  """
15521 
 
15522 
  thrift_spec = (
15523 
    None, # 0
15524 
    (1, TType.I64, 'orderId', None, None, ), # 1
15525 
    (2, TType.I64, 'deliveryTimestamp', None, None, ), # 2
15526 
  )
15527 
 
15528 
  def __init__(self, orderId=None, deliveryTimestamp=None,):
15529 
    self.orderId = orderId
15530 
    self.deliveryTimestamp = deliveryTimestamp
15531 
 
15532 
  def read(self, iprot):
15533 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15534 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15535 
      return
15536 
    iprot.readStructBegin()
15537 
    while True:
15538 
      (fname, ftype, fid) = iprot.readFieldBegin()
15539 
      if ftype == TType.STOP:
15540 
        break
15541 
      if fid == 1:
15542 
        if ftype == TType.I64:
15543 
          self.orderId = iprot.readI64();
15544 
        else:
15545 
          iprot.skip(ftype)
15546 
      elif fid == 2:
15547 
        if ftype == TType.I64:
15548 
          self.deliveryTimestamp = iprot.readI64();
15549 
        else:
15550 
          iprot.skip(ftype)
15551 
      else:
15552 
        iprot.skip(ftype)
15553 
      iprot.readFieldEnd()
15554 
    iprot.readStructEnd()
15555 
 
15556 
  def write(self, oprot):
15557 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15558 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15559 
      return
15560 
    oprot.writeStructBegin('markOrderAsReceivedAtStore_args')
15561 
    if self.orderId is not None:
15562 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
15563 
      oprot.writeI64(self.orderId)
15564 
      oprot.writeFieldEnd()
15565 
    if self.deliveryTimestamp is not None:
15566 
      oprot.writeFieldBegin('deliveryTimestamp', TType.I64, 2)
15567 
      oprot.writeI64(self.deliveryTimestamp)
15568 
      oprot.writeFieldEnd()
15569 
    oprot.writeFieldStop()
15570 
    oprot.writeStructEnd()
15571 
 
15572 
  def validate(self):
15573 
    return
15574 
 
15575 
 
15576 
  def __repr__(self):
15577 
    L = ['%s=%r' % (key, value)
15578 
      for key, value in self.__dict__.iteritems()]
15579 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15580 
 
15581 
  def __eq__(self, other):
15582 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15583 
 
15584 
  def __ne__(self, other):
15585 
    return not (self == other)
15586 
 
15587 
class markOrderAsReceivedAtStore_result:
15588 
  """
15589 
  Attributes:
15590 
   - ex
15591 
  """
15592 
 
15593 
  thrift_spec = (
15594 
    None, # 0
15595 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
15596 
  )
15597 
 
15598 
  def __init__(self, ex=None,):
15599 
    self.ex = ex
15600 
 
15601 
  def read(self, iprot):
15602 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15603 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15604 
      return
15605 
    iprot.readStructBegin()
15606 
    while True:
15607 
      (fname, ftype, fid) = iprot.readFieldBegin()
15608 
      if ftype == TType.STOP:
15609 
        break
15610 
      if fid == 1:
15611 
        if ftype == TType.STRUCT:
15612 
          self.ex = TransactionServiceException()
15613 
          self.ex.read(iprot)
15614 
        else:
15615 
          iprot.skip(ftype)
15616 
      else:
15617 
        iprot.skip(ftype)
15618 
      iprot.readFieldEnd()
15619 
    iprot.readStructEnd()
15620 
 
15621 
  def write(self, oprot):
15622 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15623 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15624 
      return
15625 
    oprot.writeStructBegin('markOrderAsReceivedAtStore_result')
15626 
    if self.ex is not None:
15627 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
15628 
      self.ex.write(oprot)
15629 
      oprot.writeFieldEnd()
15630 
    oprot.writeFieldStop()
15631 
    oprot.writeStructEnd()
15632 
 
15633 
  def validate(self):
15634 
    return
15635 
 
15636 
 
15637 
  def __repr__(self):
15638 
    L = ['%s=%r' % (key, value)
15639 
      for key, value in self.__dict__.iteritems()]
15640 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15641 
 
15642 
  def __eq__(self, other):
15643 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15644 
 
15645 
  def __ne__(self, other):
15646 
    return not (self == other)
15647 
 
4454 rajveer 15648 
class markOrderDoaRequestReceived_args:
15649 
  """
15650 
  Attributes:
15651 
   - orderId
15652 
  """
15653 
 
15654 
  thrift_spec = (
15655 
    None, # 0
15656 
    (1, TType.I64, 'orderId', None, None, ), # 1
15657 
  )
15658 
 
15659 
  def __init__(self, orderId=None,):
15660 
    self.orderId = orderId
15661 
 
15662 
  def read(self, iprot):
15663 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15664 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15665 
      return
15666 
    iprot.readStructBegin()
15667 
    while True:
15668 
      (fname, ftype, fid) = iprot.readFieldBegin()
15669 
      if ftype == TType.STOP:
15670 
        break
15671 
      if fid == 1:
15672 
        if ftype == TType.I64:
15673 
          self.orderId = iprot.readI64();
15674 
        else:
15675 
          iprot.skip(ftype)
15676 
      else:
15677 
        iprot.skip(ftype)
15678 
      iprot.readFieldEnd()
15679 
    iprot.readStructEnd()
15680 
 
15681 
  def write(self, oprot):
15682 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15683 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15684 
      return
15685 
    oprot.writeStructBegin('markOrderDoaRequestReceived_args')
15686 
    if self.orderId is not None:
15687 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
15688 
      oprot.writeI64(self.orderId)
15689 
      oprot.writeFieldEnd()
15690 
    oprot.writeFieldStop()
15691 
    oprot.writeStructEnd()
15692 
 
15693 
  def validate(self):
15694 
    return
15695 
 
15696 
 
15697 
  def __repr__(self):
15698 
    L = ['%s=%r' % (key, value)
15699 
      for key, value in self.__dict__.iteritems()]
15700 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15701 
 
15702 
  def __eq__(self, other):
15703 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15704 
 
15705 
  def __ne__(self, other):
15706 
    return not (self == other)
15707 
 
15708 
class markOrderDoaRequestReceived_result:
15709 
  """
15710 
  Attributes:
15711 
   - success
15712 
   - ex
15713 
  """
15714 
 
15715 
  thrift_spec = (
15716 
    (0, TType.BOOL, 'success', None, None, ), # 0
15717 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
15718 
  )
15719 
 
15720 
  def __init__(self, success=None, ex=None,):
15721 
    self.success = success
15722 
    self.ex = ex
15723 
 
15724 
  def read(self, iprot):
15725 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15726 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15727 
      return
15728 
    iprot.readStructBegin()
15729 
    while True:
15730 
      (fname, ftype, fid) = iprot.readFieldBegin()
15731 
      if ftype == TType.STOP:
15732 
        break
15733 
      if fid == 0:
15734 
        if ftype == TType.BOOL:
15735 
          self.success = iprot.readBool();
15736 
        else:
15737 
          iprot.skip(ftype)
15738 
      elif fid == 1:
15739 
        if ftype == TType.STRUCT:
15740 
          self.ex = TransactionServiceException()
15741 
          self.ex.read(iprot)
15742 
        else:
15743 
          iprot.skip(ftype)
15744 
      else:
15745 
        iprot.skip(ftype)
15746 
      iprot.readFieldEnd()
15747 
    iprot.readStructEnd()
15748 
 
15749 
  def write(self, oprot):
15750 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15751 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15752 
      return
15753 
    oprot.writeStructBegin('markOrderDoaRequestReceived_result')
15754 
    if self.success is not None:
15755 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
15756 
      oprot.writeBool(self.success)
15757 
      oprot.writeFieldEnd()
15758 
    if self.ex is not None:
15759 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
15760 
      self.ex.write(oprot)
15761 
      oprot.writeFieldEnd()
15762 
    oprot.writeFieldStop()
15763 
    oprot.writeStructEnd()
15764 
 
15765 
  def validate(self):
15766 
    return
15767 
 
15768 
 
15769 
  def __repr__(self):
15770 
    L = ['%s=%r' % (key, value)
15771 
      for key, value in self.__dict__.iteritems()]
15772 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15773 
 
15774 
  def __eq__(self, other):
15775 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15776 
 
15777 
  def __ne__(self, other):
15778 
    return not (self == other)
15779 
 
15780 
class markOrderDoaRequestAuthorized_args:
15781 
  """
15782 
  Attributes:
15783 
   - orderId
15784 
   - isAuthorized
15785 
  """
15786 
 
15787 
  thrift_spec = (
15788 
    None, # 0
15789 
    (1, TType.I64, 'orderId', None, None, ), # 1
15790 
    (2, TType.BOOL, 'isAuthorized', None, None, ), # 2
15791 
  )
15792 
 
15793 
  def __init__(self, orderId=None, isAuthorized=None,):
15794 
    self.orderId = orderId
15795 
    self.isAuthorized = isAuthorized
15796 
 
15797 
  def read(self, iprot):
15798 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15799 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15800 
      return
15801 
    iprot.readStructBegin()
15802 
    while True:
15803 
      (fname, ftype, fid) = iprot.readFieldBegin()
15804 
      if ftype == TType.STOP:
15805 
        break
15806 
      if fid == 1:
15807 
        if ftype == TType.I64:
15808 
          self.orderId = iprot.readI64();
15809 
        else:
15810 
          iprot.skip(ftype)
15811 
      elif fid == 2:
15812 
        if ftype == TType.BOOL:
15813 
          self.isAuthorized = iprot.readBool();
15814 
        else:
15815 
          iprot.skip(ftype)
15816 
      else:
15817 
        iprot.skip(ftype)
15818 
      iprot.readFieldEnd()
15819 
    iprot.readStructEnd()
15820 
 
15821 
  def write(self, oprot):
15822 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15823 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15824 
      return
15825 
    oprot.writeStructBegin('markOrderDoaRequestAuthorized_args')
15826 
    if self.orderId is not None:
15827 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
15828 
      oprot.writeI64(self.orderId)
15829 
      oprot.writeFieldEnd()
15830 
    if self.isAuthorized is not None:
15831 
      oprot.writeFieldBegin('isAuthorized', TType.BOOL, 2)
15832 
      oprot.writeBool(self.isAuthorized)
15833 
      oprot.writeFieldEnd()
15834 
    oprot.writeFieldStop()
15835 
    oprot.writeStructEnd()
15836 
 
15837 
  def validate(self):
15838 
    return
15839 
 
15840 
 
15841 
  def __repr__(self):
15842 
    L = ['%s=%r' % (key, value)
15843 
      for key, value in self.__dict__.iteritems()]
15844 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15845 
 
15846 
  def __eq__(self, other):
15847 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15848 
 
15849 
  def __ne__(self, other):
15850 
    return not (self == other)
15851 
 
15852 
class markOrderDoaRequestAuthorized_result:
15853 
  """
15854 
  Attributes:
15855 
   - success
15856 
   - ex
15857 
  """
15858 
 
15859 
  thrift_spec = (
15860 
    (0, TType.BOOL, 'success', None, None, ), # 0
15861 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
15862 
  )
15863 
 
15864 
  def __init__(self, success=None, ex=None,):
15865 
    self.success = success
15866 
    self.ex = ex
15867 
 
15868 
  def read(self, iprot):
15869 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15870 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15871 
      return
15872 
    iprot.readStructBegin()
15873 
    while True:
15874 
      (fname, ftype, fid) = iprot.readFieldBegin()
15875 
      if ftype == TType.STOP:
15876 
        break
15877 
      if fid == 0:
15878 
        if ftype == TType.BOOL:
15879 
          self.success = iprot.readBool();
15880 
        else:
15881 
          iprot.skip(ftype)
15882 
      elif fid == 1:
15883 
        if ftype == TType.STRUCT:
15884 
          self.ex = TransactionServiceException()
15885 
          self.ex.read(iprot)
15886 
        else:
15887 
          iprot.skip(ftype)
15888 
      else:
15889 
        iprot.skip(ftype)
15890 
      iprot.readFieldEnd()
15891 
    iprot.readStructEnd()
15892 
 
15893 
  def write(self, oprot):
15894 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15895 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15896 
      return
15897 
    oprot.writeStructBegin('markOrderDoaRequestAuthorized_result')
15898 
    if self.success is not None:
15899 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
15900 
      oprot.writeBool(self.success)
15901 
      oprot.writeFieldEnd()
15902 
    if self.ex is not None:
15903 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
15904 
      self.ex.write(oprot)
15905 
      oprot.writeFieldEnd()
15906 
    oprot.writeFieldStop()
15907 
    oprot.writeStructEnd()
15908 
 
15909 
  def validate(self):
15910 
    return
15911 
 
15912 
 
15913 
  def __repr__(self):
15914 
    L = ['%s=%r' % (key, value)
15915 
      for key, value in self.__dict__.iteritems()]
15916 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15917 
 
15918 
  def __eq__(self, other):
15919 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15920 
 
15921 
  def __ne__(self, other):
15922 
    return not (self == other)
15923 
 
4488 rajveer 15924 
class markOrderReturnRequestReceived_args:
15925 
  """
15926 
  Attributes:
15927 
   - orderId
15928 
  """
15929 
 
15930 
  thrift_spec = (
15931 
    None, # 0
15932 
    (1, TType.I64, 'orderId', None, None, ), # 1
15933 
  )
15934 
 
15935 
  def __init__(self, orderId=None,):
15936 
    self.orderId = orderId
15937 
 
15938 
  def read(self, iprot):
15939 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15940 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15941 
      return
15942 
    iprot.readStructBegin()
15943 
    while True:
15944 
      (fname, ftype, fid) = iprot.readFieldBegin()
15945 
      if ftype == TType.STOP:
15946 
        break
15947 
      if fid == 1:
15948 
        if ftype == TType.I64:
15949 
          self.orderId = iprot.readI64();
15950 
        else:
15951 
          iprot.skip(ftype)
15952 
      else:
15953 
        iprot.skip(ftype)
15954 
      iprot.readFieldEnd()
15955 
    iprot.readStructEnd()
15956 
 
15957 
  def write(self, oprot):
15958 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15959 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15960 
      return
15961 
    oprot.writeStructBegin('markOrderReturnRequestReceived_args')
15962 
    if self.orderId is not None:
15963 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
15964 
      oprot.writeI64(self.orderId)
15965 
      oprot.writeFieldEnd()
15966 
    oprot.writeFieldStop()
15967 
    oprot.writeStructEnd()
15968 
 
15969 
  def validate(self):
15970 
    return
15971 
 
15972 
 
15973 
  def __repr__(self):
15974 
    L = ['%s=%r' % (key, value)
15975 
      for key, value in self.__dict__.iteritems()]
15976 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15977 
 
15978 
  def __eq__(self, other):
15979 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15980 
 
15981 
  def __ne__(self, other):
15982 
    return not (self == other)
15983 
 
15984 
class markOrderReturnRequestReceived_result:
15985 
  """
15986 
  Attributes:
15987 
   - success
15988 
   - ex
15989 
  """
15990 
 
15991 
  thrift_spec = (
15992 
    (0, TType.BOOL, 'success', None, None, ), # 0
15993 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
15994 
  )
15995 
 
15996 
  def __init__(self, success=None, ex=None,):
15997 
    self.success = success
15998 
    self.ex = ex
15999 
 
16000 
  def read(self, iprot):
16001 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16002 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16003 
      return
16004 
    iprot.readStructBegin()
16005 
    while True:
16006 
      (fname, ftype, fid) = iprot.readFieldBegin()
16007 
      if ftype == TType.STOP:
16008 
        break
16009 
      if fid == 0:
16010 
        if ftype == TType.BOOL:
16011 
          self.success = iprot.readBool();
16012 
        else:
16013 
          iprot.skip(ftype)
16014 
      elif fid == 1:
16015 
        if ftype == TType.STRUCT:
16016 
          self.ex = TransactionServiceException()
16017 
          self.ex.read(iprot)
16018 
        else:
16019 
          iprot.skip(ftype)
16020 
      else:
16021 
        iprot.skip(ftype)
16022 
      iprot.readFieldEnd()
16023 
    iprot.readStructEnd()
16024 
 
16025 
  def write(self, oprot):
16026 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16027 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16028 
      return
16029 
    oprot.writeStructBegin('markOrderReturnRequestReceived_result')
16030 
    if self.success is not None:
16031 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
16032 
      oprot.writeBool(self.success)
16033 
      oprot.writeFieldEnd()
16034 
    if self.ex is not None:
16035 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
16036 
      self.ex.write(oprot)
16037 
      oprot.writeFieldEnd()
16038 
    oprot.writeFieldStop()
16039 
    oprot.writeStructEnd()
16040 
 
16041 
  def validate(self):
16042 
    return
16043 
 
16044 
 
16045 
  def __repr__(self):
16046 
    L = ['%s=%r' % (key, value)
16047 
      for key, value in self.__dict__.iteritems()]
16048 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16049 
 
16050 
  def __eq__(self, other):
16051 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16052 
 
16053 
  def __ne__(self, other):
16054 
    return not (self == other)
16055 
 
16056 
class markOrderReturnRequestAuthorized_args:
16057 
  """
16058 
  Attributes:
16059 
   - orderId
16060 
   - isAuthorized
16061 
  """
16062 
 
16063 
  thrift_spec = (
16064 
    None, # 0
16065 
    (1, TType.I64, 'orderId', None, None, ), # 1
16066 
    (2, TType.BOOL, 'isAuthorized', None, None, ), # 2
16067 
  )
16068 
 
16069 
  def __init__(self, orderId=None, isAuthorized=None,):
16070 
    self.orderId = orderId
16071 
    self.isAuthorized = isAuthorized
16072 
 
16073 
  def read(self, iprot):
16074 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16075 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16076 
      return
16077 
    iprot.readStructBegin()
16078 
    while True:
16079 
      (fname, ftype, fid) = iprot.readFieldBegin()
16080 
      if ftype == TType.STOP:
16081 
        break
16082 
      if fid == 1:
16083 
        if ftype == TType.I64:
16084 
          self.orderId = iprot.readI64();
16085 
        else:
16086 
          iprot.skip(ftype)
16087 
      elif fid == 2:
16088 
        if ftype == TType.BOOL:
16089 
          self.isAuthorized = iprot.readBool();
16090 
        else:
16091 
          iprot.skip(ftype)
16092 
      else:
16093 
        iprot.skip(ftype)
16094 
      iprot.readFieldEnd()
16095 
    iprot.readStructEnd()
16096 
 
16097 
  def write(self, oprot):
16098 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16099 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16100 
      return
16101 
    oprot.writeStructBegin('markOrderReturnRequestAuthorized_args')
16102 
    if self.orderId is not None:
16103 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
16104 
      oprot.writeI64(self.orderId)
16105 
      oprot.writeFieldEnd()
16106 
    if self.isAuthorized is not None:
16107 
      oprot.writeFieldBegin('isAuthorized', TType.BOOL, 2)
16108 
      oprot.writeBool(self.isAuthorized)
16109 
      oprot.writeFieldEnd()
16110 
    oprot.writeFieldStop()
16111 
    oprot.writeStructEnd()
16112 
 
16113 
  def validate(self):
16114 
    return
16115 
 
16116 
 
16117 
  def __repr__(self):
16118 
    L = ['%s=%r' % (key, value)
16119 
      for key, value in self.__dict__.iteritems()]
16120 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16121 
 
16122 
  def __eq__(self, other):
16123 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16124 
 
16125 
  def __ne__(self, other):
16126 
    return not (self == other)
16127 
 
16128 
class markOrderReturnRequestAuthorized_result:
16129 
  """
16130 
  Attributes:
16131 
   - success
16132 
   - ex
16133 
  """
16134 
 
16135 
  thrift_spec = (
16136 
    (0, TType.BOOL, 'success', None, None, ), # 0
16137 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
16138 
  )
16139 
 
16140 
  def __init__(self, success=None, ex=None,):
16141 
    self.success = success
16142 
    self.ex = ex
16143 
 
16144 
  def read(self, iprot):
16145 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16146 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16147 
      return
16148 
    iprot.readStructBegin()
16149 
    while True:
16150 
      (fname, ftype, fid) = iprot.readFieldBegin()
16151 
      if ftype == TType.STOP:
16152 
        break
16153 
      if fid == 0:
16154 
        if ftype == TType.BOOL:
16155 
          self.success = iprot.readBool();
16156 
        else:
16157 
          iprot.skip(ftype)
16158 
      elif fid == 1:
16159 
        if ftype == TType.STRUCT:
16160 
          self.ex = TransactionServiceException()
16161 
          self.ex.read(iprot)
16162 
        else:
16163 
          iprot.skip(ftype)
16164 
      else:
16165 
        iprot.skip(ftype)
16166 
      iprot.readFieldEnd()
16167 
    iprot.readStructEnd()
16168 
 
16169 
  def write(self, oprot):
16170 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16171 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16172 
      return
16173 
    oprot.writeStructBegin('markOrderReturnRequestAuthorized_result')
16174 
    if self.success is not None:
16175 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
16176 
      oprot.writeBool(self.success)
16177 
      oprot.writeFieldEnd()
16178 
    if self.ex is not None:
16179 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
16180 
      self.ex.write(oprot)
16181 
      oprot.writeFieldEnd()
16182 
    oprot.writeFieldStop()
16183 
    oprot.writeStructEnd()
16184 
 
16185 
  def validate(self):
16186 
    return
16187 
 
16188 
 
16189 
  def __repr__(self):
16190 
    L = ['%s=%r' % (key, value)
16191 
      for key, value in self.__dict__.iteritems()]
16192 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16193 
 
16194 
  def __eq__(self, other):
16195 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16196 
 
16197 
  def __ne__(self, other):
16198 
    return not (self == other)
16199 
 
2536 chandransh 16200 
class requestPickupNumber_args:
16201 
  """
16202 
  Attributes:
16203 
   - orderId
4579 rajveer 16204 
   - providerId
2536 chandransh 16205 
  """
16206 
 
16207 
  thrift_spec = (
16208 
    None, # 0
16209 
    (1, TType.I64, 'orderId', None, None, ), # 1
4579 rajveer 16210 
    (2, TType.I64, 'providerId', None, None, ), # 2
2536 chandransh 16211 
  )
16212 
 
4579 rajveer 16213 
  def __init__(self, orderId=None, providerId=None,):
2536 chandransh 16214 
    self.orderId = orderId
4579 rajveer 16215 
    self.providerId = providerId
2536 chandransh 16216 
 
16217 
  def read(self, iprot):
16218 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16219 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16220 
      return
16221 
    iprot.readStructBegin()
16222 
    while True:
16223 
      (fname, ftype, fid) = iprot.readFieldBegin()
16224 
      if ftype == TType.STOP:
16225 
        break
16226 
      if fid == 1:
16227 
        if ftype == TType.I64:
16228 
          self.orderId = iprot.readI64();
16229 
        else:
16230 
          iprot.skip(ftype)
4579 rajveer 16231 
      elif fid == 2:
16232 
        if ftype == TType.I64:
16233 
          self.providerId = iprot.readI64();
16234 
        else:
16235 
          iprot.skip(ftype)
2536 chandransh 16236 
      else:
16237 
        iprot.skip(ftype)
16238 
      iprot.readFieldEnd()
16239 
    iprot.readStructEnd()
16240 
 
16241 
  def write(self, oprot):
16242 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16243 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16244 
      return
16245 
    oprot.writeStructBegin('requestPickupNumber_args')
3431 rajveer 16246 
    if self.orderId is not None:
2536 chandransh 16247 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
16248 
      oprot.writeI64(self.orderId)
16249 
      oprot.writeFieldEnd()
4579 rajveer 16250 
    if self.providerId is not None:
16251 
      oprot.writeFieldBegin('providerId', TType.I64, 2)
16252 
      oprot.writeI64(self.providerId)
16253 
      oprot.writeFieldEnd()
2536 chandransh 16254 
    oprot.writeFieldStop()
16255 
    oprot.writeStructEnd()
16256 
 
3431 rajveer 16257 
  def validate(self):
16258 
    return
16259 
 
16260 
 
2536 chandransh 16261 
  def __repr__(self):
16262 
    L = ['%s=%r' % (key, value)
16263 
      for key, value in self.__dict__.iteritems()]
16264 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16265 
 
16266 
  def __eq__(self, other):
16267 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16268 
 
16269 
  def __ne__(self, other):
16270 
    return not (self == other)
16271 
 
16272 
class requestPickupNumber_result:
16273 
  """
16274 
  Attributes:
16275 
   - success
16276 
   - ex
16277 
  """
16278 
 
16279 
  thrift_spec = (
16280 
    (0, TType.BOOL, 'success', None, None, ), # 0
16281 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
16282 
  )
16283 
 
16284 
  def __init__(self, success=None, ex=None,):
16285 
    self.success = success
16286 
    self.ex = ex
16287 
 
16288 
  def read(self, iprot):
16289 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16290 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16291 
      return
16292 
    iprot.readStructBegin()
16293 
    while True:
16294 
      (fname, ftype, fid) = iprot.readFieldBegin()
16295 
      if ftype == TType.STOP:
16296 
        break
16297 
      if fid == 0:
16298 
        if ftype == TType.BOOL:
16299 
          self.success = iprot.readBool();
16300 
        else:
16301 
          iprot.skip(ftype)
16302 
      elif fid == 1:
16303 
        if ftype == TType.STRUCT:
16304 
          self.ex = TransactionServiceException()
16305 
          self.ex.read(iprot)
16306 
        else:
16307 
          iprot.skip(ftype)
16308 
      else:
16309 
        iprot.skip(ftype)
16310 
      iprot.readFieldEnd()
16311 
    iprot.readStructEnd()
16312 
 
16313 
  def write(self, oprot):
16314 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16315 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16316 
      return
16317 
    oprot.writeStructBegin('requestPickupNumber_result')
3431 rajveer 16318 
    if self.success is not None:
2536 chandransh 16319 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
16320 
      oprot.writeBool(self.success)
16321 
      oprot.writeFieldEnd()
3431 rajveer 16322 
    if self.ex is not None:
2536 chandransh 16323 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
16324 
      self.ex.write(oprot)
16325 
      oprot.writeFieldEnd()
16326 
    oprot.writeFieldStop()
16327 
    oprot.writeStructEnd()
16328 
 
3431 rajveer 16329 
  def validate(self):
16330 
    return
16331 
 
16332 
 
2536 chandransh 16333 
  def __repr__(self):
16334 
    L = ['%s=%r' % (key, value)
16335 
      for key, value in self.__dict__.iteritems()]
16336 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16337 
 
16338 
  def __eq__(self, other):
16339 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16340 
 
16341 
  def __ne__(self, other):
16342 
    return not (self == other)
16343 
 
16344 
class authorizePickup_args:
16345 
  """
16346 
  Attributes:
16347 
   - orderId
16348 
   - pickupNumber
4602 rajveer 16349 
   - providerId
2536 chandransh 16350 
  """
16351 
 
16352 
  thrift_spec = (
16353 
    None, # 0
16354 
    (1, TType.I64, 'orderId', None, None, ), # 1
16355 
    (2, TType.STRING, 'pickupNumber', None, None, ), # 2
4602 rajveer 16356 
    (3, TType.I64, 'providerId', None, None, ), # 3
2536 chandransh 16357 
  )
16358 
 
4602 rajveer 16359 
  def __init__(self, orderId=None, pickupNumber=None, providerId=None,):
2536 chandransh 16360 
    self.orderId = orderId
16361 
    self.pickupNumber = pickupNumber
4602 rajveer 16362 
    self.providerId = providerId
2536 chandransh 16363 
 
16364 
  def read(self, iprot):
16365 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16366 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16367 
      return
16368 
    iprot.readStructBegin()
16369 
    while True:
16370 
      (fname, ftype, fid) = iprot.readFieldBegin()
16371 
      if ftype == TType.STOP:
16372 
        break
16373 
      if fid == 1:
16374 
        if ftype == TType.I64:
16375 
          self.orderId = iprot.readI64();
16376 
        else:
16377 
          iprot.skip(ftype)
16378 
      elif fid == 2:
16379 
        if ftype == TType.STRING:
16380 
          self.pickupNumber = iprot.readString();
16381 
        else:
16382 
          iprot.skip(ftype)
4602 rajveer 16383 
      elif fid == 3:
16384 
        if ftype == TType.I64:
16385 
          self.providerId = iprot.readI64();
16386 
        else:
16387 
          iprot.skip(ftype)
2536 chandransh 16388 
      else:
16389 
        iprot.skip(ftype)
16390 
      iprot.readFieldEnd()
16391 
    iprot.readStructEnd()
16392 
 
16393 
  def write(self, oprot):
16394 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16395 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16396 
      return
16397 
    oprot.writeStructBegin('authorizePickup_args')
3431 rajveer 16398 
    if self.orderId is not None:
2536 chandransh 16399 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
16400 
      oprot.writeI64(self.orderId)
16401 
      oprot.writeFieldEnd()
3431 rajveer 16402 
    if self.pickupNumber is not None:
2536 chandransh 16403 
      oprot.writeFieldBegin('pickupNumber', TType.STRING, 2)
16404 
      oprot.writeString(self.pickupNumber)
16405 
      oprot.writeFieldEnd()
4602 rajveer 16406 
    if self.providerId is not None:
16407 
      oprot.writeFieldBegin('providerId', TType.I64, 3)
16408 
      oprot.writeI64(self.providerId)
16409 
      oprot.writeFieldEnd()
2536 chandransh 16410 
    oprot.writeFieldStop()
16411 
    oprot.writeStructEnd()
16412 
 
3431 rajveer 16413 
  def validate(self):
16414 
    return
16415 
 
16416 
 
2536 chandransh 16417 
  def __repr__(self):
16418 
    L = ['%s=%r' % (key, value)
16419 
      for key, value in self.__dict__.iteritems()]
16420 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16421 
 
16422 
  def __eq__(self, other):
16423 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16424 
 
16425 
  def __ne__(self, other):
16426 
    return not (self == other)
16427 
 
16428 
class authorizePickup_result:
16429 
  """
16430 
  Attributes:
16431 
   - success
16432 
   - ex
16433 
  """
16434 
 
16435 
  thrift_spec = (
16436 
    (0, TType.BOOL, 'success', None, None, ), # 0
16437 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
16438 
  )
16439 
 
16440 
  def __init__(self, success=None, ex=None,):
16441 
    self.success = success
16442 
    self.ex = ex
16443 
 
16444 
  def read(self, iprot):
16445 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16446 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16447 
      return
16448 
    iprot.readStructBegin()
16449 
    while True:
16450 
      (fname, ftype, fid) = iprot.readFieldBegin()
16451 
      if ftype == TType.STOP:
16452 
        break
16453 
      if fid == 0:
16454 
        if ftype == TType.BOOL:
16455 
          self.success = iprot.readBool();
16456 
        else:
16457 
          iprot.skip(ftype)
16458 
      elif fid == 1:
16459 
        if ftype == TType.STRUCT:
16460 
          self.ex = TransactionServiceException()
16461 
          self.ex.read(iprot)
16462 
        else:
16463 
          iprot.skip(ftype)
16464 
      else:
16465 
        iprot.skip(ftype)
16466 
      iprot.readFieldEnd()
16467 
    iprot.readStructEnd()
16468 
 
16469 
  def write(self, oprot):
16470 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16471 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16472 
      return
16473 
    oprot.writeStructBegin('authorizePickup_result')
3431 rajveer 16474 
    if self.success is not None:
2536 chandransh 16475 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
16476 
      oprot.writeBool(self.success)
16477 
      oprot.writeFieldEnd()
3431 rajveer 16478 
    if self.ex is not None:
2536 chandransh 16479 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
16480 
      self.ex.write(oprot)
16481 
      oprot.writeFieldEnd()
16482 
    oprot.writeFieldStop()
16483 
    oprot.writeStructEnd()
16484 
 
3431 rajveer 16485 
  def validate(self):
16486 
    return
16487 
 
16488 
 
2536 chandransh 16489 
  def __repr__(self):
16490 
    L = ['%s=%r' % (key, value)
16491 
      for key, value in self.__dict__.iteritems()]
16492 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16493 
 
16494 
  def __eq__(self, other):
16495 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16496 
 
16497 
  def __ne__(self, other):
16498 
    return not (self == other)
16499 
 
2764 chandransh 16500 
class markDoasAsPickedUp_args:
16501 
  """
16502 
  Attributes:
16503 
   - providerId
16504 
   - pickupDetails
16505 
  """
16506 
 
16507 
  thrift_spec = (
16508 
    None, # 0
16509 
    (1, TType.I64, 'providerId', None, None, ), # 1
16510 
    (2, TType.MAP, 'pickupDetails', (TType.STRING,None,TType.STRING,None), None, ), # 2
16511 
  )
16512 
 
16513 
  def __init__(self, providerId=None, pickupDetails=None,):
16514 
    self.providerId = providerId
16515 
    self.pickupDetails = pickupDetails
16516 
 
16517 
  def read(self, iprot):
16518 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16519 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16520 
      return
16521 
    iprot.readStructBegin()
16522 
    while True:
16523 
      (fname, ftype, fid) = iprot.readFieldBegin()
16524 
      if ftype == TType.STOP:
16525 
        break
16526 
      if fid == 1:
16527 
        if ftype == TType.I64:
16528 
          self.providerId = iprot.readI64();
16529 
        else:
16530 
          iprot.skip(ftype)
16531 
      elif fid == 2:
16532 
        if ftype == TType.MAP:
16533 
          self.pickupDetails = {}
6000 mandeep.dh 16534 
          (_ktype372, _vtype373, _size371 ) = iprot.readMapBegin()
16535 
          for _i375 in xrange(_size371):
16536 
            _key376 = iprot.readString();
16537 
            _val377 = iprot.readString();
16538 
            self.pickupDetails[_key376] = _val377
2764 chandransh 16539 
          iprot.readMapEnd()
16540 
        else:
16541 
          iprot.skip(ftype)
16542 
      else:
16543 
        iprot.skip(ftype)
16544 
      iprot.readFieldEnd()
16545 
    iprot.readStructEnd()
16546 
 
16547 
  def write(self, oprot):
16548 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16549 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16550 
      return
16551 
    oprot.writeStructBegin('markDoasAsPickedUp_args')
3431 rajveer 16552 
    if self.providerId is not None:
2764 chandransh 16553 
      oprot.writeFieldBegin('providerId', TType.I64, 1)
16554 
      oprot.writeI64(self.providerId)
16555 
      oprot.writeFieldEnd()
3431 rajveer 16556 
    if self.pickupDetails is not None:
2764 chandransh 16557 
      oprot.writeFieldBegin('pickupDetails', TType.MAP, 2)
16558 
      oprot.writeMapBegin(TType.STRING, TType.STRING, len(self.pickupDetails))
6000 mandeep.dh 16559 
      for kiter378,viter379 in self.pickupDetails.items():
16560 
        oprot.writeString(kiter378)
16561 
        oprot.writeString(viter379)
2764 chandransh 16562 
      oprot.writeMapEnd()
16563 
      oprot.writeFieldEnd()
16564 
    oprot.writeFieldStop()
16565 
    oprot.writeStructEnd()
16566 
 
3431 rajveer 16567 
  def validate(self):
16568 
    return
16569 
 
16570 
 
2764 chandransh 16571 
  def __repr__(self):
16572 
    L = ['%s=%r' % (key, value)
16573 
      for key, value in self.__dict__.iteritems()]
16574 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16575 
 
16576 
  def __eq__(self, other):
16577 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16578 
 
16579 
  def __ne__(self, other):
16580 
    return not (self == other)
16581 
 
16582 
class markDoasAsPickedUp_result:
4910 phani.kuma 16583 
 
16584 
  thrift_spec = (
16585 
  )
16586 
 
16587 
  def read(self, iprot):
16588 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16589 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16590 
      return
16591 
    iprot.readStructBegin()
16592 
    while True:
16593 
      (fname, ftype, fid) = iprot.readFieldBegin()
16594 
      if ftype == TType.STOP:
16595 
        break
16596 
      else:
16597 
        iprot.skip(ftype)
16598 
      iprot.readFieldEnd()
16599 
    iprot.readStructEnd()
16600 
 
16601 
  def write(self, oprot):
16602 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16603 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16604 
      return
16605 
    oprot.writeStructBegin('markDoasAsPickedUp_result')
16606 
    oprot.writeFieldStop()
16607 
    oprot.writeStructEnd()
16608 
 
16609 
  def validate(self):
16610 
    return
16611 
 
16612 
 
16613 
  def __repr__(self):
16614 
    L = ['%s=%r' % (key, value)
16615 
      for key, value in self.__dict__.iteritems()]
16616 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16617 
 
16618 
  def __eq__(self, other):
16619 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16620 
 
16621 
  def __ne__(self, other):
16622 
    return not (self == other)
16623 
 
16624 
class getDoasNotPickedUp_args:
2764 chandransh 16625 
  """
16626 
  Attributes:
4910 phani.kuma 16627 
   - providerId
16628 
  """
16629 
 
16630 
  thrift_spec = (
16631 
    None, # 0
16632 
    (1, TType.I64, 'providerId', None, None, ), # 1
16633 
  )
16634 
 
16635 
  def __init__(self, providerId=None,):
16636 
    self.providerId = providerId
16637 
 
16638 
  def read(self, iprot):
16639 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16640 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16641 
      return
16642 
    iprot.readStructBegin()
16643 
    while True:
16644 
      (fname, ftype, fid) = iprot.readFieldBegin()
16645 
      if ftype == TType.STOP:
16646 
        break
16647 
      if fid == 1:
16648 
        if ftype == TType.I64:
16649 
          self.providerId = iprot.readI64();
16650 
        else:
16651 
          iprot.skip(ftype)
16652 
      else:
16653 
        iprot.skip(ftype)
16654 
      iprot.readFieldEnd()
16655 
    iprot.readStructEnd()
16656 
 
16657 
  def write(self, oprot):
16658 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16659 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16660 
      return
16661 
    oprot.writeStructBegin('getDoasNotPickedUp_args')
16662 
    if self.providerId is not None:
16663 
      oprot.writeFieldBegin('providerId', TType.I64, 1)
16664 
      oprot.writeI64(self.providerId)
16665 
      oprot.writeFieldEnd()
16666 
    oprot.writeFieldStop()
16667 
    oprot.writeStructEnd()
16668 
 
16669 
  def validate(self):
16670 
    return
16671 
 
16672 
 
16673 
  def __repr__(self):
16674 
    L = ['%s=%r' % (key, value)
16675 
      for key, value in self.__dict__.iteritems()]
16676 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16677 
 
16678 
  def __eq__(self, other):
16679 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16680 
 
16681 
  def __ne__(self, other):
16682 
    return not (self == other)
16683 
 
16684 
class getDoasNotPickedUp_result:
16685 
  """
16686 
  Attributes:
2764 chandransh 16687 
   - success
16688 
  """
16689 
 
16690 
  thrift_spec = (
16691 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
16692 
  )
16693 
 
16694 
  def __init__(self, success=None,):
16695 
    self.success = success
16696 
 
16697 
  def read(self, iprot):
16698 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16699 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16700 
      return
16701 
    iprot.readStructBegin()
16702 
    while True:
16703 
      (fname, ftype, fid) = iprot.readFieldBegin()
16704 
      if ftype == TType.STOP:
16705 
        break
16706 
      if fid == 0:
16707 
        if ftype == TType.LIST:
16708 
          self.success = []
6000 mandeep.dh 16709 
          (_etype383, _size380) = iprot.readListBegin()
16710 
          for _i384 in xrange(_size380):
16711 
            _elem385 = Order()
16712 
            _elem385.read(iprot)
16713 
            self.success.append(_elem385)
2764 chandransh 16714 
          iprot.readListEnd()
16715 
        else:
16716 
          iprot.skip(ftype)
16717 
      else:
16718 
        iprot.skip(ftype)
16719 
      iprot.readFieldEnd()
16720 
    iprot.readStructEnd()
16721 
 
16722 
  def write(self, oprot):
16723 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16724 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16725 
      return
4910 phani.kuma 16726 
    oprot.writeStructBegin('getDoasNotPickedUp_result')
3431 rajveer 16727 
    if self.success is not None:
2764 chandransh 16728 
      oprot.writeFieldBegin('success', TType.LIST, 0)
16729 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
6000 mandeep.dh 16730 
      for iter386 in self.success:
16731 
        iter386.write(oprot)
2764 chandransh 16732 
      oprot.writeListEnd()
16733 
      oprot.writeFieldEnd()
16734 
    oprot.writeFieldStop()
16735 
    oprot.writeStructEnd()
16736 
 
3431 rajveer 16737 
  def validate(self):
16738 
    return
16739 
 
16740 
 
2764 chandransh 16741 
  def __repr__(self):
16742 
    L = ['%s=%r' % (key, value)
16743 
      for key, value in self.__dict__.iteritems()]
16744 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16745 
 
16746 
  def __eq__(self, other):
16747 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16748 
 
16749 
  def __ne__(self, other):
16750 
    return not (self == other)
16751 
 
4741 phani.kuma 16752 
class markReturnOrdersAsPickedUp_args:
16753 
  """
16754 
  Attributes:
16755 
   - providerId
16756 
   - pickupDetails
16757 
  """
16758 
 
16759 
  thrift_spec = (
16760 
    None, # 0
16761 
    (1, TType.I64, 'providerId', None, None, ), # 1
16762 
    (2, TType.MAP, 'pickupDetails', (TType.STRING,None,TType.STRING,None), None, ), # 2
16763 
  )
16764 
 
16765 
  def __init__(self, providerId=None, pickupDetails=None,):
16766 
    self.providerId = providerId
16767 
    self.pickupDetails = pickupDetails
16768 
 
16769 
  def read(self, iprot):
16770 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16771 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16772 
      return
16773 
    iprot.readStructBegin()
16774 
    while True:
16775 
      (fname, ftype, fid) = iprot.readFieldBegin()
16776 
      if ftype == TType.STOP:
16777 
        break
16778 
      if fid == 1:
16779 
        if ftype == TType.I64:
16780 
          self.providerId = iprot.readI64();
16781 
        else:
16782 
          iprot.skip(ftype)
16783 
      elif fid == 2:
16784 
        if ftype == TType.MAP:
16785 
          self.pickupDetails = {}
6000 mandeep.dh 16786 
          (_ktype388, _vtype389, _size387 ) = iprot.readMapBegin()
16787 
          for _i391 in xrange(_size387):
16788 
            _key392 = iprot.readString();
16789 
            _val393 = iprot.readString();
16790 
            self.pickupDetails[_key392] = _val393
4741 phani.kuma 16791 
          iprot.readMapEnd()
16792 
        else:
16793 
          iprot.skip(ftype)
16794 
      else:
16795 
        iprot.skip(ftype)
16796 
      iprot.readFieldEnd()
16797 
    iprot.readStructEnd()
16798 
 
16799 
  def write(self, oprot):
16800 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16801 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16802 
      return
16803 
    oprot.writeStructBegin('markReturnOrdersAsPickedUp_args')
16804 
    if self.providerId is not None:
16805 
      oprot.writeFieldBegin('providerId', TType.I64, 1)
16806 
      oprot.writeI64(self.providerId)
16807 
      oprot.writeFieldEnd()
16808 
    if self.pickupDetails is not None:
16809 
      oprot.writeFieldBegin('pickupDetails', TType.MAP, 2)
16810 
      oprot.writeMapBegin(TType.STRING, TType.STRING, len(self.pickupDetails))
6000 mandeep.dh 16811 
      for kiter394,viter395 in self.pickupDetails.items():
16812 
        oprot.writeString(kiter394)
16813 
        oprot.writeString(viter395)
4741 phani.kuma 16814 
      oprot.writeMapEnd()
16815 
      oprot.writeFieldEnd()
16816 
    oprot.writeFieldStop()
16817 
    oprot.writeStructEnd()
16818 
 
16819 
  def validate(self):
16820 
    return
16821 
 
16822 
 
16823 
  def __repr__(self):
16824 
    L = ['%s=%r' % (key, value)
16825 
      for key, value in self.__dict__.iteritems()]
16826 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16827 
 
16828 
  def __eq__(self, other):
16829 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16830 
 
16831 
  def __ne__(self, other):
16832 
    return not (self == other)
16833 
 
16834 
class markReturnOrdersAsPickedUp_result:
4910 phani.kuma 16835 
 
16836 
  thrift_spec = (
16837 
  )
16838 
 
16839 
  def read(self, iprot):
16840 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16841 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16842 
      return
16843 
    iprot.readStructBegin()
16844 
    while True:
16845 
      (fname, ftype, fid) = iprot.readFieldBegin()
16846 
      if ftype == TType.STOP:
16847 
        break
16848 
      else:
16849 
        iprot.skip(ftype)
16850 
      iprot.readFieldEnd()
16851 
    iprot.readStructEnd()
16852 
 
16853 
  def write(self, oprot):
16854 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16855 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16856 
      return
16857 
    oprot.writeStructBegin('markReturnOrdersAsPickedUp_result')
16858 
    oprot.writeFieldStop()
16859 
    oprot.writeStructEnd()
16860 
 
16861 
  def validate(self):
16862 
    return
16863 
 
16864 
 
16865 
  def __repr__(self):
16866 
    L = ['%s=%r' % (key, value)
16867 
      for key, value in self.__dict__.iteritems()]
16868 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16869 
 
16870 
  def __eq__(self, other):
16871 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16872 
 
16873 
  def __ne__(self, other):
16874 
    return not (self == other)
16875 
 
16876 
class getReturnOrdersNotPickedUp_args:
4741 phani.kuma 16877 
  """
16878 
  Attributes:
4910 phani.kuma 16879 
   - providerId
16880 
  """
16881 
 
16882 
  thrift_spec = (
16883 
    None, # 0
16884 
    (1, TType.I64, 'providerId', None, None, ), # 1
16885 
  )
16886 
 
16887 
  def __init__(self, providerId=None,):
16888 
    self.providerId = providerId
16889 
 
16890 
  def read(self, iprot):
16891 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16892 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16893 
      return
16894 
    iprot.readStructBegin()
16895 
    while True:
16896 
      (fname, ftype, fid) = iprot.readFieldBegin()
16897 
      if ftype == TType.STOP:
16898 
        break
16899 
      if fid == 1:
16900 
        if ftype == TType.I64:
16901 
          self.providerId = iprot.readI64();
16902 
        else:
16903 
          iprot.skip(ftype)
16904 
      else:
16905 
        iprot.skip(ftype)
16906 
      iprot.readFieldEnd()
16907 
    iprot.readStructEnd()
16908 
 
16909 
  def write(self, oprot):
16910 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16911 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16912 
      return
16913 
    oprot.writeStructBegin('getReturnOrdersNotPickedUp_args')
16914 
    if self.providerId is not None:
16915 
      oprot.writeFieldBegin('providerId', TType.I64, 1)
16916 
      oprot.writeI64(self.providerId)
16917 
      oprot.writeFieldEnd()
16918 
    oprot.writeFieldStop()
16919 
    oprot.writeStructEnd()
16920 
 
16921 
  def validate(self):
16922 
    return
16923 
 
16924 
 
16925 
  def __repr__(self):
16926 
    L = ['%s=%r' % (key, value)
16927 
      for key, value in self.__dict__.iteritems()]
16928 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16929 
 
16930 
  def __eq__(self, other):
16931 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16932 
 
16933 
  def __ne__(self, other):
16934 
    return not (self == other)
16935 
 
16936 
class getReturnOrdersNotPickedUp_result:
16937 
  """
16938 
  Attributes:
4741 phani.kuma 16939 
   - success
16940 
  """
16941 
 
16942 
  thrift_spec = (
16943 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
16944 
  )
16945 
 
16946 
  def __init__(self, success=None,):
16947 
    self.success = success
16948 
 
16949 
  def read(self, iprot):
16950 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16951 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16952 
      return
16953 
    iprot.readStructBegin()
16954 
    while True:
16955 
      (fname, ftype, fid) = iprot.readFieldBegin()
16956 
      if ftype == TType.STOP:
16957 
        break
16958 
      if fid == 0:
16959 
        if ftype == TType.LIST:
16960 
          self.success = []
6000 mandeep.dh 16961 
          (_etype399, _size396) = iprot.readListBegin()
16962 
          for _i400 in xrange(_size396):
16963 
            _elem401 = Order()
16964 
            _elem401.read(iprot)
16965 
            self.success.append(_elem401)
4741 phani.kuma 16966 
          iprot.readListEnd()
16967 
        else:
16968 
          iprot.skip(ftype)
16969 
      else:
16970 
        iprot.skip(ftype)
16971 
      iprot.readFieldEnd()
16972 
    iprot.readStructEnd()
16973 
 
16974 
  def write(self, oprot):
16975 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16976 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16977 
      return
4910 phani.kuma 16978 
    oprot.writeStructBegin('getReturnOrdersNotPickedUp_result')
4741 phani.kuma 16979 
    if self.success is not None:
16980 
      oprot.writeFieldBegin('success', TType.LIST, 0)
16981 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
6000 mandeep.dh 16982 
      for iter402 in self.success:
16983 
        iter402.write(oprot)
4741 phani.kuma 16984 
      oprot.writeListEnd()
16985 
      oprot.writeFieldEnd()
16986 
    oprot.writeFieldStop()
16987 
    oprot.writeStructEnd()
16988 
 
16989 
  def validate(self):
16990 
    return
16991 
 
16992 
 
16993 
  def __repr__(self):
16994 
    L = ['%s=%r' % (key, value)
16995 
      for key, value in self.__dict__.iteritems()]
16996 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16997 
 
16998 
  def __eq__(self, other):
16999 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
17000 
 
17001 
  def __ne__(self, other):
17002 
    return not (self == other)
17003 
 
2616 chandransh 17004 
class receiveReturn_args:
2591 chandransh 17005 
  """
17006 
  Attributes:
17007 
   - orderId
4479 rajveer 17008 
   - receiveCondition
2591 chandransh 17009 
  """
2536 chandransh 17010 
 
2591 chandransh 17011 
  thrift_spec = (
17012 
    None, # 0
17013 
    (1, TType.I64, 'orderId', None, None, ), # 1
4479 rajveer 17014 
    (2, TType.I64, 'receiveCondition', None, None, ), # 2
2591 chandransh 17015 
  )
17016 
 
4479 rajveer 17017 
  def __init__(self, orderId=None, receiveCondition=None,):
2591 chandransh 17018 
    self.orderId = orderId
4479 rajveer 17019 
    self.receiveCondition = receiveCondition
2591 chandransh 17020 
 
17021 
  def read(self, iprot):
17022 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
17023 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
17024 
      return
17025 
    iprot.readStructBegin()
17026 
    while True:
17027 
      (fname, ftype, fid) = iprot.readFieldBegin()
17028 
      if ftype == TType.STOP:
17029 
        break
17030 
      if fid == 1:
17031 
        if ftype == TType.I64:
17032 
          self.orderId = iprot.readI64();
17033 
        else:
17034 
          iprot.skip(ftype)
4479 rajveer 17035 
      elif fid == 2:
17036 
        if ftype == TType.I64:
17037 
          self.receiveCondition = iprot.readI64();
17038 
        else:
17039 
          iprot.skip(ftype)
2591 chandransh 17040 
      else:
17041 
        iprot.skip(ftype)
17042 
      iprot.readFieldEnd()
17043 
    iprot.readStructEnd()
17044 
 
17045 
  def write(self, oprot):
17046 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
17047 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
17048 
      return
2616 chandransh 17049 
    oprot.writeStructBegin('receiveReturn_args')
3431 rajveer 17050 
    if self.orderId is not None:
2591 chandransh 17051 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
17052 
      oprot.writeI64(self.orderId)
17053 
      oprot.writeFieldEnd()
4479 rajveer 17054 
    if self.receiveCondition is not None:
17055 
      oprot.writeFieldBegin('receiveCondition', TType.I64, 2)
17056 
      oprot.writeI64(self.receiveCondition)
17057 
      oprot.writeFieldEnd()
2591 chandransh 17058 
    oprot.writeFieldStop()
17059 
    oprot.writeStructEnd()
17060 
 
3431 rajveer 17061 
  def validate(self):
17062 
    return
17063 
 
17064 
 
2591 chandransh 17065 
  def __repr__(self):
17066 
    L = ['%s=%r' % (key, value)
17067 
      for key, value in self.__dict__.iteritems()]
17068 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
17069 
 
17070 
  def __eq__(self, other):
17071 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
17072 
 
17073 
  def __ne__(self, other):
17074 
    return not (self == other)
17075 
 
2616 chandransh 17076 
class receiveReturn_result:
2591 chandransh 17077 
  """
17078 
  Attributes:
17079 
   - success
17080 
   - ex
17081 
  """
17082 
 
17083 
  thrift_spec = (
17084 
    (0, TType.BOOL, 'success', None, None, ), # 0
17085 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
17086 
  )
17087 
 
17088 
  def __init__(self, success=None, ex=None,):
17089 
    self.success = success
17090 
    self.ex = ex
17091 
 
17092 
  def read(self, iprot):
17093 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
17094 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
17095 
      return
17096 
    iprot.readStructBegin()
17097 
    while True:
17098 
      (fname, ftype, fid) = iprot.readFieldBegin()
17099 
      if ftype == TType.STOP:
17100 
        break
17101 
      if fid == 0:
17102 
        if ftype == TType.BOOL:
17103 
          self.success = iprot.readBool();
17104 
        else:
17105 
          iprot.skip(ftype)
17106 
      elif fid == 1:
17107 
        if ftype == TType.STRUCT:
17108 
          self.ex = TransactionServiceException()
17109 
          self.ex.read(iprot)
17110 
        else:
17111 
          iprot.skip(ftype)
17112 
      else:
17113 
        iprot.skip(ftype)
17114 
      iprot.readFieldEnd()
17115 
    iprot.readStructEnd()
17116 
 
17117 
  def write(self, oprot):
17118 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
17119 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
17120 
      return
2616 chandransh 17121 
    oprot.writeStructBegin('receiveReturn_result')
3431 rajveer 17122 
    if self.success is not None:
2591 chandransh 17123 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
17124 
      oprot.writeBool(self.success)
17125 
      oprot.writeFieldEnd()
3431 rajveer 17126 
    if self.ex is not None:
2591 chandransh 17127 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
17128 
      self.ex.write(oprot)
17129 
      oprot.writeFieldEnd()
17130 
    oprot.writeFieldStop()
17131 
    oprot.writeStructEnd()
17132 
 
3431 rajveer 17133 
  def validate(self):
17134 
    return
17135 
 
17136 
 
2591 chandransh 17137 
  def __repr__(self):
17138 
    L = ['%s=%r' % (key, value)
17139 
      for key, value in self.__dict__.iteritems()]
17140 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
17141 
 
17142 
  def __eq__(self, other):
17143 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
17144 
 
17145 
  def __ne__(self, other):
17146 
    return not (self == other)
17147 
 
17148 
class validateDoa_args:
17149 
  """
17150 
  Attributes:
17151 
   - orderId
17152 
   - isValid
17153 
  """
17154 
 
17155 
  thrift_spec = (
17156 
    None, # 0
17157 
    (1, TType.I64, 'orderId', None, None, ), # 1
17158 
    (2, TType.BOOL, 'isValid', None, None, ), # 2
17159 
  )
17160 
 
17161 
  def __init__(self, orderId=None, isValid=None,):
17162 
    self.orderId = orderId
17163 
    self.isValid = isValid
17164 
 
17165 
  def read(self, iprot):
17166 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
17167 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
17168 
      return
17169 
    iprot.readStructBegin()
17170 
    while True:
17171 
      (fname, ftype, fid) = iprot.readFieldBegin()
17172 
      if ftype == TType.STOP:
17173 
        break
17174 
      if fid == 1:
17175 
        if ftype == TType.I64:
17176 
          self.orderId = iprot.readI64();
17177 
        else:
17178 
          iprot.skip(ftype)
17179 
      elif fid == 2:
17180 
        if ftype == TType.BOOL:
17181 
          self.isValid = iprot.readBool();
17182 
        else:
17183 
          iprot.skip(ftype)
17184 
      else:
17185 
        iprot.skip(ftype)
17186 
      iprot.readFieldEnd()
17187 
    iprot.readStructEnd()
17188 
 
17189 
  def write(self, oprot):
17190 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
17191 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
17192 
      return
17193 
    oprot.writeStructBegin('validateDoa_args')
3431 rajveer 17194 
    if self.orderId is not None:
2591 chandransh 17195 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
17196 
      oprot.writeI64(self.orderId)
17197 
      oprot.writeFieldEnd()
3431 rajveer 17198 
    if self.isValid is not None:
2591 chandransh 17199 
      oprot.writeFieldBegin('isValid', TType.BOOL, 2)
17200 
      oprot.writeBool(self.isValid)
17201 
      oprot.writeFieldEnd()
17202 
    oprot.writeFieldStop()
17203 
    oprot.writeStructEnd()
17204 
 
3431 rajveer 17205 
  def validate(self):
17206 
    return
17207 
 
17208 
 
2591 chandransh 17209 
  def __repr__(self):
17210 
    L = ['%s=%r' % (key, value)
17211 
      for key, value in self.__dict__.iteritems()]
17212 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
17213 
 
17214 
  def __eq__(self, other):
17215 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
17216 
 
17217 
  def __ne__(self, other):
17218 
    return not (self == other)
17219 
 
17220 
class validateDoa_result:
17221 
  """
17222 
  Attributes:
17223 
   - success
17224 
   - ex
17225 
  """
17226 
 
17227 
  thrift_spec = (
17228 
    (0, TType.BOOL, 'success', None, None, ), # 0
17229 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
17230 
  )
17231 
 
17232 
  def __init__(self, success=None, ex=None,):
17233 
    self.success = success
17234 
    self.ex = ex
17235 
 
17236 
  def read(self, iprot):
17237 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
17238 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
17239 
      return
17240 
    iprot.readStructBegin()
17241 
    while True:
17242 
      (fname, ftype, fid) = iprot.readFieldBegin()
17243 
      if ftype == TType.STOP:
17244 
        break
17245 
      if fid == 0:
17246 
        if ftype == TType.BOOL:
17247 
          self.success = iprot.readBool();
17248 
        else:
17249 
          iprot.skip(ftype)
17250 
      elif fid == 1:
17251 
        if ftype == TType.STRUCT:
17252 
          self.ex = TransactionServiceException()
17253 
          self.ex.read(iprot)
17254 
        else:
17255 
          iprot.skip(ftype)
17256 
      else:
17257 
        iprot.skip(ftype)
17258 
      iprot.readFieldEnd()
17259 
    iprot.readStructEnd()
17260 
 
17261 
  def write(self, oprot):
17262 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
17263 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
17264 
      return
17265 
    oprot.writeStructBegin('validateDoa_result')
3431 rajveer 17266 
    if self.success is not None:
2591 chandransh 17267 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
17268 
      oprot.writeBool(self.success)
17269 
      oprot.writeFieldEnd()
3431 rajveer 17270 
    if self.ex is not None:
2591 chandransh 17271 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
17272 
      self.ex.write(oprot)
17273 
      oprot.writeFieldEnd()
17274 
    oprot.writeFieldStop()
17275 
    oprot.writeStructEnd()
17276 
 
3431 rajveer 17277 
  def validate(self):
17278 
    return
17279 
 
17280 
 
2591 chandransh 17281 
  def __repr__(self):
17282 
    L = ['%s=%r' % (key, value)
17283 
      for key, value in self.__dict__.iteritems()]
17284 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
17285 
 
17286 
  def __eq__(self, other):
17287 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
17288 
 
17289 
  def __ne__(self, other):
17290 
    return not (self == other)
17291 
 
4495 rajveer 17292 
class validateReturnProduct_args:
17293 
  """
17294 
  Attributes:
17295 
   - orderId
17296 
   - isUsable
17297 
  """
17298 
 
17299 
  thrift_spec = (
17300 
    None, # 0
17301 
    (1, TType.I64, 'orderId', None, None, ), # 1
17302 
    (2, TType.BOOL, 'isUsable', None, None, ), # 2
17303 
  )
17304 
 
17305 
  def __init__(self, orderId=None, isUsable=None,):
17306 
    self.orderId = orderId
17307 
    self.isUsable = isUsable
17308 
 
17309 
  def read(self, iprot):
17310 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
17311 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
17312 
      return
17313 
    iprot.readStructBegin()
17314 
    while True:
17315 
      (fname, ftype, fid) = iprot.readFieldBegin()
17316 
      if ftype == TType.STOP:
17317 
        break
17318 
      if fid == 1:
17319 
        if ftype == TType.I64:
17320 
          self.orderId = iprot.readI64();
17321 
        else:
17322 
          iprot.skip(ftype)
17323 
      elif fid == 2:
17324 
        if ftype == TType.BOOL:
17325 
          self.isUsable = iprot.readBool();
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('validateReturnProduct_args')
17338 
    if self.orderId is not None:
17339 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
17340 
      oprot.writeI64(self.orderId)
17341 
      oprot.writeFieldEnd()
17342 
    if self.isUsable is not None:
17343 
      oprot.writeFieldBegin('isUsable', TType.BOOL, 2)
17344 
      oprot.writeBool(self.isUsable)
17345 
      oprot.writeFieldEnd()
17346 
    oprot.writeFieldStop()
17347 
    oprot.writeStructEnd()
17348 
 
17349 
  def validate(self):
17350 
    return
17351 
 
17352 
 
17353 
  def __repr__(self):
17354 
    L = ['%s=%r' % (key, value)
17355 
      for key, value in self.__dict__.iteritems()]
17356 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
17357 
 
17358 
  def __eq__(self, other):
17359 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
17360 
 
17361 
  def __ne__(self, other):
17362 
    return not (self == other)
17363 
 
17364 
class validateReturnProduct_result:
17365 
  """
17366 
  Attributes:
17367 
   - success
17368 
   - ex
17369 
  """
17370 
 
17371 
  thrift_spec = (
17372 
    (0, TType.BOOL, 'success', None, None, ), # 0
17373 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
17374 
  )
17375 
 
17376 
  def __init__(self, success=None, ex=None,):
17377 
    self.success = success
17378 
    self.ex = ex
17379 
 
17380 
  def read(self, iprot):
17381 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
17382 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
17383 
      return
17384 
    iprot.readStructBegin()
17385 
    while True:
17386 
      (fname, ftype, fid) = iprot.readFieldBegin()
17387 
      if ftype == TType.STOP:
17388 
        break
17389 
      if fid == 0:
17390 
        if ftype == TType.BOOL:
17391 
          self.success = iprot.readBool();
17392 
        else:
17393 
          iprot.skip(ftype)
17394 
      elif fid == 1:
17395 
        if ftype == TType.STRUCT:
17396 
          self.ex = TransactionServiceException()
17397 
          self.ex.read(iprot)
17398 
        else:
17399 
          iprot.skip(ftype)
17400 
      else:
17401 
        iprot.skip(ftype)
17402 
      iprot.readFieldEnd()
17403 
    iprot.readStructEnd()
17404 
 
17405 
  def write(self, oprot):
17406 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
17407 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
17408 
      return
17409 
    oprot.writeStructBegin('validateReturnProduct_result')
17410 
    if self.success is not None:
17411 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
17412 
      oprot.writeBool(self.success)
17413 
      oprot.writeFieldEnd()
17414 
    if self.ex is not None:
17415 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
17416 
      self.ex.write(oprot)
17417 
      oprot.writeFieldEnd()
17418 
    oprot.writeFieldStop()
17419 
    oprot.writeStructEnd()
17420 
 
17421 
  def validate(self):
17422 
    return
17423 
 
17424 
 
17425 
  def __repr__(self):
17426 
    L = ['%s=%r' % (key, value)
17427 
      for key, value in self.__dict__.iteritems()]
17428 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
17429 
 
17430 
  def __eq__(self, other):
17431 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
17432 
 
17433 
  def __ne__(self, other):
17434 
    return not (self == other)
17435 
 
2616 chandransh 17436 
class reshipOrder_args:
17437 
  """
17438 
  Attributes:
17439 
   - orderId
17440 
  """
2591 chandransh 17441 
 
2616 chandransh 17442 
  thrift_spec = (
17443 
    None, # 0
17444 
    (1, TType.I64, 'orderId', None, None, ), # 1
17445 
  )
17446 
 
17447 
  def __init__(self, orderId=None,):
17448 
    self.orderId = orderId
17449 
 
17450 
  def read(self, iprot):
17451 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
17452 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
17453 
      return
17454 
    iprot.readStructBegin()
17455 
    while True:
17456 
      (fname, ftype, fid) = iprot.readFieldBegin()
17457 
      if ftype == TType.STOP:
17458 
        break
17459 
      if fid == 1:
17460 
        if ftype == TType.I64:
17461 
          self.orderId = iprot.readI64();
17462 
        else:
17463 
          iprot.skip(ftype)
17464 
      else:
17465 
        iprot.skip(ftype)
17466 
      iprot.readFieldEnd()
17467 
    iprot.readStructEnd()
17468 
 
17469 
  def write(self, oprot):
17470 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
17471 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
17472 
      return
17473 
    oprot.writeStructBegin('reshipOrder_args')
3431 rajveer 17474 
    if self.orderId is not None:
2616 chandransh 17475 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
17476 
      oprot.writeI64(self.orderId)
17477 
      oprot.writeFieldEnd()
17478 
    oprot.writeFieldStop()
17479 
    oprot.writeStructEnd()
17480 
 
3431 rajveer 17481 
  def validate(self):
17482 
    return
17483 
 
17484 
 
2616 chandransh 17485 
  def __repr__(self):
17486 
    L = ['%s=%r' % (key, value)
17487 
      for key, value in self.__dict__.iteritems()]
17488 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
17489 
 
17490 
  def __eq__(self, other):
17491 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
17492 
 
17493 
  def __ne__(self, other):
17494 
    return not (self == other)
17495 
 
17496 
class reshipOrder_result:
17497 
  """
17498 
  Attributes:
17499 
   - success
17500 
   - ex
17501 
  """
17502 
 
17503 
  thrift_spec = (
17504 
    (0, TType.I64, 'success', None, None, ), # 0
17505 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
17506 
  )
17507 
 
17508 
  def __init__(self, success=None, ex=None,):
17509 
    self.success = success
17510 
    self.ex = ex
17511 
 
17512 
  def read(self, iprot):
17513 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
17514 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
17515 
      return
17516 
    iprot.readStructBegin()
17517 
    while True:
17518 
      (fname, ftype, fid) = iprot.readFieldBegin()
17519 
      if ftype == TType.STOP:
17520 
        break
17521 
      if fid == 0:
17522 
        if ftype == TType.I64:
17523 
          self.success = iprot.readI64();
17524 
        else:
17525 
          iprot.skip(ftype)
17526 
      elif fid == 1:
17527 
        if ftype == TType.STRUCT:
17528 
          self.ex = TransactionServiceException()
17529 
          self.ex.read(iprot)
17530 
        else:
17531 
          iprot.skip(ftype)
17532 
      else:
17533 
        iprot.skip(ftype)
17534 
      iprot.readFieldEnd()
17535 
    iprot.readStructEnd()
17536 
 
17537 
  def write(self, oprot):
17538 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
17539 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
17540 
      return
17541 
    oprot.writeStructBegin('reshipOrder_result')
3431 rajveer 17542 
    if self.success is not None:
2616 chandransh 17543 
      oprot.writeFieldBegin('success', TType.I64, 0)
17544 
      oprot.writeI64(self.success)
17545 
      oprot.writeFieldEnd()
3431 rajveer 17546 
    if self.ex is not None:
2616 chandransh 17547 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
17548 
      self.ex.write(oprot)
17549 
      oprot.writeFieldEnd()
17550 
    oprot.writeFieldStop()
17551 
    oprot.writeStructEnd()
17552 
 
3431 rajveer 17553 
  def validate(self):
17554 
    return
17555 
 
17556 
 
2616 chandransh 17557 
  def __repr__(self):
17558 
    L = ['%s=%r' % (key, value)
17559 
      for key, value in self.__dict__.iteritems()]
17560 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
17561 
 
17562 
  def __eq__(self, other):
17563 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
17564 
 
17565 
  def __ne__(self, other):
17566 
    return not (self == other)
17567 
 
17568 
class refundOrder_args:
17569 
  """
17570 
  Attributes:
17571 
   - orderId
3226 chandransh 17572 
   - refundedBy
17573 
   - reason
2616 chandransh 17574 
  """
17575 
 
17576 
  thrift_spec = (
17577 
    None, # 0
17578 
    (1, TType.I64, 'orderId', None, None, ), # 1
3226 chandransh 17579 
    (2, TType.STRING, 'refundedBy', None, None, ), # 2
17580 
    (3, TType.STRING, 'reason', None, None, ), # 3
2616 chandransh 17581 
  )
17582 
 
3226 chandransh 17583 
  def __init__(self, orderId=None, refundedBy=None, reason=None,):
2616 chandransh 17584 
    self.orderId = orderId
3226 chandransh 17585 
    self.refundedBy = refundedBy
17586 
    self.reason = reason
2616 chandransh 17587 
 
17588 
  def read(self, iprot):
17589 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
17590 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
17591 
      return
17592 
    iprot.readStructBegin()
17593 
    while True:
17594 
      (fname, ftype, fid) = iprot.readFieldBegin()
17595 
      if ftype == TType.STOP:
17596 
        break
17597 
      if fid == 1:
17598 
        if ftype == TType.I64:
17599 
          self.orderId = iprot.readI64();
17600 
        else:
17601 
          iprot.skip(ftype)
3226 chandransh 17602 
      elif fid == 2:
17603 
        if ftype == TType.STRING:
17604 
          self.refundedBy = iprot.readString();
17605 
        else:
17606 
          iprot.skip(ftype)
17607 
      elif fid == 3:
17608 
        if ftype == TType.STRING:
17609 
          self.reason = iprot.readString();
17610 
        else:
17611 
          iprot.skip(ftype)
2616 chandransh 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('refundOrder_args')
3431 rajveer 17622 
    if self.orderId is not None:
2616 chandransh 17623 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
17624 
      oprot.writeI64(self.orderId)
17625 
      oprot.writeFieldEnd()
3431 rajveer 17626 
    if self.refundedBy is not None:
3226 chandransh 17627 
      oprot.writeFieldBegin('refundedBy', TType.STRING, 2)
17628 
      oprot.writeString(self.refundedBy)
17629 
      oprot.writeFieldEnd()
3431 rajveer 17630 
    if self.reason is not None:
3226 chandransh 17631 
      oprot.writeFieldBegin('reason', TType.STRING, 3)
17632 
      oprot.writeString(self.reason)
17633 
      oprot.writeFieldEnd()
2616 chandransh 17634 
    oprot.writeFieldStop()
17635 
    oprot.writeStructEnd()
17636 
 
3431 rajveer 17637 
  def validate(self):
17638 
    return
17639 
 
17640 
 
2616 chandransh 17641 
  def __repr__(self):
17642 
    L = ['%s=%r' % (key, value)
17643 
      for key, value in self.__dict__.iteritems()]
17644 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
17645 
 
17646 
  def __eq__(self, other):
17647 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
17648 
 
17649 
  def __ne__(self, other):
17650 
    return not (self == other)
17651 
 
17652 
class refundOrder_result:
17653 
  """
17654 
  Attributes:
17655 
   - success
17656 
   - ex
17657 
  """
17658 
 
17659 
  thrift_spec = (
17660 
    (0, TType.BOOL, 'success', None, None, ), # 0
17661 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
17662 
  )
17663 
 
17664 
  def __init__(self, success=None, ex=None,):
17665 
    self.success = success
17666 
    self.ex = ex
17667 
 
17668 
  def read(self, iprot):
17669 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
17670 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
17671 
      return
17672 
    iprot.readStructBegin()
17673 
    while True:
17674 
      (fname, ftype, fid) = iprot.readFieldBegin()
17675 
      if ftype == TType.STOP:
17676 
        break
17677 
      if fid == 0:
17678 
        if ftype == TType.BOOL:
17679 
          self.success = iprot.readBool();
17680 
        else:
17681 
          iprot.skip(ftype)
17682 
      elif fid == 1:
17683 
        if ftype == TType.STRUCT:
17684 
          self.ex = TransactionServiceException()
17685 
          self.ex.read(iprot)
17686 
        else:
17687 
          iprot.skip(ftype)
17688 
      else:
17689 
        iprot.skip(ftype)
17690 
      iprot.readFieldEnd()
17691 
    iprot.readStructEnd()
17692 
 
17693 
  def write(self, oprot):
17694 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
17695 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
17696 
      return
17697 
    oprot.writeStructBegin('refundOrder_result')
3431 rajveer 17698 
    if self.success is not None:
2616 chandransh 17699 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
17700 
      oprot.writeBool(self.success)
17701 
      oprot.writeFieldEnd()
3431 rajveer 17702 
    if self.ex is not None:
2616 chandransh 17703 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
17704 
      self.ex.write(oprot)
17705 
      oprot.writeFieldEnd()
17706 
    oprot.writeFieldStop()
17707 
    oprot.writeStructEnd()
17708 
 
3431 rajveer 17709 
  def validate(self):
17710 
    return
17711 
 
17712 
 
2616 chandransh 17713 
  def __repr__(self):
17714 
    L = ['%s=%r' % (key, value)
17715 
      for key, value in self.__dict__.iteritems()]
17716 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
17717 
 
17718 
  def __eq__(self, other):
17719 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
17720 
 
17721 
  def __ne__(self, other):
17722 
    return not (self == other)
17723 
 
2690 chandransh 17724 
class getReturnOrders_args:
17725 
  """
17726 
  Attributes:
17727 
   - warehouseId
17728 
   - fromDate
17729 
   - toDate
17730 
  """
2616 chandransh 17731 
 
2690 chandransh 17732 
  thrift_spec = (
17733 
    None, # 0
17734 
    (1, TType.I64, 'warehouseId', None, None, ), # 1
17735 
    (2, TType.I64, 'fromDate', None, None, ), # 2
17736 
    (3, TType.I64, 'toDate', None, None, ), # 3
17737 
  )
17738 
 
17739 
  def __init__(self, warehouseId=None, fromDate=None, toDate=None,):
17740 
    self.warehouseId = warehouseId
17741 
    self.fromDate = fromDate
17742 
    self.toDate = toDate
17743 
 
17744 
  def read(self, iprot):
17745 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
17746 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
17747 
      return
17748 
    iprot.readStructBegin()
17749 
    while True:
17750 
      (fname, ftype, fid) = iprot.readFieldBegin()
17751 
      if ftype == TType.STOP:
17752 
        break
17753 
      if fid == 1:
17754 
        if ftype == TType.I64:
17755 
          self.warehouseId = iprot.readI64();
17756 
        else:
17757 
          iprot.skip(ftype)
17758 
      elif fid == 2:
17759 
        if ftype == TType.I64:
17760 
          self.fromDate = iprot.readI64();
17761 
        else:
17762 
          iprot.skip(ftype)
17763 
      elif fid == 3:
17764 
        if ftype == TType.I64:
17765 
          self.toDate = iprot.readI64();
17766 
        else:
17767 
          iprot.skip(ftype)
17768 
      else:
17769 
        iprot.skip(ftype)
17770 
      iprot.readFieldEnd()
17771 
    iprot.readStructEnd()
17772 
 
17773 
  def write(self, oprot):
17774 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
17775 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
17776 
      return
17777 
    oprot.writeStructBegin('getReturnOrders_args')
3431 rajveer 17778 
    if self.warehouseId is not None:
2690 chandransh 17779 
      oprot.writeFieldBegin('warehouseId', TType.I64, 1)
17780 
      oprot.writeI64(self.warehouseId)
17781 
      oprot.writeFieldEnd()
3431 rajveer 17782 
    if self.fromDate is not None:
2690 chandransh 17783 
      oprot.writeFieldBegin('fromDate', TType.I64, 2)
17784 
      oprot.writeI64(self.fromDate)
17785 
      oprot.writeFieldEnd()
3431 rajveer 17786 
    if self.toDate is not None:
2690 chandransh 17787 
      oprot.writeFieldBegin('toDate', TType.I64, 3)
17788 
      oprot.writeI64(self.toDate)
17789 
      oprot.writeFieldEnd()
17790 
    oprot.writeFieldStop()
17791 
    oprot.writeStructEnd()
17792 
 
3431 rajveer 17793 
  def validate(self):
17794 
    return
17795 
 
17796 
 
2690 chandransh 17797 
  def __repr__(self):
17798 
    L = ['%s=%r' % (key, value)
17799 
      for key, value in self.__dict__.iteritems()]
17800 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
17801 
 
17802 
  def __eq__(self, other):
17803 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
17804 
 
17805 
  def __ne__(self, other):
17806 
    return not (self == other)
17807 
 
17808 
class getReturnOrders_result:
17809 
  """
17810 
  Attributes:
17811 
   - success
17812 
  """
17813 
 
17814 
  thrift_spec = (
17815 
    (0, TType.LIST, 'success', (TType.STRUCT,(ReturnOrder, ReturnOrder.thrift_spec)), None, ), # 0
17816 
  )
17817 
 
17818 
  def __init__(self, success=None,):
17819 
    self.success = success
17820 
 
17821 
  def read(self, iprot):
17822 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
17823 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
17824 
      return
17825 
    iprot.readStructBegin()
17826 
    while True:
17827 
      (fname, ftype, fid) = iprot.readFieldBegin()
17828 
      if ftype == TType.STOP:
17829 
        break
17830 
      if fid == 0:
17831 
        if ftype == TType.LIST:
17832 
          self.success = []
6000 mandeep.dh 17833 
          (_etype406, _size403) = iprot.readListBegin()
17834 
          for _i407 in xrange(_size403):
17835 
            _elem408 = ReturnOrder()
17836 
            _elem408.read(iprot)
17837 
            self.success.append(_elem408)
2690 chandransh 17838 
          iprot.readListEnd()
17839 
        else:
17840 
          iprot.skip(ftype)
17841 
      else:
17842 
        iprot.skip(ftype)
17843 
      iprot.readFieldEnd()
17844 
    iprot.readStructEnd()
17845 
 
17846 
  def write(self, oprot):
17847 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
17848 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
17849 
      return
17850 
    oprot.writeStructBegin('getReturnOrders_result')
3431 rajveer 17851 
    if self.success is not None:
2690 chandransh 17852 
      oprot.writeFieldBegin('success', TType.LIST, 0)
17853 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
6000 mandeep.dh 17854 
      for iter409 in self.success:
17855 
        iter409.write(oprot)
2690 chandransh 17856 
      oprot.writeListEnd()
17857 
      oprot.writeFieldEnd()
17858 
    oprot.writeFieldStop()
17859 
    oprot.writeStructEnd()
17860 
 
3431 rajveer 17861 
  def validate(self):
17862 
    return
17863 
 
17864 
 
2690 chandransh 17865 
  def __repr__(self):
17866 
    L = ['%s=%r' % (key, value)
17867 
      for key, value in self.__dict__.iteritems()]
17868 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
17869 
 
17870 
  def __eq__(self, other):
17871 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
17872 
 
17873 
  def __ne__(self, other):
17874 
    return not (self == other)
17875 
 
5481 phani.kuma 17876 
class getAllReturnOrders_args:
17877 
  """
17878 
  Attributes:
17879 
   - onlyNotProcessed
17880 
   - fromDate
17881 
   - toDate
17882 
  """
17883 
 
17884 
  thrift_spec = (
17885 
    None, # 0
17886 
    (1, TType.BOOL, 'onlyNotProcessed', None, None, ), # 1
17887 
    (2, TType.I64, 'fromDate', None, None, ), # 2
17888 
    (3, TType.I64, 'toDate', None, None, ), # 3
17889 
  )
17890 
 
17891 
  def __init__(self, onlyNotProcessed=None, fromDate=None, toDate=None,):
17892 
    self.onlyNotProcessed = onlyNotProcessed
17893 
    self.fromDate = fromDate
17894 
    self.toDate = toDate
17895 
 
17896 
  def read(self, iprot):
17897 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
17898 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
17899 
      return
17900 
    iprot.readStructBegin()
17901 
    while True:
17902 
      (fname, ftype, fid) = iprot.readFieldBegin()
17903 
      if ftype == TType.STOP:
17904 
        break
17905 
      if fid == 1:
17906 
        if ftype == TType.BOOL:
17907 
          self.onlyNotProcessed = iprot.readBool();
17908 
        else:
17909 
          iprot.skip(ftype)
17910 
      elif fid == 2:
17911 
        if ftype == TType.I64:
17912 
          self.fromDate = iprot.readI64();
17913 
        else:
17914 
          iprot.skip(ftype)
17915 
      elif fid == 3:
17916 
        if ftype == TType.I64:
17917 
          self.toDate = iprot.readI64();
17918 
        else:
17919 
          iprot.skip(ftype)
17920 
      else:
17921 
        iprot.skip(ftype)
17922 
      iprot.readFieldEnd()
17923 
    iprot.readStructEnd()
17924 
 
17925 
  def write(self, oprot):
17926 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
17927 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
17928 
      return
17929 
    oprot.writeStructBegin('getAllReturnOrders_args')
17930 
    if self.onlyNotProcessed is not None:
17931 
      oprot.writeFieldBegin('onlyNotProcessed', TType.BOOL, 1)
17932 
      oprot.writeBool(self.onlyNotProcessed)
17933 
      oprot.writeFieldEnd()
17934 
    if self.fromDate is not None:
17935 
      oprot.writeFieldBegin('fromDate', TType.I64, 2)
17936 
      oprot.writeI64(self.fromDate)
17937 
      oprot.writeFieldEnd()
17938 
    if self.toDate is not None:
17939 
      oprot.writeFieldBegin('toDate', TType.I64, 3)
17940 
      oprot.writeI64(self.toDate)
17941 
      oprot.writeFieldEnd()
17942 
    oprot.writeFieldStop()
17943 
    oprot.writeStructEnd()
17944 
 
17945 
  def validate(self):
17946 
    return
17947 
 
17948 
 
17949 
  def __repr__(self):
17950 
    L = ['%s=%r' % (key, value)
17951 
      for key, value in self.__dict__.iteritems()]
17952 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
17953 
 
17954 
  def __eq__(self, other):
17955 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
17956 
 
17957 
  def __ne__(self, other):
17958 
    return not (self == other)
17959 
 
17960 
class getAllReturnOrders_result:
17961 
  """
17962 
  Attributes:
17963 
   - success
17964 
  """
17965 
 
17966 
  thrift_spec = (
17967 
    (0, TType.LIST, 'success', (TType.STRUCT,(ReturnOrder, ReturnOrder.thrift_spec)), None, ), # 0
17968 
  )
17969 
 
17970 
  def __init__(self, success=None,):
17971 
    self.success = success
17972 
 
17973 
  def read(self, iprot):
17974 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
17975 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
17976 
      return
17977 
    iprot.readStructBegin()
17978 
    while True:
17979 
      (fname, ftype, fid) = iprot.readFieldBegin()
17980 
      if ftype == TType.STOP:
17981 
        break
17982 
      if fid == 0:
17983 
        if ftype == TType.LIST:
17984 
          self.success = []
6000 mandeep.dh 17985 
          (_etype413, _size410) = iprot.readListBegin()
17986 
          for _i414 in xrange(_size410):
17987 
            _elem415 = ReturnOrder()
17988 
            _elem415.read(iprot)
17989 
            self.success.append(_elem415)
5481 phani.kuma 17990 
          iprot.readListEnd()
17991 
        else:
17992 
          iprot.skip(ftype)
17993 
      else:
17994 
        iprot.skip(ftype)
17995 
      iprot.readFieldEnd()
17996 
    iprot.readStructEnd()
17997 
 
17998 
  def write(self, oprot):
17999 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
18000 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
18001 
      return
18002 
    oprot.writeStructBegin('getAllReturnOrders_result')
18003 
    if self.success is not None:
18004 
      oprot.writeFieldBegin('success', TType.LIST, 0)
18005 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
6000 mandeep.dh 18006 
      for iter416 in self.success:
18007 
        iter416.write(oprot)
5481 phani.kuma 18008 
      oprot.writeListEnd()
18009 
      oprot.writeFieldEnd()
18010 
    oprot.writeFieldStop()
18011 
    oprot.writeStructEnd()
18012 
 
18013 
  def validate(self):
18014 
    return
18015 
 
18016 
 
18017 
  def __repr__(self):
18018 
    L = ['%s=%r' % (key, value)
18019 
      for key, value in self.__dict__.iteritems()]
18020 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
18021 
 
18022 
  def __eq__(self, other):
18023 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
18024 
 
18025 
  def __ne__(self, other):
18026 
    return not (self == other)
18027 
 
2700 chandransh 18028 
class getReturnOrder_args:
18029 
  """
18030 
  Attributes:
18031 
   - id
18032 
  """
18033 
 
18034 
  thrift_spec = (
18035 
    None, # 0
18036 
    (1, TType.I64, 'id', None, None, ), # 1
18037 
  )
18038 
 
18039 
  def __init__(self, id=None,):
18040 
    self.id = id
18041 
 
18042 
  def read(self, iprot):
18043 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
18044 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
18045 
      return
18046 
    iprot.readStructBegin()
18047 
    while True:
18048 
      (fname, ftype, fid) = iprot.readFieldBegin()
18049 
      if ftype == TType.STOP:
18050 
        break
18051 
      if fid == 1:
18052 
        if ftype == TType.I64:
18053 
          self.id = iprot.readI64();
18054 
        else:
18055 
          iprot.skip(ftype)
18056 
      else:
18057 
        iprot.skip(ftype)
18058 
      iprot.readFieldEnd()
18059 
    iprot.readStructEnd()
18060 
 
18061 
  def write(self, oprot):
18062 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
18063 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
18064 
      return
18065 
    oprot.writeStructBegin('getReturnOrder_args')
3431 rajveer 18066 
    if self.id is not None:
2700 chandransh 18067 
      oprot.writeFieldBegin('id', TType.I64, 1)
18068 
      oprot.writeI64(self.id)
18069 
      oprot.writeFieldEnd()
18070 
    oprot.writeFieldStop()
18071 
    oprot.writeStructEnd()
18072 
 
3431 rajveer 18073 
  def validate(self):
18074 
    return
18075 
 
18076 
 
2700 chandransh 18077 
  def __repr__(self):
18078 
    L = ['%s=%r' % (key, value)
18079 
      for key, value in self.__dict__.iteritems()]
18080 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
18081 
 
18082 
  def __eq__(self, other):
18083 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
18084 
 
18085 
  def __ne__(self, other):
18086 
    return not (self == other)
18087 
 
18088 
class getReturnOrder_result:
18089 
  """
18090 
  Attributes:
18091 
   - success
18092 
   - ex
18093 
  """
18094 
 
18095 
  thrift_spec = (
18096 
    (0, TType.STRUCT, 'success', (ReturnOrder, ReturnOrder.thrift_spec), None, ), # 0
18097 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
18098 
  )
18099 
 
18100 
  def __init__(self, success=None, ex=None,):
18101 
    self.success = success
18102 
    self.ex = ex
18103 
 
18104 
  def read(self, iprot):
18105 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
18106 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
18107 
      return
18108 
    iprot.readStructBegin()
18109 
    while True:
18110 
      (fname, ftype, fid) = iprot.readFieldBegin()
18111 
      if ftype == TType.STOP:
18112 
        break
18113 
      if fid == 0:
18114 
        if ftype == TType.STRUCT:
18115 
          self.success = ReturnOrder()
18116 
          self.success.read(iprot)
18117 
        else:
18118 
          iprot.skip(ftype)
18119 
      elif fid == 1:
18120 
        if ftype == TType.STRUCT:
18121 
          self.ex = TransactionServiceException()
18122 
          self.ex.read(iprot)
18123 
        else:
18124 
          iprot.skip(ftype)
18125 
      else:
18126 
        iprot.skip(ftype)
18127 
      iprot.readFieldEnd()
18128 
    iprot.readStructEnd()
18129 
 
18130 
  def write(self, oprot):
18131 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
18132 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
18133 
      return
18134 
    oprot.writeStructBegin('getReturnOrder_result')
3431 rajveer 18135 
    if self.success is not None:
2700 chandransh 18136 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
18137 
      self.success.write(oprot)
18138 
      oprot.writeFieldEnd()
3431 rajveer 18139 
    if self.ex is not None:
2700 chandransh 18140 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
18141 
      self.ex.write(oprot)
18142 
      oprot.writeFieldEnd()
18143 
    oprot.writeFieldStop()
18144 
    oprot.writeStructEnd()
18145 
 
3431 rajveer 18146 
  def validate(self):
18147 
    return
18148 
 
18149 
 
2700 chandransh 18150 
  def __repr__(self):
18151 
    L = ['%s=%r' % (key, value)
18152 
      for key, value in self.__dict__.iteritems()]
18153 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
18154 
 
18155 
  def __eq__(self, other):
18156 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
18157 
 
18158 
  def __ne__(self, other):
18159 
    return not (self == other)
18160 
 
2690 chandransh 18161 
class processReturn_args:
18162 
  """
18163 
  Attributes:
18164 
   - returnOrderId
18165 
  """
18166 
 
18167 
  thrift_spec = (
18168 
    None, # 0
18169 
    (1, TType.I64, 'returnOrderId', None, None, ), # 1
18170 
  )
18171 
 
18172 
  def __init__(self, returnOrderId=None,):
18173 
    self.returnOrderId = returnOrderId
18174 
 
18175 
  def read(self, iprot):
18176 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
18177 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
18178 
      return
18179 
    iprot.readStructBegin()
18180 
    while True:
18181 
      (fname, ftype, fid) = iprot.readFieldBegin()
18182 
      if ftype == TType.STOP:
18183 
        break
18184 
      if fid == 1:
18185 
        if ftype == TType.I64:
18186 
          self.returnOrderId = iprot.readI64();
18187 
        else:
18188 
          iprot.skip(ftype)
18189 
      else:
18190 
        iprot.skip(ftype)
18191 
      iprot.readFieldEnd()
18192 
    iprot.readStructEnd()
18193 
 
18194 
  def write(self, oprot):
18195 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
18196 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
18197 
      return
18198 
    oprot.writeStructBegin('processReturn_args')
3431 rajveer 18199 
    if self.returnOrderId is not None:
2690 chandransh 18200 
      oprot.writeFieldBegin('returnOrderId', TType.I64, 1)
18201 
      oprot.writeI64(self.returnOrderId)
18202 
      oprot.writeFieldEnd()
18203 
    oprot.writeFieldStop()
18204 
    oprot.writeStructEnd()
18205 
 
3431 rajveer 18206 
  def validate(self):
18207 
    return
18208 
 
18209 
 
2690 chandransh 18210 
  def __repr__(self):
18211 
    L = ['%s=%r' % (key, value)
18212 
      for key, value in self.__dict__.iteritems()]
18213 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
18214 
 
18215 
  def __eq__(self, other):
18216 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
18217 
 
18218 
  def __ne__(self, other):
18219 
    return not (self == other)
18220 
 
18221 
class processReturn_result:
18222 
  """
18223 
  Attributes:
18224 
   - ex
18225 
  """
18226 
 
18227 
  thrift_spec = (
18228 
    None, # 0
18229 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
18230 
  )
18231 
 
18232 
  def __init__(self, ex=None,):
18233 
    self.ex = ex
18234 
 
18235 
  def read(self, iprot):
18236 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
18237 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
18238 
      return
18239 
    iprot.readStructBegin()
18240 
    while True:
18241 
      (fname, ftype, fid) = iprot.readFieldBegin()
18242 
      if ftype == TType.STOP:
18243 
        break
18244 
      if fid == 1:
18245 
        if ftype == TType.STRUCT:
18246 
          self.ex = TransactionServiceException()
18247 
          self.ex.read(iprot)
18248 
        else:
18249 
          iprot.skip(ftype)
18250 
      else:
18251 
        iprot.skip(ftype)
18252 
      iprot.readFieldEnd()
18253 
    iprot.readStructEnd()
18254 
 
18255 
  def write(self, oprot):
18256 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
18257 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
18258 
      return
18259 
    oprot.writeStructBegin('processReturn_result')
3431 rajveer 18260 
    if self.ex is not None:
2690 chandransh 18261 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
18262 
      self.ex.write(oprot)
18263 
      oprot.writeFieldEnd()
18264 
    oprot.writeFieldStop()
18265 
    oprot.writeStructEnd()
18266 
 
3431 rajveer 18267 
  def validate(self):
18268 
    return
18269 
 
18270 
 
2690 chandransh 18271 
  def __repr__(self):
18272 
    L = ['%s=%r' % (key, value)
18273 
      for key, value in self.__dict__.iteritems()]
18274 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
18275 
 
18276 
  def __eq__(self, other):
18277 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
18278 
 
18279 
  def __ne__(self, other):
18280 
    return not (self == other)
18281 
 
3451 chandransh 18282 
class updateWeight_args:
18283 
  """
18284 
  Attributes:
18285 
   - orderId
18286 
   - weight
18287 
  """
18288 
 
18289 
  thrift_spec = (
18290 
    None, # 0
18291 
    (1, TType.I64, 'orderId', None, None, ), # 1
18292 
    (2, TType.DOUBLE, 'weight', None, None, ), # 2
18293 
  )
18294 
 
18295 
  def __init__(self, orderId=None, weight=None,):
18296 
    self.orderId = orderId
18297 
    self.weight = weight
18298 
 
18299 
  def read(self, iprot):
18300 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
18301 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
18302 
      return
18303 
    iprot.readStructBegin()
18304 
    while True:
18305 
      (fname, ftype, fid) = iprot.readFieldBegin()
18306 
      if ftype == TType.STOP:
18307 
        break
18308 
      if fid == 1:
18309 
        if ftype == TType.I64:
18310 
          self.orderId = iprot.readI64();
18311 
        else:
18312 
          iprot.skip(ftype)
18313 
      elif fid == 2:
18314 
        if ftype == TType.DOUBLE:
18315 
          self.weight = iprot.readDouble();
18316 
        else:
18317 
          iprot.skip(ftype)
18318 
      else:
18319 
        iprot.skip(ftype)
18320 
      iprot.readFieldEnd()
18321 
    iprot.readStructEnd()
18322 
 
18323 
  def write(self, oprot):
18324 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
18325 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
18326 
      return
18327 
    oprot.writeStructBegin('updateWeight_args')
18328 
    if self.orderId is not None:
18329 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
18330 
      oprot.writeI64(self.orderId)
18331 
      oprot.writeFieldEnd()
18332 
    if self.weight is not None:
18333 
      oprot.writeFieldBegin('weight', TType.DOUBLE, 2)
18334 
      oprot.writeDouble(self.weight)
18335 
      oprot.writeFieldEnd()
18336 
    oprot.writeFieldStop()
18337 
    oprot.writeStructEnd()
18338 
 
18339 
  def validate(self):
18340 
    return
18341 
 
18342 
 
18343 
  def __repr__(self):
18344 
    L = ['%s=%r' % (key, value)
18345 
      for key, value in self.__dict__.iteritems()]
18346 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
18347 
 
18348 
  def __eq__(self, other):
18349 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
18350 
 
18351 
  def __ne__(self, other):
18352 
    return not (self == other)
18353 
 
18354 
class updateWeight_result:
18355 
  """
18356 
  Attributes:
18357 
   - success
18358 
   - ex
18359 
  """
18360 
 
18361 
  thrift_spec = (
18362 
    (0, TType.STRUCT, 'success', (Order, Order.thrift_spec), None, ), # 0
18363 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
18364 
  )
18365 
 
18366 
  def __init__(self, success=None, ex=None,):
18367 
    self.success = success
18368 
    self.ex = ex
18369 
 
18370 
  def read(self, iprot):
18371 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
18372 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
18373 
      return
18374 
    iprot.readStructBegin()
18375 
    while True:
18376 
      (fname, ftype, fid) = iprot.readFieldBegin()
18377 
      if ftype == TType.STOP:
18378 
        break
18379 
      if fid == 0:
18380 
        if ftype == TType.STRUCT:
18381 
          self.success = Order()
18382 
          self.success.read(iprot)
18383 
        else:
18384 
          iprot.skip(ftype)
18385 
      elif fid == 1:
18386 
        if ftype == TType.STRUCT:
18387 
          self.ex = TransactionServiceException()
18388 
          self.ex.read(iprot)
18389 
        else:
18390 
          iprot.skip(ftype)
18391 
      else:
18392 
        iprot.skip(ftype)
18393 
      iprot.readFieldEnd()
18394 
    iprot.readStructEnd()
18395 
 
18396 
  def write(self, oprot):
18397 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
18398 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
18399 
      return
18400 
    oprot.writeStructBegin('updateWeight_result')
18401 
    if self.success is not None:
18402 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
18403 
      self.success.write(oprot)
18404 
      oprot.writeFieldEnd()
18405 
    if self.ex is not None:
18406 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
18407 
      self.ex.write(oprot)
18408 
      oprot.writeFieldEnd()
18409 
    oprot.writeFieldStop()
18410 
    oprot.writeStructEnd()
18411 
 
18412 
  def validate(self):
18413 
    return
18414 
 
18415 
 
18416 
  def __repr__(self):
18417 
    L = ['%s=%r' % (key, value)
18418 
      for key, value in self.__dict__.iteritems()]
18419 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
18420 
 
18421 
  def __eq__(self, other):
18422 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
18423 
 
18424 
  def __ne__(self, other):
18425 
    return not (self == other)
3469 chandransh 18426 
 
18427 
class changeItem_args:
18428 
  """
18429 
  Attributes:
18430 
   - orderId
18431 
   - itemId
18432 
  """
18433 
 
18434 
  thrift_spec = (
18435 
    None, # 0
18436 
    (1, TType.I64, 'orderId', None, None, ), # 1
18437 
    (2, TType.I64, 'itemId', None, None, ), # 2
18438 
  )
18439 
 
18440 
  def __init__(self, orderId=None, itemId=None,):
18441 
    self.orderId = orderId
18442 
    self.itemId = itemId
18443 
 
18444 
  def read(self, iprot):
18445 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
18446 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
18447 
      return
18448 
    iprot.readStructBegin()
18449 
    while True:
18450 
      (fname, ftype, fid) = iprot.readFieldBegin()
18451 
      if ftype == TType.STOP:
18452 
        break
18453 
      if fid == 1:
18454 
        if ftype == TType.I64:
18455 
          self.orderId = iprot.readI64();
18456 
        else:
18457 
          iprot.skip(ftype)
18458 
      elif fid == 2:
18459 
        if ftype == TType.I64:
18460 
          self.itemId = iprot.readI64();
18461 
        else:
18462 
          iprot.skip(ftype)
18463 
      else:
18464 
        iprot.skip(ftype)
18465 
      iprot.readFieldEnd()
18466 
    iprot.readStructEnd()
18467 
 
18468 
  def write(self, oprot):
18469 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
18470 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
18471 
      return
18472 
    oprot.writeStructBegin('changeItem_args')
18473 
    if self.orderId is not None:
18474 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
18475 
      oprot.writeI64(self.orderId)
18476 
      oprot.writeFieldEnd()
18477 
    if self.itemId is not None:
18478 
      oprot.writeFieldBegin('itemId', TType.I64, 2)
18479 
      oprot.writeI64(self.itemId)
18480 
      oprot.writeFieldEnd()
18481 
    oprot.writeFieldStop()
18482 
    oprot.writeStructEnd()
18483 
 
18484 
  def validate(self):
18485 
    return
18486 
 
18487 
 
18488 
  def __repr__(self):
18489 
    L = ['%s=%r' % (key, value)
18490 
      for key, value in self.__dict__.iteritems()]
18491 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
18492 
 
18493 
  def __eq__(self, other):
18494 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
18495 
 
18496 
  def __ne__(self, other):
18497 
    return not (self == other)
18498 
 
18499 
class changeItem_result:
18500 
  """
18501 
  Attributes:
18502 
   - success
18503 
   - ex
18504 
  """
18505 
 
18506 
  thrift_spec = (
18507 
    (0, TType.STRUCT, 'success', (Order, Order.thrift_spec), None, ), # 0
18508 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
18509 
  )
18510 
 
18511 
  def __init__(self, success=None, ex=None,):
18512 
    self.success = success
18513 
    self.ex = ex
18514 
 
18515 
  def read(self, iprot):
18516 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
18517 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
18518 
      return
18519 
    iprot.readStructBegin()
18520 
    while True:
18521 
      (fname, ftype, fid) = iprot.readFieldBegin()
18522 
      if ftype == TType.STOP:
18523 
        break
18524 
      if fid == 0:
18525 
        if ftype == TType.STRUCT:
18526 
          self.success = Order()
18527 
          self.success.read(iprot)
18528 
        else:
18529 
          iprot.skip(ftype)
18530 
      elif fid == 1:
18531 
        if ftype == TType.STRUCT:
18532 
          self.ex = TransactionServiceException()
18533 
          self.ex.read(iprot)
18534 
        else:
18535 
          iprot.skip(ftype)
18536 
      else:
18537 
        iprot.skip(ftype)
18538 
      iprot.readFieldEnd()
18539 
    iprot.readStructEnd()
18540 
 
18541 
  def write(self, oprot):
18542 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
18543 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
18544 
      return
18545 
    oprot.writeStructBegin('changeItem_result')
18546 
    if self.success is not None:
18547 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
18548 
      self.success.write(oprot)
18549 
      oprot.writeFieldEnd()
18550 
    if self.ex is not None:
18551 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
18552 
      self.ex.write(oprot)
18553 
      oprot.writeFieldEnd()
18554 
    oprot.writeFieldStop()
18555 
    oprot.writeStructEnd()
18556 
 
18557 
  def validate(self):
18558 
    return
18559 
 
18560 
 
18561 
  def __repr__(self):
18562 
    L = ['%s=%r' % (key, value)
18563 
      for key, value in self.__dict__.iteritems()]
18564 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
18565 
 
18566 
  def __eq__(self, other):
18567 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
18568 
 
18569 
  def __ne__(self, other):
18570 
    return not (self == other)
18571 
 
18572 
class shiftToWarehouse_args:
18573 
  """
18574 
  Attributes:
18575 
   - orderId
18576 
   - warehouseId
18577 
  """
18578 
 
18579 
  thrift_spec = (
18580 
    None, # 0
18581 
    (1, TType.I64, 'orderId', None, None, ), # 1
18582 
    (2, TType.I64, 'warehouseId', None, None, ), # 2
18583 
  )
18584 
 
18585 
  def __init__(self, orderId=None, warehouseId=None,):
18586 
    self.orderId = orderId
18587 
    self.warehouseId = warehouseId
18588 
 
18589 
  def read(self, iprot):
18590 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
18591 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
18592 
      return
18593 
    iprot.readStructBegin()
18594 
    while True:
18595 
      (fname, ftype, fid) = iprot.readFieldBegin()
18596 
      if ftype == TType.STOP:
18597 
        break
18598 
      if fid == 1:
18599 
        if ftype == TType.I64:
18600 
          self.orderId = iprot.readI64();
18601 
        else:
18602 
          iprot.skip(ftype)
18603 
      elif fid == 2:
18604 
        if ftype == TType.I64:
18605 
          self.warehouseId = iprot.readI64();
18606 
        else:
18607 
          iprot.skip(ftype)
18608 
      else:
18609 
        iprot.skip(ftype)
18610 
      iprot.readFieldEnd()
18611 
    iprot.readStructEnd()
18612 
 
18613 
  def write(self, oprot):
18614 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
18615 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
18616 
      return
18617 
    oprot.writeStructBegin('shiftToWarehouse_args')
18618 
    if self.orderId is not None:
18619 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
18620 
      oprot.writeI64(self.orderId)
18621 
      oprot.writeFieldEnd()
18622 
    if self.warehouseId is not None:
18623 
      oprot.writeFieldBegin('warehouseId', TType.I64, 2)
18624 
      oprot.writeI64(self.warehouseId)
18625 
      oprot.writeFieldEnd()
18626 
    oprot.writeFieldStop()
18627 
    oprot.writeStructEnd()
18628 
 
18629 
  def validate(self):
18630 
    return
18631 
 
18632 
 
18633 
  def __repr__(self):
18634 
    L = ['%s=%r' % (key, value)
18635 
      for key, value in self.__dict__.iteritems()]
18636 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
18637 
 
18638 
  def __eq__(self, other):
18639 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
18640 
 
18641 
  def __ne__(self, other):
18642 
    return not (self == other)
18643 
 
18644 
class shiftToWarehouse_result:
18645 
  """
18646 
  Attributes:
18647 
   - success
18648 
   - ex
18649 
  """
18650 
 
18651 
  thrift_spec = (
18652 
    (0, TType.STRUCT, 'success', (Order, Order.thrift_spec), None, ), # 0
18653 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
18654 
  )
18655 
 
18656 
  def __init__(self, success=None, ex=None,):
18657 
    self.success = success
18658 
    self.ex = ex
18659 
 
18660 
  def read(self, iprot):
18661 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
18662 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
18663 
      return
18664 
    iprot.readStructBegin()
18665 
    while True:
18666 
      (fname, ftype, fid) = iprot.readFieldBegin()
18667 
      if ftype == TType.STOP:
18668 
        break
18669 
      if fid == 0:
18670 
        if ftype == TType.STRUCT:
18671 
          self.success = Order()
18672 
          self.success.read(iprot)
18673 
        else:
18674 
          iprot.skip(ftype)
18675 
      elif fid == 1:
18676 
        if ftype == TType.STRUCT:
18677 
          self.ex = TransactionServiceException()
18678 
          self.ex.read(iprot)
18679 
        else:
18680 
          iprot.skip(ftype)
18681 
      else:
18682 
        iprot.skip(ftype)
18683 
      iprot.readFieldEnd()
18684 
    iprot.readStructEnd()
18685 
 
18686 
  def write(self, oprot):
18687 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
18688 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
18689 
      return
18690 
    oprot.writeStructBegin('shiftToWarehouse_result')
18691 
    if self.success is not None:
18692 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
18693 
      self.success.write(oprot)
18694 
      oprot.writeFieldEnd()
18695 
    if self.ex is not None:
18696 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
18697 
      self.ex.write(oprot)
18698 
      oprot.writeFieldEnd()
18699 
    oprot.writeFieldStop()
18700 
    oprot.writeStructEnd()
18701 
 
18702 
  def validate(self):
18703 
    return
18704 
 
18705 
 
18706 
  def __repr__(self):
18707 
    L = ['%s=%r' % (key, value)
18708 
      for key, value in self.__dict__.iteritems()]
18709 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
18710 
 
18711 
  def __eq__(self, other):
18712 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
18713 
 
18714 
  def __ne__(self, other):
18715 
    return not (self == other)
3553 chandransh 18716 
 
18717 
class addDelayReason_args:
18718 
  """
18719 
  Attributes:
18720 
   - orderId
18721 
   - delayReason
3986 chandransh 18722 
   - furtherDelay
4647 rajveer 18723 
   - delayReasonText
3553 chandransh 18724 
  """
18725 
 
18726 
  thrift_spec = (
18727 
    None, # 0
18728 
    (1, TType.I64, 'orderId', None, None, ), # 1
18729 
    (2, TType.I32, 'delayReason', None, None, ), # 2
3986 chandransh 18730 
    (3, TType.I64, 'furtherDelay', None, None, ), # 3
4647 rajveer 18731 
    (4, TType.STRING, 'delayReasonText', None, None, ), # 4
3553 chandransh 18732 
  )
18733 
 
4647 rajveer 18734 
  def __init__(self, orderId=None, delayReason=None, furtherDelay=None, delayReasonText=None,):
3553 chandransh 18735 
    self.orderId = orderId
18736 
    self.delayReason = delayReason
3986 chandransh 18737 
    self.furtherDelay = furtherDelay
4647 rajveer 18738 
    self.delayReasonText = delayReasonText
3553 chandransh 18739 
 
18740 
  def read(self, iprot):
18741 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
18742 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
18743 
      return
18744 
    iprot.readStructBegin()
18745 
    while True:
18746 
      (fname, ftype, fid) = iprot.readFieldBegin()
18747 
      if ftype == TType.STOP:
18748 
        break
18749 
      if fid == 1:
18750 
        if ftype == TType.I64:
18751 
          self.orderId = iprot.readI64();
18752 
        else:
18753 
          iprot.skip(ftype)
18754 
      elif fid == 2:
18755 
        if ftype == TType.I32:
18756 
          self.delayReason = iprot.readI32();
18757 
        else:
18758 
          iprot.skip(ftype)
3986 chandransh 18759 
      elif fid == 3:
18760 
        if ftype == TType.I64:
18761 
          self.furtherDelay = iprot.readI64();
18762 
        else:
18763 
          iprot.skip(ftype)
4647 rajveer 18764 
      elif fid == 4:
18765 
        if ftype == TType.STRING:
18766 
          self.delayReasonText = iprot.readString();
18767 
        else:
18768 
          iprot.skip(ftype)
3553 chandransh 18769 
      else:
18770 
        iprot.skip(ftype)
18771 
      iprot.readFieldEnd()
18772 
    iprot.readStructEnd()
18773 
 
18774 
  def write(self, oprot):
18775 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
18776 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
18777 
      return
18778 
    oprot.writeStructBegin('addDelayReason_args')
18779 
    if self.orderId is not None:
18780 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
18781 
      oprot.writeI64(self.orderId)
18782 
      oprot.writeFieldEnd()
18783 
    if self.delayReason is not None:
18784 
      oprot.writeFieldBegin('delayReason', TType.I32, 2)
18785 
      oprot.writeI32(self.delayReason)
18786 
      oprot.writeFieldEnd()
3986 chandransh 18787 
    if self.furtherDelay is not None:
18788 
      oprot.writeFieldBegin('furtherDelay', TType.I64, 3)
18789 
      oprot.writeI64(self.furtherDelay)
18790 
      oprot.writeFieldEnd()
4647 rajveer 18791 
    if self.delayReasonText is not None:
18792 
      oprot.writeFieldBegin('delayReasonText', TType.STRING, 4)
18793 
      oprot.writeString(self.delayReasonText)
18794 
      oprot.writeFieldEnd()
3553 chandransh 18795 
    oprot.writeFieldStop()
18796 
    oprot.writeStructEnd()
18797 
 
18798 
  def validate(self):
18799 
    return
18800 
 
18801 
 
18802 
  def __repr__(self):
18803 
    L = ['%s=%r' % (key, value)
18804 
      for key, value in self.__dict__.iteritems()]
18805 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
18806 
 
18807 
  def __eq__(self, other):
18808 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
18809 
 
18810 
  def __ne__(self, other):
18811 
    return not (self == other)
18812 
 
18813 
class addDelayReason_result:
18814 
  """
18815 
  Attributes:
18816 
   - success
18817 
   - ex
18818 
  """
18819 
 
18820 
  thrift_spec = (
18821 
    (0, TType.BOOL, 'success', None, None, ), # 0
18822 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
18823 
  )
18824 
 
18825 
  def __init__(self, success=None, ex=None,):
18826 
    self.success = success
18827 
    self.ex = ex
18828 
 
18829 
  def read(self, iprot):
18830 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
18831 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
18832 
      return
18833 
    iprot.readStructBegin()
18834 
    while True:
18835 
      (fname, ftype, fid) = iprot.readFieldBegin()
18836 
      if ftype == TType.STOP:
18837 
        break
18838 
      if fid == 0:
18839 
        if ftype == TType.BOOL:
18840 
          self.success = iprot.readBool();
18841 
        else:
18842 
          iprot.skip(ftype)
18843 
      elif fid == 1:
18844 
        if ftype == TType.STRUCT:
18845 
          self.ex = TransactionServiceException()
18846 
          self.ex.read(iprot)
18847 
        else:
18848 
          iprot.skip(ftype)
18849 
      else:
18850 
        iprot.skip(ftype)
18851 
      iprot.readFieldEnd()
18852 
    iprot.readStructEnd()
18853 
 
18854 
  def write(self, oprot):
18855 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
18856 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
18857 
      return
18858 
    oprot.writeStructBegin('addDelayReason_result')
18859 
    if self.success is not None:
18860 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
18861 
      oprot.writeBool(self.success)
18862 
      oprot.writeFieldEnd()
18863 
    if self.ex is not None:
18864 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
18865 
      self.ex.write(oprot)
18866 
      oprot.writeFieldEnd()
18867 
    oprot.writeFieldStop()
18868 
    oprot.writeStructEnd()
18869 
 
18870 
  def validate(self):
18871 
    return
18872 
 
18873 
 
18874 
  def __repr__(self):
18875 
    L = ['%s=%r' % (key, value)
18876 
      for key, value in self.__dict__.iteritems()]
18877 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
18878 
 
18879 
  def __eq__(self, other):
18880 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
18881 
 
18882 
  def __ne__(self, other):
18883 
    return not (self == other)
3956 chandransh 18884 
 
18885 
class reconcileCodCollection_args:
18886 
  """
18887 
  Attributes:
18888 
   - collectedAmountMap
18889 
   - xferBy
18890 
   - xferTxnId
18891 
   - xferDate
18892 
  """
18893 
 
18894 
  thrift_spec = (
18895 
    None, # 0
18896 
    (1, TType.MAP, 'collectedAmountMap', (TType.STRING,None,TType.DOUBLE,None), None, ), # 1
18897 
    (2, TType.STRING, 'xferBy', None, None, ), # 2
18898 
    (3, TType.STRING, 'xferTxnId', None, None, ), # 3
18899 
    (4, TType.I64, 'xferDate', None, None, ), # 4
18900 
  )
18901 
 
18902 
  def __init__(self, collectedAmountMap=None, xferBy=None, xferTxnId=None, xferDate=None,):
18903 
    self.collectedAmountMap = collectedAmountMap
18904 
    self.xferBy = xferBy
18905 
    self.xferTxnId = xferTxnId
18906 
    self.xferDate = xferDate
18907 
 
18908 
  def read(self, iprot):
18909 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
18910 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
18911 
      return
18912 
    iprot.readStructBegin()
18913 
    while True:
18914 
      (fname, ftype, fid) = iprot.readFieldBegin()
18915 
      if ftype == TType.STOP:
18916 
        break
18917 
      if fid == 1:
18918 
        if ftype == TType.MAP:
18919 
          self.collectedAmountMap = {}
6000 mandeep.dh 18920 
          (_ktype418, _vtype419, _size417 ) = iprot.readMapBegin()
18921 
          for _i421 in xrange(_size417):
18922 
            _key422 = iprot.readString();
18923 
            _val423 = iprot.readDouble();
18924 
            self.collectedAmountMap[_key422] = _val423
3956 chandransh 18925 
          iprot.readMapEnd()
18926 
        else:
18927 
          iprot.skip(ftype)
18928 
      elif fid == 2:
18929 
        if ftype == TType.STRING:
18930 
          self.xferBy = iprot.readString();
18931 
        else:
18932 
          iprot.skip(ftype)
18933 
      elif fid == 3:
18934 
        if ftype == TType.STRING:
18935 
          self.xferTxnId = iprot.readString();
18936 
        else:
18937 
          iprot.skip(ftype)
18938 
      elif fid == 4:
18939 
        if ftype == TType.I64:
18940 
          self.xferDate = iprot.readI64();
18941 
        else:
18942 
          iprot.skip(ftype)
18943 
      else:
18944 
        iprot.skip(ftype)
18945 
      iprot.readFieldEnd()
18946 
    iprot.readStructEnd()
18947 
 
18948 
  def write(self, oprot):
18949 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
18950 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
18951 
      return
18952 
    oprot.writeStructBegin('reconcileCodCollection_args')
18953 
    if self.collectedAmountMap is not None:
18954 
      oprot.writeFieldBegin('collectedAmountMap', TType.MAP, 1)
18955 
      oprot.writeMapBegin(TType.STRING, TType.DOUBLE, len(self.collectedAmountMap))
6000 mandeep.dh 18956 
      for kiter424,viter425 in self.collectedAmountMap.items():
18957 
        oprot.writeString(kiter424)
18958 
        oprot.writeDouble(viter425)
3956 chandransh 18959 
      oprot.writeMapEnd()
18960 
      oprot.writeFieldEnd()
18961 
    if self.xferBy is not None:
18962 
      oprot.writeFieldBegin('xferBy', TType.STRING, 2)
18963 
      oprot.writeString(self.xferBy)
18964 
      oprot.writeFieldEnd()
18965 
    if self.xferTxnId is not None:
18966 
      oprot.writeFieldBegin('xferTxnId', TType.STRING, 3)
18967 
      oprot.writeString(self.xferTxnId)
18968 
      oprot.writeFieldEnd()
18969 
    if self.xferDate is not None:
18970 
      oprot.writeFieldBegin('xferDate', TType.I64, 4)
18971 
      oprot.writeI64(self.xferDate)
18972 
      oprot.writeFieldEnd()
18973 
    oprot.writeFieldStop()
18974 
    oprot.writeStructEnd()
18975 
 
18976 
  def validate(self):
18977 
    return
18978 
 
18979 
 
18980 
  def __repr__(self):
18981 
    L = ['%s=%r' % (key, value)
18982 
      for key, value in self.__dict__.iteritems()]
18983 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
18984 
 
18985 
  def __eq__(self, other):
18986 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
18987 
 
18988 
  def __ne__(self, other):
18989 
    return not (self == other)
18990 
 
18991 
class reconcileCodCollection_result:
18992 
  """
18993 
  Attributes:
18994 
   - success
18995 
   - ex
18996 
  """
18997 
 
18998 
  thrift_spec = (
18999 
    (0, TType.MAP, 'success', (TType.STRING,None,TType.STRING,None), None, ), # 0
19000 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
19001 
  )
19002 
 
19003 
  def __init__(self, success=None, ex=None,):
19004 
    self.success = success
19005 
    self.ex = ex
19006 
 
19007 
  def read(self, iprot):
19008 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
19009 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
19010 
      return
19011 
    iprot.readStructBegin()
19012 
    while True:
19013 
      (fname, ftype, fid) = iprot.readFieldBegin()
19014 
      if ftype == TType.STOP:
19015 
        break
19016 
      if fid == 0:
19017 
        if ftype == TType.MAP:
19018 
          self.success = {}
6000 mandeep.dh 19019 
          (_ktype427, _vtype428, _size426 ) = iprot.readMapBegin()
19020 
          for _i430 in xrange(_size426):
19021 
            _key431 = iprot.readString();
19022 
            _val432 = iprot.readString();
19023 
            self.success[_key431] = _val432
3956 chandransh 19024 
          iprot.readMapEnd()
19025 
        else:
19026 
          iprot.skip(ftype)
19027 
      elif fid == 1:
19028 
        if ftype == TType.STRUCT:
19029 
          self.ex = TransactionServiceException()
19030 
          self.ex.read(iprot)
19031 
        else:
19032 
          iprot.skip(ftype)
19033 
      else:
19034 
        iprot.skip(ftype)
19035 
      iprot.readFieldEnd()
19036 
    iprot.readStructEnd()
19037 
 
19038 
  def write(self, oprot):
19039 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
19040 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
19041 
      return
19042 
    oprot.writeStructBegin('reconcileCodCollection_result')
19043 
    if self.success is not None:
19044 
      oprot.writeFieldBegin('success', TType.MAP, 0)
19045 
      oprot.writeMapBegin(TType.STRING, TType.STRING, len(self.success))
6000 mandeep.dh 19046 
      for kiter433,viter434 in self.success.items():
19047 
        oprot.writeString(kiter433)
19048 
        oprot.writeString(viter434)
3956 chandransh 19049 
      oprot.writeMapEnd()
19050 
      oprot.writeFieldEnd()
19051 
    if self.ex is not None:
19052 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
19053 
      self.ex.write(oprot)
19054 
      oprot.writeFieldEnd()
19055 
    oprot.writeFieldStop()
19056 
    oprot.writeStructEnd()
19057 
 
19058 
  def validate(self):
19059 
    return
19060 
 
19061 
 
19062 
  def __repr__(self):
19063 
    L = ['%s=%r' % (key, value)
19064 
      for key, value in self.__dict__.iteritems()]
19065 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
19066 
 
19067 
  def __eq__(self, other):
19068 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
19069 
 
19070 
  def __ne__(self, other):
19071 
    return not (self == other)
4008 mandeep.dh 19072 
 
19073 
class getTransactionsRequiringExtraProcessing_args:
19074 
  """
19075 
  Attributes:
19076 
   - category
19077 
  """
19078 
 
19079 
  thrift_spec = (
19080 
    None, # 0
19081 
    (1, TType.I32, 'category', None, None, ), # 1
19082 
  )
19083 
 
19084 
  def __init__(self, category=None,):
19085 
    self.category = category
19086 
 
19087 
  def read(self, iprot):
19088 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
19089 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
19090 
      return
19091 
    iprot.readStructBegin()
19092 
    while True:
19093 
      (fname, ftype, fid) = iprot.readFieldBegin()
19094 
      if ftype == TType.STOP:
19095 
        break
19096 
      if fid == 1:
19097 
        if ftype == TType.I32:
19098 
          self.category = iprot.readI32();
19099 
        else:
19100 
          iprot.skip(ftype)
19101 
      else:
19102 
        iprot.skip(ftype)
19103 
      iprot.readFieldEnd()
19104 
    iprot.readStructEnd()
19105 
 
19106 
  def write(self, oprot):
19107 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
19108 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
19109 
      return
19110 
    oprot.writeStructBegin('getTransactionsRequiringExtraProcessing_args')
19111 
    if self.category is not None:
19112 
      oprot.writeFieldBegin('category', TType.I32, 1)
19113 
      oprot.writeI32(self.category)
19114 
      oprot.writeFieldEnd()
19115 
    oprot.writeFieldStop()
19116 
    oprot.writeStructEnd()
19117 
 
19118 
  def validate(self):
19119 
    return
19120 
 
19121 
 
19122 
  def __repr__(self):
19123 
    L = ['%s=%r' % (key, value)
19124 
      for key, value in self.__dict__.iteritems()]
19125 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
19126 
 
19127 
  def __eq__(self, other):
19128 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
19129 
 
19130 
  def __ne__(self, other):
19131 
    return not (self == other)
19132 
 
19133 
class getTransactionsRequiringExtraProcessing_result:
19134 
  """
19135 
  Attributes:
19136 
   - success
19137 
  """
19138 
 
19139 
  thrift_spec = (
19140 
    (0, TType.LIST, 'success', (TType.I64,None), None, ), # 0
19141 
  )
19142 
 
19143 
  def __init__(self, success=None,):
19144 
    self.success = success
19145 
 
19146 
  def read(self, iprot):
19147 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
19148 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
19149 
      return
19150 
    iprot.readStructBegin()
19151 
    while True:
19152 
      (fname, ftype, fid) = iprot.readFieldBegin()
19153 
      if ftype == TType.STOP:
19154 
        break
19155 
      if fid == 0:
19156 
        if ftype == TType.LIST:
19157 
          self.success = []
6000 mandeep.dh 19158 
          (_etype438, _size435) = iprot.readListBegin()
19159 
          for _i439 in xrange(_size435):
19160 
            _elem440 = iprot.readI64();
19161 
            self.success.append(_elem440)
4008 mandeep.dh 19162 
          iprot.readListEnd()
19163 
        else:
19164 
          iprot.skip(ftype)
19165 
      else:
19166 
        iprot.skip(ftype)
19167 
      iprot.readFieldEnd()
19168 
    iprot.readStructEnd()
19169 
 
19170 
  def write(self, oprot):
19171 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
19172 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
19173 
      return
19174 
    oprot.writeStructBegin('getTransactionsRequiringExtraProcessing_result')
19175 
    if self.success is not None:
19176 
      oprot.writeFieldBegin('success', TType.LIST, 0)
19177 
      oprot.writeListBegin(TType.I64, len(self.success))
6000 mandeep.dh 19178 
      for iter441 in self.success:
19179 
        oprot.writeI64(iter441)
4008 mandeep.dh 19180 
      oprot.writeListEnd()
19181 
      oprot.writeFieldEnd()
19182 
    oprot.writeFieldStop()
19183 
    oprot.writeStructEnd()
19184 
 
19185 
  def validate(self):
19186 
    return
19187 
 
19188 
 
19189 
  def __repr__(self):
19190 
    L = ['%s=%r' % (key, value)
19191 
      for key, value in self.__dict__.iteritems()]
19192 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
19193 
 
19194 
  def __eq__(self, other):
19195 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
19196 
 
19197 
  def __ne__(self, other):
19198 
    return not (self == other)
19199 
 
19200 
class markTransactionAsProcessed_args:
19201 
  """
19202 
  Attributes:
19203 
   - transactionId
19204 
   - category
19205 
  """
19206 
 
19207 
  thrift_spec = (
19208 
    None, # 0
19209 
    (1, TType.I64, 'transactionId', None, None, ), # 1
19210 
    (2, TType.I32, 'category', None, None, ), # 2
19211 
  )
19212 
 
19213 
  def __init__(self, transactionId=None, category=None,):
19214 
    self.transactionId = transactionId
19215 
    self.category = category
19216 
 
19217 
  def read(self, iprot):
19218 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
19219 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
19220 
      return
19221 
    iprot.readStructBegin()
19222 
    while True:
19223 
      (fname, ftype, fid) = iprot.readFieldBegin()
19224 
      if ftype == TType.STOP:
19225 
        break
19226 
      if fid == 1:
19227 
        if ftype == TType.I64:
19228 
          self.transactionId = iprot.readI64();
19229 
        else:
19230 
          iprot.skip(ftype)
19231 
      elif fid == 2:
19232 
        if ftype == TType.I32:
19233 
          self.category = iprot.readI32();
19234 
        else:
19235 
          iprot.skip(ftype)
19236 
      else:
19237 
        iprot.skip(ftype)
19238 
      iprot.readFieldEnd()
19239 
    iprot.readStructEnd()
19240 
 
19241 
  def write(self, oprot):
19242 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
19243 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
19244 
      return
19245 
    oprot.writeStructBegin('markTransactionAsProcessed_args')
19246 
    if self.transactionId is not None:
19247 
      oprot.writeFieldBegin('transactionId', TType.I64, 1)
19248 
      oprot.writeI64(self.transactionId)
19249 
      oprot.writeFieldEnd()
19250 
    if self.category is not None:
19251 
      oprot.writeFieldBegin('category', TType.I32, 2)
19252 
      oprot.writeI32(self.category)
19253 
      oprot.writeFieldEnd()
19254 
    oprot.writeFieldStop()
19255 
    oprot.writeStructEnd()
19256 
 
19257 
  def validate(self):
19258 
    return
19259 
 
19260 
 
19261 
  def __repr__(self):
19262 
    L = ['%s=%r' % (key, value)
19263 
      for key, value in self.__dict__.iteritems()]
19264 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
19265 
 
19266 
  def __eq__(self, other):
19267 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
19268 
 
19269 
  def __ne__(self, other):
19270 
    return not (self == other)
19271 
 
19272 
class markTransactionAsProcessed_result:
19273 
 
19274 
  thrift_spec = (
19275 
  )
19276 
 
19277 
  def read(self, iprot):
19278 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
19279 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
19280 
      return
19281 
    iprot.readStructBegin()
19282 
    while True:
19283 
      (fname, ftype, fid) = iprot.readFieldBegin()
19284 
      if ftype == TType.STOP:
19285 
        break
19286 
      else:
19287 
        iprot.skip(ftype)
19288 
      iprot.readFieldEnd()
19289 
    iprot.readStructEnd()
19290 
 
19291 
  def write(self, oprot):
19292 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
19293 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
19294 
      return
19295 
    oprot.writeStructBegin('markTransactionAsProcessed_result')
19296 
    oprot.writeFieldStop()
19297 
    oprot.writeStructEnd()
19298 
 
19299 
  def validate(self):
19300 
    return
19301 
 
19302 
 
19303 
  def __repr__(self):
19304 
    L = ['%s=%r' % (key, value)
19305 
      for key, value in self.__dict__.iteritems()]
19306 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
19307 
 
19308 
  def __eq__(self, other):
19309 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
19310 
 
19311 
  def __ne__(self, other):
19312 
    return not (self == other)
4018 chandransh 19313 
 
19314 
class getItemWiseRiskyOrdersCount_args:
19315 
 
19316 
  thrift_spec = (
19317 
  )
19318 
 
19319 
  def read(self, iprot):
19320 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
19321 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
19322 
      return
19323 
    iprot.readStructBegin()
19324 
    while True:
19325 
      (fname, ftype, fid) = iprot.readFieldBegin()
19326 
      if ftype == TType.STOP:
19327 
        break
19328 
      else:
19329 
        iprot.skip(ftype)
19330 
      iprot.readFieldEnd()
19331 
    iprot.readStructEnd()
19332 
 
19333 
  def write(self, oprot):
19334 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
19335 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
19336 
      return
19337 
    oprot.writeStructBegin('getItemWiseRiskyOrdersCount_args')
19338 
    oprot.writeFieldStop()
19339 
    oprot.writeStructEnd()
19340 
 
19341 
  def validate(self):
19342 
    return
19343 
 
19344 
 
19345 
  def __repr__(self):
19346 
    L = ['%s=%r' % (key, value)
19347 
      for key, value in self.__dict__.iteritems()]
19348 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
19349 
 
19350 
  def __eq__(self, other):
19351 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
19352 
 
19353 
  def __ne__(self, other):
19354 
    return not (self == other)
19355 
 
19356 
class getItemWiseRiskyOrdersCount_result:
19357 
  """
19358 
  Attributes:
19359 
   - success
19360 
  """
19361 
 
19362 
  thrift_spec = (
19363 
    (0, TType.MAP, 'success', (TType.I64,None,TType.I64,None), None, ), # 0
19364 
  )
19365 
 
19366 
  def __init__(self, success=None,):
19367 
    self.success = success
19368 
 
19369 
  def read(self, iprot):
19370 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
19371 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
19372 
      return
19373 
    iprot.readStructBegin()
19374 
    while True:
19375 
      (fname, ftype, fid) = iprot.readFieldBegin()
19376 
      if ftype == TType.STOP:
19377 
        break
19378 
      if fid == 0:
19379 
        if ftype == TType.MAP:
19380 
          self.success = {}
6000 mandeep.dh 19381 
          (_ktype443, _vtype444, _size442 ) = iprot.readMapBegin()
19382 
          for _i446 in xrange(_size442):
19383 
            _key447 = iprot.readI64();
19384 
            _val448 = iprot.readI64();
19385 
            self.success[_key447] = _val448
4018 chandransh 19386 
          iprot.readMapEnd()
19387 
        else:
19388 
          iprot.skip(ftype)
19389 
      else:
19390 
        iprot.skip(ftype)
19391 
      iprot.readFieldEnd()
19392 
    iprot.readStructEnd()
19393 
 
19394 
  def write(self, oprot):
19395 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
19396 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
19397 
      return
19398 
    oprot.writeStructBegin('getItemWiseRiskyOrdersCount_result')
19399 
    if self.success is not None:
19400 
      oprot.writeFieldBegin('success', TType.MAP, 0)
19401 
      oprot.writeMapBegin(TType.I64, TType.I64, len(self.success))
6000 mandeep.dh 19402 
      for kiter449,viter450 in self.success.items():
19403 
        oprot.writeI64(kiter449)
19404 
        oprot.writeI64(viter450)
4018 chandransh 19405 
      oprot.writeMapEnd()
19406 
      oprot.writeFieldEnd()
19407 
    oprot.writeFieldStop()
19408 
    oprot.writeStructEnd()
19409 
 
19410 
  def validate(self):
19411 
    return
19412 
 
19413 
 
19414 
  def __repr__(self):
19415 
    L = ['%s=%r' % (key, value)
19416 
      for key, value in self.__dict__.iteritems()]
19417 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
19418 
 
19419 
  def __eq__(self, other):
19420 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
19421 
 
19422 
  def __ne__(self, other):
19423 
    return not (self == other)
4247 rajveer 19424 
 
4295 varun.gupt 19425 
class getOrdersForItemIds_args:
19426 
  """
19427 
  Attributes:
19428 
   - itemIds
19429 
  """
19430 
 
19431 
  thrift_spec = (
19432 
    None, # 0
19433 
    (1, TType.LIST, 'itemIds', (TType.I64,None), None, ), # 1
19434 
  )
19435 
 
19436 
  def __init__(self, itemIds=None,):
19437 
    self.itemIds = itemIds
19438 
 
19439 
  def read(self, iprot):
19440 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
19441 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
19442 
      return
19443 
    iprot.readStructBegin()
19444 
    while True:
19445 
      (fname, ftype, fid) = iprot.readFieldBegin()
19446 
      if ftype == TType.STOP:
19447 
        break
19448 
      if fid == 1:
19449 
        if ftype == TType.LIST:
19450 
          self.itemIds = []
6000 mandeep.dh 19451 
          (_etype454, _size451) = iprot.readListBegin()
19452 
          for _i455 in xrange(_size451):
19453 
            _elem456 = iprot.readI64();
19454 
            self.itemIds.append(_elem456)
4295 varun.gupt 19455 
          iprot.readListEnd()
19456 
        else:
19457 
          iprot.skip(ftype)
19458 
      else:
19459 
        iprot.skip(ftype)
19460 
      iprot.readFieldEnd()
19461 
    iprot.readStructEnd()
19462 
 
19463 
  def write(self, oprot):
19464 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
19465 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
19466 
      return
19467 
    oprot.writeStructBegin('getOrdersForItemIds_args')
19468 
    if self.itemIds is not None:
19469 
      oprot.writeFieldBegin('itemIds', TType.LIST, 1)
19470 
      oprot.writeListBegin(TType.I64, len(self.itemIds))
6000 mandeep.dh 19471 
      for iter457 in self.itemIds:
19472 
        oprot.writeI64(iter457)
4295 varun.gupt 19473 
      oprot.writeListEnd()
19474 
      oprot.writeFieldEnd()
19475 
    oprot.writeFieldStop()
19476 
    oprot.writeStructEnd()
19477 
 
19478 
  def validate(self):
19479 
    return
19480 
 
19481 
 
19482 
  def __repr__(self):
19483 
    L = ['%s=%r' % (key, value)
19484 
      for key, value in self.__dict__.iteritems()]
19485 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
19486 
 
19487 
  def __eq__(self, other):
19488 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
19489 
 
19490 
  def __ne__(self, other):
19491 
    return not (self == other)
19492 
 
19493 
class getOrdersForItemIds_result:
19494 
  """
19495 
  Attributes:
19496 
   - success
19497 
  """
19498 
 
19499 
  thrift_spec = (
19500 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
19501 
  )
19502 
 
19503 
  def __init__(self, success=None,):
19504 
    self.success = success
19505 
 
19506 
  def read(self, iprot):
19507 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
19508 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
19509 
      return
19510 
    iprot.readStructBegin()
19511 
    while True:
19512 
      (fname, ftype, fid) = iprot.readFieldBegin()
19513 
      if ftype == TType.STOP:
19514 
        break
19515 
      if fid == 0:
19516 
        if ftype == TType.LIST:
19517 
          self.success = []
6000 mandeep.dh 19518 
          (_etype461, _size458) = iprot.readListBegin()
19519 
          for _i462 in xrange(_size458):
19520 
            _elem463 = Order()
19521 
            _elem463.read(iprot)
19522 
            self.success.append(_elem463)
4295 varun.gupt 19523 
          iprot.readListEnd()
19524 
        else:
19525 
          iprot.skip(ftype)
19526 
      else:
19527 
        iprot.skip(ftype)
19528 
      iprot.readFieldEnd()
19529 
    iprot.readStructEnd()
19530 
 
19531 
  def write(self, oprot):
19532 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
19533 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
19534 
      return
19535 
    oprot.writeStructBegin('getOrdersForItemIds_result')
19536 
    if self.success is not None:
19537 
      oprot.writeFieldBegin('success', TType.LIST, 0)
19538 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
6000 mandeep.dh 19539 
      for iter464 in self.success:
19540 
        iter464.write(oprot)
4295 varun.gupt 19541 
      oprot.writeListEnd()
19542 
      oprot.writeFieldEnd()
19543 
    oprot.writeFieldStop()
19544 
    oprot.writeStructEnd()
19545 
 
19546 
  def validate(self):
19547 
    return
19548 
 
19549 
 
19550 
  def __repr__(self):
19551 
    L = ['%s=%r' % (key, value)
19552 
      for key, value in self.__dict__.iteritems()]
19553 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
19554 
 
19555 
  def __eq__(self, other):
19556 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
19557 
 
19558 
  def __ne__(self, other):
19559 
    return not (self == other)
19560 
 
4247 rajveer 19561 
class markOrderCancellationRequestReceived_args:
19562 
  """
19563 
  Attributes:
19564 
   - orderId
19565 
  """
19566 
 
19567 
  thrift_spec = (
19568 
    None, # 0
19569 
    (1, TType.I64, 'orderId', None, None, ), # 1
19570 
  )
19571 
 
19572 
  def __init__(self, orderId=None,):
19573 
    self.orderId = orderId
19574 
 
19575 
  def read(self, iprot):
19576 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
19577 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
19578 
      return
19579 
    iprot.readStructBegin()
19580 
    while True:
19581 
      (fname, ftype, fid) = iprot.readFieldBegin()
19582 
      if ftype == TType.STOP:
19583 
        break
19584 
      if fid == 1:
19585 
        if ftype == TType.I64:
19586 
          self.orderId = iprot.readI64();
19587 
        else:
19588 
          iprot.skip(ftype)
19589 
      else:
19590 
        iprot.skip(ftype)
19591 
      iprot.readFieldEnd()
19592 
    iprot.readStructEnd()
19593 
 
19594 
  def write(self, oprot):
19595 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
19596 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
19597 
      return
19598 
    oprot.writeStructBegin('markOrderCancellationRequestReceived_args')
19599 
    if self.orderId is not None:
19600 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
19601 
      oprot.writeI64(self.orderId)
19602 
      oprot.writeFieldEnd()
19603 
    oprot.writeFieldStop()
19604 
    oprot.writeStructEnd()
19605 
 
19606 
  def validate(self):
19607 
    return
19608 
 
19609 
 
19610 
  def __repr__(self):
19611 
    L = ['%s=%r' % (key, value)
19612 
      for key, value in self.__dict__.iteritems()]
19613 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
19614 
 
19615 
  def __eq__(self, other):
19616 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
19617 
 
19618 
  def __ne__(self, other):
19619 
    return not (self == other)
19620 
 
19621 
class markOrderCancellationRequestReceived_result:
19622 
  """
19623 
  Attributes:
19624 
   - ex
19625 
  """
19626 
 
19627 
  thrift_spec = (
19628 
    None, # 0
19629 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
19630 
  )
19631 
 
19632 
  def __init__(self, ex=None,):
19633 
    self.ex = ex
19634 
 
19635 
  def read(self, iprot):
19636 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
19637 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
19638 
      return
19639 
    iprot.readStructBegin()
19640 
    while True:
19641 
      (fname, ftype, fid) = iprot.readFieldBegin()
19642 
      if ftype == TType.STOP:
19643 
        break
19644 
      if fid == 1:
19645 
        if ftype == TType.STRUCT:
19646 
          self.ex = TransactionServiceException()
19647 
          self.ex.read(iprot)
19648 
        else:
19649 
          iprot.skip(ftype)
19650 
      else:
19651 
        iprot.skip(ftype)
19652 
      iprot.readFieldEnd()
19653 
    iprot.readStructEnd()
19654 
 
19655 
  def write(self, oprot):
19656 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
19657 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
19658 
      return
19659 
    oprot.writeStructBegin('markOrderCancellationRequestReceived_result')
19660 
    if self.ex is not None:
19661 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
19662 
      self.ex.write(oprot)
19663 
      oprot.writeFieldEnd()
19664 
    oprot.writeFieldStop()
19665 
    oprot.writeStructEnd()
19666 
 
19667 
  def validate(self):
19668 
    return
19669 
 
19670 
 
19671 
  def __repr__(self):
19672 
    L = ['%s=%r' % (key, value)
19673 
      for key, value in self.__dict__.iteritems()]
19674 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
19675 
 
19676 
  def __eq__(self, other):
19677 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
19678 
 
19679 
  def __ne__(self, other):
19680 
    return not (self == other)
19681 
 
19682 
class markOrderCancellationRequestConfirmed_args:
19683 
  """
19684 
  Attributes:
19685 
   - orderId
19686 
  """
19687 
 
19688 
  thrift_spec = (
19689 
    None, # 0
19690 
    (1, TType.I64, 'orderId', None, None, ), # 1
19691 
  )
19692 
 
19693 
  def __init__(self, orderId=None,):
19694 
    self.orderId = orderId
19695 
 
19696 
  def read(self, iprot):
19697 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
19698 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
19699 
      return
19700 
    iprot.readStructBegin()
19701 
    while True:
19702 
      (fname, ftype, fid) = iprot.readFieldBegin()
19703 
      if ftype == TType.STOP:
19704 
        break
19705 
      if fid == 1:
19706 
        if ftype == TType.I64:
19707 
          self.orderId = iprot.readI64();
19708 
        else:
19709 
          iprot.skip(ftype)
19710 
      else:
19711 
        iprot.skip(ftype)
19712 
      iprot.readFieldEnd()
19713 
    iprot.readStructEnd()
19714 
 
19715 
  def write(self, oprot):
19716 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
19717 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
19718 
      return
19719 
    oprot.writeStructBegin('markOrderCancellationRequestConfirmed_args')
19720 
    if self.orderId is not None:
19721 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
19722 
      oprot.writeI64(self.orderId)
19723 
      oprot.writeFieldEnd()
19724 
    oprot.writeFieldStop()
19725 
    oprot.writeStructEnd()
19726 
 
19727 
  def validate(self):
19728 
    return
19729 
 
19730 
 
19731 
  def __repr__(self):
19732 
    L = ['%s=%r' % (key, value)
19733 
      for key, value in self.__dict__.iteritems()]
19734 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
19735 
 
19736 
  def __eq__(self, other):
19737 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
19738 
 
19739 
  def __ne__(self, other):
19740 
    return not (self == other)
19741 
 
19742 
class markOrderCancellationRequestConfirmed_result:
19743 
  """
19744 
  Attributes:
19745 
   - ex
19746 
  """
19747 
 
19748 
  thrift_spec = (
19749 
    None, # 0
19750 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
19751 
  )
19752 
 
19753 
  def __init__(self, ex=None,):
19754 
    self.ex = ex
19755 
 
19756 
  def read(self, iprot):
19757 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
19758 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
19759 
      return
19760 
    iprot.readStructBegin()
19761 
    while True:
19762 
      (fname, ftype, fid) = iprot.readFieldBegin()
19763 
      if ftype == TType.STOP:
19764 
        break
19765 
      if fid == 1:
19766 
        if ftype == TType.STRUCT:
19767 
          self.ex = TransactionServiceException()
19768 
          self.ex.read(iprot)
19769 
        else:
19770 
          iprot.skip(ftype)
19771 
      else:
19772 
        iprot.skip(ftype)
19773 
      iprot.readFieldEnd()
19774 
    iprot.readStructEnd()
19775 
 
19776 
  def write(self, oprot):
19777 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
19778 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
19779 
      return
19780 
    oprot.writeStructBegin('markOrderCancellationRequestConfirmed_result')
19781 
    if self.ex is not None:
19782 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
19783 
      self.ex.write(oprot)
19784 
      oprot.writeFieldEnd()
19785 
    oprot.writeFieldStop()
19786 
    oprot.writeStructEnd()
19787 
 
19788 
  def validate(self):
19789 
    return
19790 
 
19791 
 
19792 
  def __repr__(self):
19793 
    L = ['%s=%r' % (key, value)
19794 
      for key, value in self.__dict__.iteritems()]
19795 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
19796 
 
19797 
  def __eq__(self, other):
19798 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
19799 
 
19800 
  def __ne__(self, other):
19801 
    return not (self == other)
19802 
 
19803 
class markOrderCancellationRequestDenied_args:
19804 
  """
19805 
  Attributes:
19806 
   - orderId
19807 
  """
19808 
 
19809 
  thrift_spec = (
19810 
    None, # 0
19811 
    (1, TType.I64, 'orderId', None, None, ), # 1
19812 
  )
19813 
 
19814 
  def __init__(self, orderId=None,):
19815 
    self.orderId = orderId
19816 
 
19817 
  def read(self, iprot):
19818 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
19819 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
19820 
      return
19821 
    iprot.readStructBegin()
19822 
    while True:
19823 
      (fname, ftype, fid) = iprot.readFieldBegin()
19824 
      if ftype == TType.STOP:
19825 
        break
19826 
      if fid == 1:
19827 
        if ftype == TType.I64:
19828 
          self.orderId = iprot.readI64();
19829 
        else:
19830 
          iprot.skip(ftype)
19831 
      else:
19832 
        iprot.skip(ftype)
19833 
      iprot.readFieldEnd()
19834 
    iprot.readStructEnd()
19835 
 
19836 
  def write(self, oprot):
19837 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
19838 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
19839 
      return
19840 
    oprot.writeStructBegin('markOrderCancellationRequestDenied_args')
19841 
    if self.orderId is not None:
19842 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
19843 
      oprot.writeI64(self.orderId)
19844 
      oprot.writeFieldEnd()
19845 
    oprot.writeFieldStop()
19846 
    oprot.writeStructEnd()
19847 
 
19848 
  def validate(self):
19849 
    return
19850 
 
19851 
 
19852 
  def __repr__(self):
19853 
    L = ['%s=%r' % (key, value)
19854 
      for key, value in self.__dict__.iteritems()]
19855 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
19856 
 
19857 
  def __eq__(self, other):
19858 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
19859 
 
19860 
  def __ne__(self, other):
19861 
    return not (self == other)
19862 
 
19863 
class markOrderCancellationRequestDenied_result:
19864 
  """
19865 
  Attributes:
19866 
   - ex
19867 
  """
19868 
 
19869 
  thrift_spec = (
19870 
    None, # 0
19871 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
19872 
  )
19873 
 
19874 
  def __init__(self, ex=None,):
19875 
    self.ex = ex
19876 
 
19877 
  def read(self, iprot):
19878 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
19879 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
19880 
      return
19881 
    iprot.readStructBegin()
19882 
    while True:
19883 
      (fname, ftype, fid) = iprot.readFieldBegin()
19884 
      if ftype == TType.STOP:
19885 
        break
19886 
      if fid == 1:
19887 
        if ftype == TType.STRUCT:
19888 
          self.ex = TransactionServiceException()
19889 
          self.ex.read(iprot)
19890 
        else:
19891 
          iprot.skip(ftype)
19892 
      else:
19893 
        iprot.skip(ftype)
19894 
      iprot.readFieldEnd()
19895 
    iprot.readStructEnd()
19896 
 
19897 
  def write(self, oprot):
19898 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
19899 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
19900 
      return
19901 
    oprot.writeStructBegin('markOrderCancellationRequestDenied_result')
19902 
    if self.ex is not None:
19903 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
19904 
      self.ex.write(oprot)
19905 
      oprot.writeFieldEnd()
19906 
    oprot.writeFieldStop()
19907 
    oprot.writeStructEnd()
19908 
 
19909 
  def validate(self):
19910 
    return
19911 
 
19912 
 
19913 
  def __repr__(self):
19914 
    L = ['%s=%r' % (key, value)
19915 
      for key, value in self.__dict__.iteritems()]
19916 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
19917 
 
19918 
  def __eq__(self, other):
19919 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
19920 
 
19921 
  def __ne__(self, other):
19922 
    return not (self == other)
19923 
 
4258 rajveer 19924 
class markTransactionAsPaymentFlagRemoved_args:
4247 rajveer 19925 
  """
19926 
  Attributes:
4258 rajveer 19927 
   - transactionId
4247 rajveer 19928 
  """
19929 
 
19930 
  thrift_spec = (
19931 
    None, # 0
4258 rajveer 19932 
    (1, TType.I64, 'transactionId', None, None, ), # 1
4247 rajveer 19933 
  )
19934 
 
4258 rajveer 19935 
  def __init__(self, transactionId=None,):
19936 
    self.transactionId = transactionId
4247 rajveer 19937 
 
19938 
  def read(self, iprot):
19939 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
19940 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
19941 
      return
19942 
    iprot.readStructBegin()
19943 
    while True:
19944 
      (fname, ftype, fid) = iprot.readFieldBegin()
19945 
      if ftype == TType.STOP:
19946 
        break
19947 
      if fid == 1:
19948 
        if ftype == TType.I64:
4258 rajveer 19949 
          self.transactionId = iprot.readI64();
4247 rajveer 19950 
        else:
19951 
          iprot.skip(ftype)
19952 
      else:
19953 
        iprot.skip(ftype)
19954 
      iprot.readFieldEnd()
19955 
    iprot.readStructEnd()
19956 
 
19957 
  def write(self, oprot):
19958 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
19959 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
19960 
      return
4258 rajveer 19961 
    oprot.writeStructBegin('markTransactionAsPaymentFlagRemoved_args')
19962 
    if self.transactionId is not None:
19963 
      oprot.writeFieldBegin('transactionId', TType.I64, 1)
19964 
      oprot.writeI64(self.transactionId)
4247 rajveer 19965 
      oprot.writeFieldEnd()
19966 
    oprot.writeFieldStop()
19967 
    oprot.writeStructEnd()
19968 
 
19969 
  def validate(self):
19970 
    return
19971 
 
19972 
 
19973 
  def __repr__(self):
19974 
    L = ['%s=%r' % (key, value)
19975 
      for key, value in self.__dict__.iteritems()]
19976 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
19977 
 
19978 
  def __eq__(self, other):
19979 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
19980 
 
19981 
  def __ne__(self, other):
19982 
    return not (self == other)
19983 
 
4258 rajveer 19984 
class markTransactionAsPaymentFlagRemoved_result:
4247 rajveer 19985 
  """
19986 
  Attributes:
19987 
   - ex
19988 
  """
19989 
 
19990 
  thrift_spec = (
19991 
    None, # 0
19992 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
19993 
  )
19994 
 
19995 
  def __init__(self, ex=None,):
19996 
    self.ex = ex
19997 
 
19998 
  def read(self, iprot):
19999 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
20000 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
20001 
      return
20002 
    iprot.readStructBegin()
20003 
    while True:
20004 
      (fname, ftype, fid) = iprot.readFieldBegin()
20005 
      if ftype == TType.STOP:
20006 
        break
20007 
      if fid == 1:
20008 
        if ftype == TType.STRUCT:
20009 
          self.ex = TransactionServiceException()
20010 
          self.ex.read(iprot)
20011 
        else:
20012 
          iprot.skip(ftype)
20013 
      else:
20014 
        iprot.skip(ftype)
20015 
      iprot.readFieldEnd()
20016 
    iprot.readStructEnd()
20017 
 
20018 
  def write(self, oprot):
20019 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
20020 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
20021 
      return
4258 rajveer 20022 
    oprot.writeStructBegin('markTransactionAsPaymentFlagRemoved_result')
4247 rajveer 20023 
    if self.ex is not None:
20024 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
20025 
      self.ex.write(oprot)
20026 
      oprot.writeFieldEnd()
20027 
    oprot.writeFieldStop()
20028 
    oprot.writeStructEnd()
20029 
 
20030 
  def validate(self):
20031 
    return
20032 
 
20033 
 
20034 
  def __repr__(self):
20035 
    L = ['%s=%r' % (key, value)
20036 
      for key, value in self.__dict__.iteritems()]
20037 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
20038 
 
20039 
  def __eq__(self, other):
20040 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
20041 
 
20042 
  def __ne__(self, other):
20043 
    return not (self == other)
4259 anupam.sin 20044 
 
20045 
class refundTransaction_args:
20046 
  """
20047 
  Attributes:
20048 
   - transactionId
20049 
   - refundedBy
20050 
   - reason
20051 
  """
20052 
 
20053 
  thrift_spec = (
20054 
    None, # 0
20055 
    (1, TType.I64, 'transactionId', None, None, ), # 1
20056 
    (2, TType.STRING, 'refundedBy', None, None, ), # 2
20057 
    (3, TType.STRING, 'reason', None, None, ), # 3
20058 
  )
20059 
 
20060 
  def __init__(self, transactionId=None, refundedBy=None, reason=None,):
20061 
    self.transactionId = transactionId
20062 
    self.refundedBy = refundedBy
20063 
    self.reason = reason
20064 
 
20065 
  def read(self, iprot):
20066 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
20067 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
20068 
      return
20069 
    iprot.readStructBegin()
20070 
    while True:
20071 
      (fname, ftype, fid) = iprot.readFieldBegin()
20072 
      if ftype == TType.STOP:
20073 
        break
20074 
      if fid == 1:
20075 
        if ftype == TType.I64:
20076 
          self.transactionId = iprot.readI64();
20077 
        else:
20078 
          iprot.skip(ftype)
20079 
      elif fid == 2:
20080 
        if ftype == TType.STRING:
20081 
          self.refundedBy = iprot.readString();
20082 
        else:
20083 
          iprot.skip(ftype)
20084 
      elif fid == 3:
20085 
        if ftype == TType.STRING:
20086 
          self.reason = iprot.readString();
20087 
        else:
20088 
          iprot.skip(ftype)
20089 
      else:
20090 
        iprot.skip(ftype)
20091 
      iprot.readFieldEnd()
20092 
    iprot.readStructEnd()
20093 
 
20094 
  def write(self, oprot):
20095 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
20096 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
20097 
      return
20098 
    oprot.writeStructBegin('refundTransaction_args')
20099 
    if self.transactionId is not None:
20100 
      oprot.writeFieldBegin('transactionId', TType.I64, 1)
20101 
      oprot.writeI64(self.transactionId)
20102 
      oprot.writeFieldEnd()
20103 
    if self.refundedBy is not None:
20104 
      oprot.writeFieldBegin('refundedBy', TType.STRING, 2)
20105 
      oprot.writeString(self.refundedBy)
20106 
      oprot.writeFieldEnd()
20107 
    if self.reason is not None:
20108 
      oprot.writeFieldBegin('reason', TType.STRING, 3)
20109 
      oprot.writeString(self.reason)
20110 
      oprot.writeFieldEnd()
20111 
    oprot.writeFieldStop()
20112 
    oprot.writeStructEnd()
20113 
 
20114 
  def validate(self):
20115 
    return
20116 
 
20117 
 
20118 
  def __repr__(self):
20119 
    L = ['%s=%r' % (key, value)
20120 
      for key, value in self.__dict__.iteritems()]
20121 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
20122 
 
20123 
  def __eq__(self, other):
20124 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
20125 
 
20126 
  def __ne__(self, other):
20127 
    return not (self == other)
20128 
 
20129 
class refundTransaction_result:
20130 
  """
20131 
  Attributes:
20132 
   - ex
20133 
  """
20134 
 
20135 
  thrift_spec = (
20136 
    None, # 0
20137 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
20138 
  )
20139 
 
20140 
  def __init__(self, ex=None,):
20141 
    self.ex = ex
20142 
 
20143 
  def read(self, iprot):
20144 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
20145 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
20146 
      return
20147 
    iprot.readStructBegin()
20148 
    while True:
20149 
      (fname, ftype, fid) = iprot.readFieldBegin()
20150 
      if ftype == TType.STOP:
20151 
        break
20152 
      if fid == 1:
20153 
        if ftype == TType.STRUCT:
20154 
          self.ex = TransactionServiceException()
20155 
          self.ex.read(iprot)
20156 
        else:
20157 
          iprot.skip(ftype)
20158 
      else:
20159 
        iprot.skip(ftype)
20160 
      iprot.readFieldEnd()
20161 
    iprot.readStructEnd()
20162 
 
20163 
  def write(self, oprot):
20164 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
20165 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
20166 
      return
20167 
    oprot.writeStructBegin('refundTransaction_result')
20168 
    if self.ex is not None:
20169 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
20170 
      self.ex.write(oprot)
20171 
      oprot.writeFieldEnd()
20172 
    oprot.writeFieldStop()
20173 
    oprot.writeStructEnd()
20174 
 
20175 
  def validate(self):
20176 
    return
20177 
 
20178 
 
20179 
  def __repr__(self):
20180 
    L = ['%s=%r' % (key, value)
20181 
      for key, value in self.__dict__.iteritems()]
20182 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
20183 
 
20184 
  def __eq__(self, other):
20185 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
20186 
 
20187 
  def __ne__(self, other):
20188 
    return not (self == other)
4285 rajveer 20189 
 
4324 mandeep.dh 20190 
class updateShipmentAddress_args:
20191 
  """
20192 
  Attributes:
20193 
   - orderId
20194 
   - addressId
20195 
  """
20196 
 
20197 
  thrift_spec = (
20198 
    None, # 0
20199 
    (1, TType.I64, 'orderId', None, None, ), # 1
20200 
    (2, TType.I64, 'addressId', None, None, ), # 2
20201 
  )
20202 
 
20203 
  def __init__(self, orderId=None, addressId=None,):
20204 
    self.orderId = orderId
20205 
    self.addressId = addressId
20206 
 
20207 
  def read(self, iprot):
20208 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
20209 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
20210 
      return
20211 
    iprot.readStructBegin()
20212 
    while True:
20213 
      (fname, ftype, fid) = iprot.readFieldBegin()
20214 
      if ftype == TType.STOP:
20215 
        break
20216 
      if fid == 1:
20217 
        if ftype == TType.I64:
20218 
          self.orderId = iprot.readI64();
20219 
        else:
20220 
          iprot.skip(ftype)
20221 
      elif fid == 2:
20222 
        if ftype == TType.I64:
20223 
          self.addressId = iprot.readI64();
20224 
        else:
20225 
          iprot.skip(ftype)
20226 
      else:
20227 
        iprot.skip(ftype)
20228 
      iprot.readFieldEnd()
20229 
    iprot.readStructEnd()
20230 
 
20231 
  def write(self, oprot):
20232 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
20233 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
20234 
      return
20235 
    oprot.writeStructBegin('updateShipmentAddress_args')
20236 
    if self.orderId is not None:
20237 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
20238 
      oprot.writeI64(self.orderId)
20239 
      oprot.writeFieldEnd()
20240 
    if self.addressId is not None:
20241 
      oprot.writeFieldBegin('addressId', TType.I64, 2)
20242 
      oprot.writeI64(self.addressId)
20243 
      oprot.writeFieldEnd()
20244 
    oprot.writeFieldStop()
20245 
    oprot.writeStructEnd()
20246 
 
20247 
  def validate(self):
20248 
    return
20249 
 
20250 
 
20251 
  def __repr__(self):
20252 
    L = ['%s=%r' % (key, value)
20253 
      for key, value in self.__dict__.iteritems()]
20254 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
20255 
 
20256 
  def __eq__(self, other):
20257 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
20258 
 
20259 
  def __ne__(self, other):
20260 
    return not (self == other)
20261 
 
20262 
class updateShipmentAddress_result:
20263 
  """
20264 
  Attributes:
20265 
   - ex
20266 
  """
20267 
 
20268 
  thrift_spec = (
20269 
    None, # 0
20270 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
20271 
  )
20272 
 
20273 
  def __init__(self, ex=None,):
20274 
    self.ex = ex
20275 
 
20276 
  def read(self, iprot):
20277 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
20278 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
20279 
      return
20280 
    iprot.readStructBegin()
20281 
    while True:
20282 
      (fname, ftype, fid) = iprot.readFieldBegin()
20283 
      if ftype == TType.STOP:
20284 
        break
20285 
      if fid == 1:
20286 
        if ftype == TType.STRUCT:
20287 
          self.ex = TransactionServiceException()
20288 
          self.ex.read(iprot)
20289 
        else:
20290 
          iprot.skip(ftype)
20291 
      else:
20292 
        iprot.skip(ftype)
20293 
      iprot.readFieldEnd()
20294 
    iprot.readStructEnd()
20295 
 
20296 
  def write(self, oprot):
20297 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
20298 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
20299 
      return
20300 
    oprot.writeStructBegin('updateShipmentAddress_result')
20301 
    if self.ex is not None:
20302 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
20303 
      self.ex.write(oprot)
20304 
      oprot.writeFieldEnd()
20305 
    oprot.writeFieldStop()
20306 
    oprot.writeStructEnd()
20307 
 
20308 
  def validate(self):
20309 
    return
20310 
 
20311 
 
20312 
  def __repr__(self):
20313 
    L = ['%s=%r' % (key, value)
20314 
      for key, value in self.__dict__.iteritems()]
20315 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
20316 
 
20317 
  def __eq__(self, other):
20318 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
20319 
 
20320 
  def __ne__(self, other):
20321 
    return not (self == other)
20322 
 
4285 rajveer 20323 
class acceptOrdersForItemId_args:
20324 
  """
20325 
  Attributes:
20326 
   - itemId
20327 
   - inventory
20328 
  """
20329 
 
20330 
  thrift_spec = (
20331 
    None, # 0
20332 
    (1, TType.I64, 'itemId', None, None, ), # 1
20333 
    (2, TType.I64, 'inventory', None, None, ), # 2
20334 
  )
20335 
 
20336 
  def __init__(self, itemId=None, inventory=None,):
20337 
    self.itemId = itemId
20338 
    self.inventory = inventory
20339 
 
20340 
  def read(self, iprot):
20341 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
20342 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
20343 
      return
20344 
    iprot.readStructBegin()
20345 
    while True:
20346 
      (fname, ftype, fid) = iprot.readFieldBegin()
20347 
      if ftype == TType.STOP:
20348 
        break
20349 
      if fid == 1:
20350 
        if ftype == TType.I64:
20351 
          self.itemId = iprot.readI64();
20352 
        else:
20353 
          iprot.skip(ftype)
20354 
      elif fid == 2:
20355 
        if ftype == TType.I64:
20356 
          self.inventory = iprot.readI64();
20357 
        else:
20358 
          iprot.skip(ftype)
20359 
      else:
20360 
        iprot.skip(ftype)
20361 
      iprot.readFieldEnd()
20362 
    iprot.readStructEnd()
20363 
 
20364 
  def write(self, oprot):
20365 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
20366 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
20367 
      return
20368 
    oprot.writeStructBegin('acceptOrdersForItemId_args')
20369 
    if self.itemId is not None:
20370 
      oprot.writeFieldBegin('itemId', TType.I64, 1)
20371 
      oprot.writeI64(self.itemId)
20372 
      oprot.writeFieldEnd()
20373 
    if self.inventory is not None:
20374 
      oprot.writeFieldBegin('inventory', TType.I64, 2)
20375 
      oprot.writeI64(self.inventory)
20376 
      oprot.writeFieldEnd()
20377 
    oprot.writeFieldStop()
20378 
    oprot.writeStructEnd()
20379 
 
20380 
  def validate(self):
20381 
    return
20382 
 
20383 
 
20384 
  def __repr__(self):
20385 
    L = ['%s=%r' % (key, value)
20386 
      for key, value in self.__dict__.iteritems()]
20387 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
20388 
 
20389 
  def __eq__(self, other):
20390 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
20391 
 
20392 
  def __ne__(self, other):
20393 
    return not (self == other)
20394 
 
20395 
class acceptOrdersForItemId_result:
20396 
  """
20397 
  Attributes:
20398 
   - success
20399 
   - ex
20400 
  """
20401 
 
20402 
  thrift_spec = (
20403 
    (0, TType.BOOL, 'success', None, None, ), # 0
20404 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
20405 
  )
20406 
 
20407 
  def __init__(self, success=None, ex=None,):
20408 
    self.success = success
20409 
    self.ex = ex
20410 
 
20411 
  def read(self, iprot):
20412 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
20413 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
20414 
      return
20415 
    iprot.readStructBegin()
20416 
    while True:
20417 
      (fname, ftype, fid) = iprot.readFieldBegin()
20418 
      if ftype == TType.STOP:
20419 
        break
20420 
      if fid == 0:
20421 
        if ftype == TType.BOOL:
20422 
          self.success = iprot.readBool();
20423 
        else:
20424 
          iprot.skip(ftype)
20425 
      elif fid == 1:
20426 
        if ftype == TType.STRUCT:
20427 
          self.ex = TransactionServiceException()
20428 
          self.ex.read(iprot)
20429 
        else:
20430 
          iprot.skip(ftype)
20431 
      else:
20432 
        iprot.skip(ftype)
20433 
      iprot.readFieldEnd()
20434 
    iprot.readStructEnd()
20435 
 
20436 
  def write(self, oprot):
20437 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
20438 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
20439 
      return
20440 
    oprot.writeStructBegin('acceptOrdersForItemId_result')
20441 
    if self.success is not None:
20442 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
20443 
      oprot.writeBool(self.success)
20444 
      oprot.writeFieldEnd()
20445 
    if self.ex is not None:
20446 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
20447 
      self.ex.write(oprot)
20448 
      oprot.writeFieldEnd()
20449 
    oprot.writeFieldStop()
20450 
    oprot.writeStructEnd()
20451 
 
20452 
  def validate(self):
20453 
    return
20454 
 
20455 
 
20456 
  def __repr__(self):
20457 
    L = ['%s=%r' % (key, value)
20458 
      for key, value in self.__dict__.iteritems()]
20459 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
20460 
 
20461 
  def __eq__(self, other):
20462 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
20463 
 
20464 
  def __ne__(self, other):
20465 
    return not (self == other)
4303 rajveer 20466 
 
20467 
class markOrdersAsPORaised_args:
20468 
  """
20469 
  Attributes:
20470 
   - vendorId
20471 
   - itemId
20472 
   - quantity
20473 
   - estimate
4369 rajveer 20474 
   - isReminder
4303 rajveer 20475 
  """
20476 
 
20477 
  thrift_spec = (
20478 
    None, # 0
20479 
    (1, TType.I64, 'vendorId', None, None, ), # 1
20480 
    (2, TType.I64, 'itemId', None, None, ), # 2
20481 
    (3, TType.I64, 'quantity', None, None, ), # 3
20482 
    (4, TType.I64, 'estimate', None, None, ), # 4
4369 rajveer 20483 
    (5, TType.BOOL, 'isReminder', None, None, ), # 5
4303 rajveer 20484 
  )
20485 
 
4369 rajveer 20486 
  def __init__(self, vendorId=None, itemId=None, quantity=None, estimate=None, isReminder=None,):
4303 rajveer 20487 
    self.vendorId = vendorId
20488 
    self.itemId = itemId
20489 
    self.quantity = quantity
20490 
    self.estimate = estimate
4369 rajveer 20491 
    self.isReminder = isReminder
4303 rajveer 20492 
 
20493 
  def read(self, iprot):
20494 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
20495 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
20496 
      return
20497 
    iprot.readStructBegin()
20498 
    while True:
20499 
      (fname, ftype, fid) = iprot.readFieldBegin()
20500 
      if ftype == TType.STOP:
20501 
        break
20502 
      if fid == 1:
20503 
        if ftype == TType.I64:
20504 
          self.vendorId = iprot.readI64();
20505 
        else:
20506 
          iprot.skip(ftype)
20507 
      elif fid == 2:
20508 
        if ftype == TType.I64:
20509 
          self.itemId = iprot.readI64();
20510 
        else:
20511 
          iprot.skip(ftype)
20512 
      elif fid == 3:
20513 
        if ftype == TType.I64:
20514 
          self.quantity = iprot.readI64();
20515 
        else:
20516 
          iprot.skip(ftype)
20517 
      elif fid == 4:
20518 
        if ftype == TType.I64:
20519 
          self.estimate = iprot.readI64();
20520 
        else:
20521 
          iprot.skip(ftype)
4369 rajveer 20522 
      elif fid == 5:
20523 
        if ftype == TType.BOOL:
20524 
          self.isReminder = iprot.readBool();
20525 
        else:
20526 
          iprot.skip(ftype)
4303 rajveer 20527 
      else:
20528 
        iprot.skip(ftype)
20529 
      iprot.readFieldEnd()
20530 
    iprot.readStructEnd()
20531 
 
20532 
  def write(self, oprot):
20533 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
20534 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
20535 
      return
20536 
    oprot.writeStructBegin('markOrdersAsPORaised_args')
20537 
    if self.vendorId is not None:
20538 
      oprot.writeFieldBegin('vendorId', TType.I64, 1)
20539 
      oprot.writeI64(self.vendorId)
20540 
      oprot.writeFieldEnd()
20541 
    if self.itemId is not None:
20542 
      oprot.writeFieldBegin('itemId', TType.I64, 2)
20543 
      oprot.writeI64(self.itemId)
20544 
      oprot.writeFieldEnd()
20545 
    if self.quantity is not None:
20546 
      oprot.writeFieldBegin('quantity', TType.I64, 3)
20547 
      oprot.writeI64(self.quantity)
20548 
      oprot.writeFieldEnd()
20549 
    if self.estimate is not None:
20550 
      oprot.writeFieldBegin('estimate', TType.I64, 4)
20551 
      oprot.writeI64(self.estimate)
20552 
      oprot.writeFieldEnd()
4369 rajveer 20553 
    if self.isReminder is not None:
20554 
      oprot.writeFieldBegin('isReminder', TType.BOOL, 5)
20555 
      oprot.writeBool(self.isReminder)
20556 
      oprot.writeFieldEnd()
4303 rajveer 20557 
    oprot.writeFieldStop()
20558 
    oprot.writeStructEnd()
20559 
 
20560 
  def validate(self):
20561 
    return
20562 
 
20563 
 
20564 
  def __repr__(self):
20565 
    L = ['%s=%r' % (key, value)
20566 
      for key, value in self.__dict__.iteritems()]
20567 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
20568 
 
20569 
  def __eq__(self, other):
20570 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
20571 
 
20572 
  def __ne__(self, other):
20573 
    return not (self == other)
20574 
 
20575 
class markOrdersAsPORaised_result:
20576 
  """
20577 
  Attributes:
20578 
   - ex
20579 
  """
20580 
 
20581 
  thrift_spec = (
20582 
    None, # 0
20583 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
20584 
  )
20585 
 
20586 
  def __init__(self, ex=None,):
20587 
    self.ex = ex
20588 
 
20589 
  def read(self, iprot):
20590 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
20591 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
20592 
      return
20593 
    iprot.readStructBegin()
20594 
    while True:
20595 
      (fname, ftype, fid) = iprot.readFieldBegin()
20596 
      if ftype == TType.STOP:
20597 
        break
20598 
      if fid == 1:
20599 
        if ftype == TType.STRUCT:
20600 
          self.ex = TransactionServiceException()
20601 
          self.ex.read(iprot)
20602 
        else:
20603 
          iprot.skip(ftype)
20604 
      else:
20605 
        iprot.skip(ftype)
20606 
      iprot.readFieldEnd()
20607 
    iprot.readStructEnd()
20608 
 
20609 
  def write(self, oprot):
20610 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
20611 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
20612 
      return
20613 
    oprot.writeStructBegin('markOrdersAsPORaised_result')
20614 
    if self.ex is not None:
20615 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
20616 
      self.ex.write(oprot)
20617 
      oprot.writeFieldEnd()
20618 
    oprot.writeFieldStop()
20619 
    oprot.writeStructEnd()
20620 
 
20621 
  def validate(self):
20622 
    return
20623 
 
20624 
 
20625 
  def __repr__(self):
20626 
    L = ['%s=%r' % (key, value)
20627 
      for key, value in self.__dict__.iteritems()]
20628 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
20629 
 
20630 
  def __eq__(self, other):
20631 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
20632 
 
20633 
  def __ne__(self, other):
20634 
    return not (self == other)
20635 
 
20636 
class markOrdersAsReversalInitiated_args:
20637 
  """
20638 
  Attributes:
20639 
   - vendorId
20640 
   - itemId
20641 
   - quantity
20642 
   - estimate
4369 rajveer 20643 
   - isReminder
4303 rajveer 20644 
  """
20645 
 
20646 
  thrift_spec = (
20647 
    None, # 0
20648 
    (1, TType.I64, 'vendorId', None, None, ), # 1
20649 
    (2, TType.I64, 'itemId', None, None, ), # 2
20650 
    (3, TType.I64, 'quantity', None, None, ), # 3
20651 
    (4, TType.I64, 'estimate', None, None, ), # 4
4369 rajveer 20652 
    (5, TType.BOOL, 'isReminder', None, None, ), # 5
4303 rajveer 20653 
  )
20654 
 
4369 rajveer 20655 
  def __init__(self, vendorId=None, itemId=None, quantity=None, estimate=None, isReminder=None,):
4303 rajveer 20656 
    self.vendorId = vendorId
20657 
    self.itemId = itemId
20658 
    self.quantity = quantity
20659 
    self.estimate = estimate
4369 rajveer 20660 
    self.isReminder = isReminder
4303 rajveer 20661 
 
20662 
  def read(self, iprot):
20663 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
20664 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
20665 
      return
20666 
    iprot.readStructBegin()
20667 
    while True:
20668 
      (fname, ftype, fid) = iprot.readFieldBegin()
20669 
      if ftype == TType.STOP:
20670 
        break
20671 
      if fid == 1:
20672 
        if ftype == TType.I64:
20673 
          self.vendorId = iprot.readI64();
20674 
        else:
20675 
          iprot.skip(ftype)
20676 
      elif fid == 2:
20677 
        if ftype == TType.I64:
20678 
          self.itemId = iprot.readI64();
20679 
        else:
20680 
          iprot.skip(ftype)
20681 
      elif fid == 3:
20682 
        if ftype == TType.I64:
20683 
          self.quantity = iprot.readI64();
20684 
        else:
20685 
          iprot.skip(ftype)
20686 
      elif fid == 4:
20687 
        if ftype == TType.I64:
20688 
          self.estimate = iprot.readI64();
20689 
        else:
20690 
          iprot.skip(ftype)
4369 rajveer 20691 
      elif fid == 5:
20692 
        if ftype == TType.BOOL:
20693 
          self.isReminder = iprot.readBool();
20694 
        else:
20695 
          iprot.skip(ftype)
4303 rajveer 20696 
      else:
20697 
        iprot.skip(ftype)
20698 
      iprot.readFieldEnd()
20699 
    iprot.readStructEnd()
20700 
 
20701 
  def write(self, oprot):
20702 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
20703 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
20704 
      return
20705 
    oprot.writeStructBegin('markOrdersAsReversalInitiated_args')
20706 
    if self.vendorId is not None:
20707 
      oprot.writeFieldBegin('vendorId', TType.I64, 1)
20708 
      oprot.writeI64(self.vendorId)
20709 
      oprot.writeFieldEnd()
20710 
    if self.itemId is not None:
20711 
      oprot.writeFieldBegin('itemId', TType.I64, 2)
20712 
      oprot.writeI64(self.itemId)
20713 
      oprot.writeFieldEnd()
20714 
    if self.quantity is not None:
20715 
      oprot.writeFieldBegin('quantity', TType.I64, 3)
20716 
      oprot.writeI64(self.quantity)
20717 
      oprot.writeFieldEnd()
20718 
    if self.estimate is not None:
20719 
      oprot.writeFieldBegin('estimate', TType.I64, 4)
20720 
      oprot.writeI64(self.estimate)
20721 
      oprot.writeFieldEnd()
4369 rajveer 20722 
    if self.isReminder is not None:
20723 
      oprot.writeFieldBegin('isReminder', TType.BOOL, 5)
20724 
      oprot.writeBool(self.isReminder)
20725 
      oprot.writeFieldEnd()
4303 rajveer 20726 
    oprot.writeFieldStop()
20727 
    oprot.writeStructEnd()
20728 
 
20729 
  def validate(self):
20730 
    return
20731 
 
20732 
 
20733 
  def __repr__(self):
20734 
    L = ['%s=%r' % (key, value)
20735 
      for key, value in self.__dict__.iteritems()]
20736 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
20737 
 
20738 
  def __eq__(self, other):
20739 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
20740 
 
20741 
  def __ne__(self, other):
20742 
    return not (self == other)
20743 
 
20744 
class markOrdersAsReversalInitiated_result:
20745 
  """
20746 
  Attributes:
20747 
   - ex
20748 
  """
20749 
 
20750 
  thrift_spec = (
20751 
    None, # 0
20752 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
20753 
  )
20754 
 
20755 
  def __init__(self, ex=None,):
20756 
    self.ex = ex
20757 
 
20758 
  def read(self, iprot):
20759 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
20760 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
20761 
      return
20762 
    iprot.readStructBegin()
20763 
    while True:
20764 
      (fname, ftype, fid) = iprot.readFieldBegin()
20765 
      if ftype == TType.STOP:
20766 
        break
20767 
      if fid == 1:
20768 
        if ftype == TType.STRUCT:
20769 
          self.ex = TransactionServiceException()
20770 
          self.ex.read(iprot)
20771 
        else:
20772 
          iprot.skip(ftype)
20773 
      else:
20774 
        iprot.skip(ftype)
20775 
      iprot.readFieldEnd()
20776 
    iprot.readStructEnd()
20777 
 
20778 
  def write(self, oprot):
20779 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
20780 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
20781 
      return
20782 
    oprot.writeStructBegin('markOrdersAsReversalInitiated_result')
20783 
    if self.ex is not None:
20784 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
20785 
      self.ex.write(oprot)
20786 
      oprot.writeFieldEnd()
20787 
    oprot.writeFieldStop()
20788 
    oprot.writeStructEnd()
20789 
 
20790 
  def validate(self):
20791 
    return
20792 
 
20793 
 
20794 
  def __repr__(self):
20795 
    L = ['%s=%r' % (key, value)
20796 
      for key, value in self.__dict__.iteritems()]
20797 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
20798 
 
20799 
  def __eq__(self, other):
20800 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
20801 
 
20802 
  def __ne__(self, other):
20803 
    return not (self == other)
20804 
 
20805 
class markOrdersAsNotAvailabke_args:
20806 
  """
20807 
  Attributes:
20808 
   - vendorId
20809 
   - itemId
20810 
   - quantity
20811 
   - estimate
4369 rajveer 20812 
   - isReminder
4303 rajveer 20813 
  """
20814 
 
20815 
  thrift_spec = (
20816 
    None, # 0
20817 
    (1, TType.I64, 'vendorId', None, None, ), # 1
20818 
    (2, TType.I64, 'itemId', None, None, ), # 2
20819 
    (3, TType.I64, 'quantity', None, None, ), # 3
20820 
    (4, TType.I64, 'estimate', None, None, ), # 4
4369 rajveer 20821 
    (5, TType.BOOL, 'isReminder', None, None, ), # 5
4303 rajveer 20822 
  )
20823 
 
4369 rajveer 20824 
  def __init__(self, vendorId=None, itemId=None, quantity=None, estimate=None, isReminder=None,):
4303 rajveer 20825 
    self.vendorId = vendorId
20826 
    self.itemId = itemId
20827 
    self.quantity = quantity
20828 
    self.estimate = estimate
4369 rajveer 20829 
    self.isReminder = isReminder
4303 rajveer 20830 
 
20831 
  def read(self, iprot):
20832 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
20833 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
20834 
      return
20835 
    iprot.readStructBegin()
20836 
    while True:
20837 
      (fname, ftype, fid) = iprot.readFieldBegin()
20838 
      if ftype == TType.STOP:
20839 
        break
20840 
      if fid == 1:
20841 
        if ftype == TType.I64:
20842 
          self.vendorId = iprot.readI64();
20843 
        else:
20844 
          iprot.skip(ftype)
20845 
      elif fid == 2:
20846 
        if ftype == TType.I64:
20847 
          self.itemId = iprot.readI64();
20848 
        else:
20849 
          iprot.skip(ftype)
20850 
      elif fid == 3:
20851 
        if ftype == TType.I64:
20852 
          self.quantity = iprot.readI64();
20853 
        else:
20854 
          iprot.skip(ftype)
20855 
      elif fid == 4:
20856 
        if ftype == TType.I64:
20857 
          self.estimate = iprot.readI64();
20858 
        else:
20859 
          iprot.skip(ftype)
4369 rajveer 20860 
      elif fid == 5:
20861 
        if ftype == TType.BOOL:
20862 
          self.isReminder = iprot.readBool();
20863 
        else:
20864 
          iprot.skip(ftype)
4303 rajveer 20865 
      else:
20866 
        iprot.skip(ftype)
20867 
      iprot.readFieldEnd()
20868 
    iprot.readStructEnd()
20869 
 
20870 
  def write(self, oprot):
20871 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
20872 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
20873 
      return
20874 
    oprot.writeStructBegin('markOrdersAsNotAvailabke_args')
20875 
    if self.vendorId is not None:
20876 
      oprot.writeFieldBegin('vendorId', TType.I64, 1)
20877 
      oprot.writeI64(self.vendorId)
20878 
      oprot.writeFieldEnd()
20879 
    if self.itemId is not None:
20880 
      oprot.writeFieldBegin('itemId', TType.I64, 2)
20881 
      oprot.writeI64(self.itemId)
20882 
      oprot.writeFieldEnd()
20883 
    if self.quantity is not None:
20884 
      oprot.writeFieldBegin('quantity', TType.I64, 3)
20885 
      oprot.writeI64(self.quantity)
20886 
      oprot.writeFieldEnd()
20887 
    if self.estimate is not None:
20888 
      oprot.writeFieldBegin('estimate', TType.I64, 4)
20889 
      oprot.writeI64(self.estimate)
20890 
      oprot.writeFieldEnd()
4369 rajveer 20891 
    if self.isReminder is not None:
20892 
      oprot.writeFieldBegin('isReminder', TType.BOOL, 5)
20893 
      oprot.writeBool(self.isReminder)
20894 
      oprot.writeFieldEnd()
4303 rajveer 20895 
    oprot.writeFieldStop()
20896 
    oprot.writeStructEnd()
20897 
 
20898 
  def validate(self):
20899 
    return
20900 
 
20901 
 
20902 
  def __repr__(self):
20903 
    L = ['%s=%r' % (key, value)
20904 
      for key, value in self.__dict__.iteritems()]
20905 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
20906 
 
20907 
  def __eq__(self, other):
20908 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
20909 
 
20910 
  def __ne__(self, other):
20911 
    return not (self == other)
20912 
 
20913 
class markOrdersAsNotAvailabke_result:
20914 
  """
20915 
  Attributes:
20916 
   - ex
20917 
  """
20918 
 
20919 
  thrift_spec = (
20920 
    None, # 0
20921 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
20922 
  )
20923 
 
20924 
  def __init__(self, ex=None,):
20925 
    self.ex = ex
20926 
 
20927 
  def read(self, iprot):
20928 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
20929 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
20930 
      return
20931 
    iprot.readStructBegin()
20932 
    while True:
20933 
      (fname, ftype, fid) = iprot.readFieldBegin()
20934 
      if ftype == TType.STOP:
20935 
        break
20936 
      if fid == 1:
20937 
        if ftype == TType.STRUCT:
20938 
          self.ex = TransactionServiceException()
20939 
          self.ex.read(iprot)
20940 
        else:
20941 
          iprot.skip(ftype)
20942 
      else:
20943 
        iprot.skip(ftype)
20944 
      iprot.readFieldEnd()
20945 
    iprot.readStructEnd()
20946 
 
20947 
  def write(self, oprot):
20948 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
20949 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
20950 
      return
20951 
    oprot.writeStructBegin('markOrdersAsNotAvailabke_result')
20952 
    if self.ex is not None:
20953 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
20954 
      self.ex.write(oprot)
20955 
      oprot.writeFieldEnd()
20956 
    oprot.writeFieldStop()
20957 
    oprot.writeStructEnd()
20958 
 
20959 
  def validate(self):
20960 
    return
20961 
 
20962 
 
20963 
  def __repr__(self):
20964 
    L = ['%s=%r' % (key, value)
20965 
      for key, value in self.__dict__.iteritems()]
20966 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
20967 
 
20968 
  def __eq__(self, other):
20969 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
20970 
 
20971 
  def __ne__(self, other):
20972 
    return not (self == other)
4369 rajveer 20973 
 
20974 
class markOrdersAsTimeout_args:
20975 
  """
20976 
  Attributes:
20977 
   - vendorId
20978 
  """
20979 
 
20980 
  thrift_spec = (
20981 
    None, # 0
20982 
    (1, TType.I64, 'vendorId', None, None, ), # 1
20983 
  )
20984 
 
20985 
  def __init__(self, vendorId=None,):
20986 
    self.vendorId = vendorId
20987 
 
20988 
  def read(self, iprot):
20989 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
20990 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
20991 
      return
20992 
    iprot.readStructBegin()
20993 
    while True:
20994 
      (fname, ftype, fid) = iprot.readFieldBegin()
20995 
      if ftype == TType.STOP:
20996 
        break
20997 
      if fid == 1:
20998 
        if ftype == TType.I64:
20999 
          self.vendorId = iprot.readI64();
21000 
        else:
21001 
          iprot.skip(ftype)
21002 
      else:
21003 
        iprot.skip(ftype)
21004 
      iprot.readFieldEnd()
21005 
    iprot.readStructEnd()
21006 
 
21007 
  def write(self, oprot):
21008 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
21009 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
21010 
      return
21011 
    oprot.writeStructBegin('markOrdersAsTimeout_args')
21012 
    if self.vendorId is not None:
21013 
      oprot.writeFieldBegin('vendorId', TType.I64, 1)
21014 
      oprot.writeI64(self.vendorId)
21015 
      oprot.writeFieldEnd()
21016 
    oprot.writeFieldStop()
21017 
    oprot.writeStructEnd()
21018 
 
21019 
  def validate(self):
21020 
    return
21021 
 
21022 
 
21023 
  def __repr__(self):
21024 
    L = ['%s=%r' % (key, value)
21025 
      for key, value in self.__dict__.iteritems()]
21026 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
21027 
 
21028 
  def __eq__(self, other):
21029 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
21030 
 
21031 
  def __ne__(self, other):
21032 
    return not (self == other)
21033 
 
21034 
class markOrdersAsTimeout_result:
21035 
  """
21036 
  Attributes:
21037 
   - success
21038 
   - ex
21039 
  """
21040 
 
21041 
  thrift_spec = (
21042 
    (0, TType.MAP, 'success', (TType.I32,None,TType.STRUCT,(TimeoutSummary, TimeoutSummary.thrift_spec)), None, ), # 0
21043 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
21044 
  )
21045 
 
21046 
  def __init__(self, success=None, ex=None,):
21047 
    self.success = success
21048 
    self.ex = ex
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 == 0:
21060 
        if ftype == TType.MAP:
21061 
          self.success = {}
6000 mandeep.dh 21062 
          (_ktype466, _vtype467, _size465 ) = iprot.readMapBegin()
21063 
          for _i469 in xrange(_size465):
21064 
            _key470 = iprot.readI32();
21065 
            _val471 = TimeoutSummary()
21066 
            _val471.read(iprot)
21067 
            self.success[_key470] = _val471
4369 rajveer 21068 
          iprot.readMapEnd()
21069 
        else:
21070 
          iprot.skip(ftype)
21071 
      elif fid == 1:
21072 
        if ftype == TType.STRUCT:
21073 
          self.ex = TransactionServiceException()
21074 
          self.ex.read(iprot)
21075 
        else:
21076 
          iprot.skip(ftype)
21077 
      else:
21078 
        iprot.skip(ftype)
21079 
      iprot.readFieldEnd()
21080 
    iprot.readStructEnd()
21081 
 
21082 
  def write(self, oprot):
21083 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
21084 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
21085 
      return
21086 
    oprot.writeStructBegin('markOrdersAsTimeout_result')
21087 
    if self.success is not None:
21088 
      oprot.writeFieldBegin('success', TType.MAP, 0)
21089 
      oprot.writeMapBegin(TType.I32, TType.STRUCT, len(self.success))
6000 mandeep.dh 21090 
      for kiter472,viter473 in self.success.items():
21091 
        oprot.writeI32(kiter472)
21092 
        viter473.write(oprot)
4369 rajveer 21093 
      oprot.writeMapEnd()
21094 
      oprot.writeFieldEnd()
21095 
    if self.ex is not None:
21096 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
21097 
      self.ex.write(oprot)
21098 
      oprot.writeFieldEnd()
21099 
    oprot.writeFieldStop()
21100 
    oprot.writeStructEnd()
21101 
 
21102 
  def validate(self):
21103 
    return
21104 
 
21105 
 
21106 
  def __repr__(self):
21107 
    L = ['%s=%r' % (key, value)
21108 
      for key, value in self.__dict__.iteritems()]
21109 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
21110 
 
21111 
  def __eq__(self, other):
21112 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
21113 
 
21114 
  def __ne__(self, other):
21115 
    return not (self == other)
4386 anupam.sin 21116 
 
4662 rajveer 21117 
class markOrderAsLostInTransit_args:
21118 
  """
21119 
  Attributes:
21120 
   - orderId
21121 
  """
21122 
 
21123 
  thrift_spec = (
21124 
    None, # 0
21125 
    (1, TType.I64, 'orderId', None, None, ), # 1
21126 
  )
21127 
 
21128 
  def __init__(self, orderId=None,):
21129 
    self.orderId = orderId
21130 
 
21131 
  def read(self, iprot):
21132 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
21133 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
21134 
      return
21135 
    iprot.readStructBegin()
21136 
    while True:
21137 
      (fname, ftype, fid) = iprot.readFieldBegin()
21138 
      if ftype == TType.STOP:
21139 
        break
21140 
      if fid == 1:
21141 
        if ftype == TType.I64:
21142 
          self.orderId = iprot.readI64();
21143 
        else:
21144 
          iprot.skip(ftype)
21145 
      else:
21146 
        iprot.skip(ftype)
21147 
      iprot.readFieldEnd()
21148 
    iprot.readStructEnd()
21149 
 
21150 
  def write(self, oprot):
21151 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
21152 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
21153 
      return
21154 
    oprot.writeStructBegin('markOrderAsLostInTransit_args')
21155 
    if self.orderId is not None:
21156 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
21157 
      oprot.writeI64(self.orderId)
21158 
      oprot.writeFieldEnd()
21159 
    oprot.writeFieldStop()
21160 
    oprot.writeStructEnd()
21161 
 
21162 
  def validate(self):
21163 
    return
21164 
 
21165 
 
21166 
  def __repr__(self):
21167 
    L = ['%s=%r' % (key, value)
21168 
      for key, value in self.__dict__.iteritems()]
21169 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
21170 
 
21171 
  def __eq__(self, other):
21172 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
21173 
 
21174 
  def __ne__(self, other):
21175 
    return not (self == other)
21176 
 
21177 
class markOrderAsLostInTransit_result:
21178 
  """
21179 
  Attributes:
21180 
   - success
21181 
   - ex
21182 
  """
21183 
 
21184 
  thrift_spec = (
21185 
    (0, TType.BOOL, 'success', None, None, ), # 0
21186 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
21187 
  )
21188 
 
21189 
  def __init__(self, success=None, ex=None,):
21190 
    self.success = success
21191 
    self.ex = ex
21192 
 
21193 
  def read(self, iprot):
21194 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
21195 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
21196 
      return
21197 
    iprot.readStructBegin()
21198 
    while True:
21199 
      (fname, ftype, fid) = iprot.readFieldBegin()
21200 
      if ftype == TType.STOP:
21201 
        break
21202 
      if fid == 0:
21203 
        if ftype == TType.BOOL:
21204 
          self.success = iprot.readBool();
21205 
        else:
21206 
          iprot.skip(ftype)
21207 
      elif fid == 1:
21208 
        if ftype == TType.STRUCT:
21209 
          self.ex = TransactionServiceException()
21210 
          self.ex.read(iprot)
21211 
        else:
21212 
          iprot.skip(ftype)
21213 
      else:
21214 
        iprot.skip(ftype)
21215 
      iprot.readFieldEnd()
21216 
    iprot.readStructEnd()
21217 
 
21218 
  def write(self, oprot):
21219 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
21220 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
21221 
      return
21222 
    oprot.writeStructBegin('markOrderAsLostInTransit_result')
21223 
    if self.success is not None:
21224 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
21225 
      oprot.writeBool(self.success)
21226 
      oprot.writeFieldEnd()
21227 
    if self.ex is not None:
21228 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
21229 
      self.ex.write(oprot)
21230 
      oprot.writeFieldEnd()
21231 
    oprot.writeFieldStop()
21232 
    oprot.writeStructEnd()
21233 
 
21234 
  def validate(self):
21235 
    return
21236 
 
21237 
 
21238 
  def __repr__(self):
21239 
    L = ['%s=%r' % (key, value)
21240 
      for key, value in self.__dict__.iteritems()]
21241 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
21242 
 
21243 
  def __eq__(self, other):
21244 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
21245 
 
21246 
  def __ne__(self, other):
21247 
    return not (self == other)
21248 
 
4386 anupam.sin 21249 
class getOrderForAwb_args:
21250 
  """
21251 
  Attributes:
21252 
   - awb
21253 
  """
21254 
 
21255 
  thrift_spec = (
21256 
    None, # 0
21257 
    (1, TType.STRING, 'awb', None, None, ), # 1
21258 
  )
21259 
 
21260 
  def __init__(self, awb=None,):
21261 
    self.awb = awb
21262 
 
21263 
  def read(self, iprot):
21264 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
21265 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
21266 
      return
21267 
    iprot.readStructBegin()
21268 
    while True:
21269 
      (fname, ftype, fid) = iprot.readFieldBegin()
21270 
      if ftype == TType.STOP:
21271 
        break
21272 
      if fid == 1:
21273 
        if ftype == TType.STRING:
21274 
          self.awb = iprot.readString();
21275 
        else:
21276 
          iprot.skip(ftype)
21277 
      else:
21278 
        iprot.skip(ftype)
21279 
      iprot.readFieldEnd()
21280 
    iprot.readStructEnd()
21281 
 
21282 
  def write(self, oprot):
21283 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
21284 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
21285 
      return
21286 
    oprot.writeStructBegin('getOrderForAwb_args')
21287 
    if self.awb is not None:
21288 
      oprot.writeFieldBegin('awb', TType.STRING, 1)
21289 
      oprot.writeString(self.awb)
21290 
      oprot.writeFieldEnd()
21291 
    oprot.writeFieldStop()
21292 
    oprot.writeStructEnd()
21293 
 
21294 
  def validate(self):
21295 
    return
21296 
 
21297 
 
21298 
  def __repr__(self):
21299 
    L = ['%s=%r' % (key, value)
21300 
      for key, value in self.__dict__.iteritems()]
21301 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
21302 
 
21303 
  def __eq__(self, other):
21304 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
21305 
 
21306 
  def __ne__(self, other):
21307 
    return not (self == other)
21308 
 
21309 
class getOrderForAwb_result:
21310 
  """
21311 
  Attributes:
21312 
   - success
21313 
   - ex
21314 
  """
21315 
 
21316 
  thrift_spec = (
21317 
    (0, TType.STRUCT, 'success', (Order, Order.thrift_spec), None, ), # 0
21318 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
21319 
  )
21320 
 
21321 
  def __init__(self, success=None, ex=None,):
21322 
    self.success = success
21323 
    self.ex = ex
21324 
 
21325 
  def read(self, iprot):
21326 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
21327 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
21328 
      return
21329 
    iprot.readStructBegin()
21330 
    while True:
21331 
      (fname, ftype, fid) = iprot.readFieldBegin()
21332 
      if ftype == TType.STOP:
21333 
        break
21334 
      if fid == 0:
21335 
        if ftype == TType.STRUCT:
21336 
          self.success = Order()
21337 
          self.success.read(iprot)
21338 
        else:
21339 
          iprot.skip(ftype)
21340 
      elif fid == 1:
21341 
        if ftype == TType.STRUCT:
21342 
          self.ex = TransactionServiceException()
21343 
          self.ex.read(iprot)
21344 
        else:
21345 
          iprot.skip(ftype)
21346 
      else:
21347 
        iprot.skip(ftype)
21348 
      iprot.readFieldEnd()
21349 
    iprot.readStructEnd()
21350 
 
21351 
  def write(self, oprot):
21352 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
21353 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
21354 
      return
21355 
    oprot.writeStructBegin('getOrderForAwb_result')
21356 
    if self.success is not None:
21357 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
21358 
      self.success.write(oprot)
21359 
      oprot.writeFieldEnd()
21360 
    if self.ex is not None:
21361 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
21362 
      self.ex.write(oprot)
21363 
      oprot.writeFieldEnd()
21364 
    oprot.writeFieldStop()
21365 
    oprot.writeStructEnd()
21366 
 
21367 
  def validate(self):
21368 
    return
21369 
 
21370 
 
21371 
  def __repr__(self):
21372 
    L = ['%s=%r' % (key, value)
21373 
      for key, value in self.__dict__.iteritems()]
21374 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
21375 
 
21376 
  def __eq__(self, other):
21377 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
21378 
 
21379 
  def __ne__(self, other):
21380 
    return not (self == other)
4506 phani.kuma 21381 
 
21382 
class getOrdersForProviderForStatus_args:
21383 
  """
21384 
  Attributes:
21385 
   - logistics_provider_id
4910 phani.kuma 21386 
   - order_status_list
4506 phani.kuma 21387 
  """
21388 
 
21389 
  thrift_spec = (
21390 
    None, # 0
21391 
    (1, TType.I64, 'logistics_provider_id', None, None, ), # 1
4910 phani.kuma 21392 
    (2, TType.LIST, 'order_status_list', (TType.I32,None), None, ), # 2
4506 phani.kuma 21393 
  )
21394 
 
4910 phani.kuma 21395 
  def __init__(self, logistics_provider_id=None, order_status_list=None,):
4506 phani.kuma 21396 
    self.logistics_provider_id = logistics_provider_id
4910 phani.kuma 21397 
    self.order_status_list = order_status_list
4506 phani.kuma 21398 
 
21399 
  def read(self, iprot):
21400 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
21401 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
21402 
      return
21403 
    iprot.readStructBegin()
21404 
    while True:
21405 
      (fname, ftype, fid) = iprot.readFieldBegin()
21406 
      if ftype == TType.STOP:
21407 
        break
21408 
      if fid == 1:
21409 
        if ftype == TType.I64:
21410 
          self.logistics_provider_id = iprot.readI64();
21411 
        else:
21412 
          iprot.skip(ftype)
21413 
      elif fid == 2:
4910 phani.kuma 21414 
        if ftype == TType.LIST:
21415 
          self.order_status_list = []
6000 mandeep.dh 21416 
          (_etype477, _size474) = iprot.readListBegin()
21417 
          for _i478 in xrange(_size474):
21418 
            _elem479 = iprot.readI32();
21419 
            self.order_status_list.append(_elem479)
4910 phani.kuma 21420 
          iprot.readListEnd()
4506 phani.kuma 21421 
        else:
21422 
          iprot.skip(ftype)
21423 
      else:
21424 
        iprot.skip(ftype)
21425 
      iprot.readFieldEnd()
21426 
    iprot.readStructEnd()
21427 
 
21428 
  def write(self, oprot):
21429 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
21430 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
21431 
      return
21432 
    oprot.writeStructBegin('getOrdersForProviderForStatus_args')
21433 
    if self.logistics_provider_id is not None:
21434 
      oprot.writeFieldBegin('logistics_provider_id', TType.I64, 1)
21435 
      oprot.writeI64(self.logistics_provider_id)
21436 
      oprot.writeFieldEnd()
4910 phani.kuma 21437 
    if self.order_status_list is not None:
21438 
      oprot.writeFieldBegin('order_status_list', TType.LIST, 2)
21439 
      oprot.writeListBegin(TType.I32, len(self.order_status_list))
6000 mandeep.dh 21440 
      for iter480 in self.order_status_list:
21441 
        oprot.writeI32(iter480)
4910 phani.kuma 21442 
      oprot.writeListEnd()
4506 phani.kuma 21443 
      oprot.writeFieldEnd()
21444 
    oprot.writeFieldStop()
21445 
    oprot.writeStructEnd()
21446 
 
21447 
  def validate(self):
21448 
    return
21449 
 
21450 
 
21451 
  def __repr__(self):
21452 
    L = ['%s=%r' % (key, value)
21453 
      for key, value in self.__dict__.iteritems()]
21454 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
21455 
 
21456 
  def __eq__(self, other):
21457 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
21458 
 
21459 
  def __ne__(self, other):
21460 
    return not (self == other)
21461 
 
21462 
class getOrdersForProviderForStatus_result:
21463 
  """
21464 
  Attributes:
21465 
   - success
21466 
   - ex
21467 
  """
21468 
 
21469 
  thrift_spec = (
21470 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
21471 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
21472 
  )
21473 
 
21474 
  def __init__(self, success=None, ex=None,):
21475 
    self.success = success
21476 
    self.ex = ex
21477 
 
21478 
  def read(self, iprot):
21479 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
21480 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
21481 
      return
21482 
    iprot.readStructBegin()
21483 
    while True:
21484 
      (fname, ftype, fid) = iprot.readFieldBegin()
21485 
      if ftype == TType.STOP:
21486 
        break
21487 
      if fid == 0:
21488 
        if ftype == TType.LIST:
21489 
          self.success = []
6000 mandeep.dh 21490 
          (_etype484, _size481) = iprot.readListBegin()
21491 
          for _i485 in xrange(_size481):
21492 
            _elem486 = Order()
21493 
            _elem486.read(iprot)
21494 
            self.success.append(_elem486)
4506 phani.kuma 21495 
          iprot.readListEnd()
21496 
        else:
21497 
          iprot.skip(ftype)
21498 
      elif fid == 1:
21499 
        if ftype == TType.STRUCT:
21500 
          self.ex = TransactionServiceException()
21501 
          self.ex.read(iprot)
21502 
        else:
21503 
          iprot.skip(ftype)
21504 
      else:
21505 
        iprot.skip(ftype)
21506 
      iprot.readFieldEnd()
21507 
    iprot.readStructEnd()
21508 
 
21509 
  def write(self, oprot):
21510 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
21511 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
21512 
      return
21513 
    oprot.writeStructBegin('getOrdersForProviderForStatus_result')
21514 
    if self.success is not None:
21515 
      oprot.writeFieldBegin('success', TType.LIST, 0)
21516 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
6000 mandeep.dh 21517 
      for iter487 in self.success:
21518 
        iter487.write(oprot)
4506 phani.kuma 21519 
      oprot.writeListEnd()
21520 
      oprot.writeFieldEnd()
21521 
    if self.ex is not None:
21522 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
21523 
      self.ex.write(oprot)
21524 
      oprot.writeFieldEnd()
21525 
    oprot.writeFieldStop()
21526 
    oprot.writeStructEnd()
21527 
 
21528 
  def validate(self):
21529 
    return
21530 
 
21531 
 
21532 
  def __repr__(self):
21533 
    L = ['%s=%r' % (key, value)
21534 
      for key, value in self.__dict__.iteritems()]
21535 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
21536 
 
21537 
  def __eq__(self, other):
21538 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
21539 
 
21540 
  def __ne__(self, other):
21541 
    return not (self == other)
4600 varun.gupt 21542 
 
21543 
class getBilledOrdersForVendor_args:
21544 
  """
21545 
  Attributes:
21546 
   - vendorId
21547 
   - billingDateFrom
21548 
   - billingDateTo
21549 
  """
21550 
 
21551 
  thrift_spec = (
21552 
    None, # 0
21553 
    (1, TType.I64, 'vendorId', None, None, ), # 1
21554 
    (2, TType.I64, 'billingDateFrom', None, None, ), # 2
21555 
    (3, TType.I64, 'billingDateTo', None, None, ), # 3
21556 
  )
21557 
 
21558 
  def __init__(self, vendorId=None, billingDateFrom=None, billingDateTo=None,):
21559 
    self.vendorId = vendorId
21560 
    self.billingDateFrom = billingDateFrom
21561 
    self.billingDateTo = billingDateTo
21562 
 
21563 
  def read(self, iprot):
21564 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
21565 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
21566 
      return
21567 
    iprot.readStructBegin()
21568 
    while True:
21569 
      (fname, ftype, fid) = iprot.readFieldBegin()
21570 
      if ftype == TType.STOP:
21571 
        break
21572 
      if fid == 1:
21573 
        if ftype == TType.I64:
21574 
          self.vendorId = iprot.readI64();
21575 
        else:
21576 
          iprot.skip(ftype)
21577 
      elif fid == 2:
21578 
        if ftype == TType.I64:
21579 
          self.billingDateFrom = iprot.readI64();
21580 
        else:
21581 
          iprot.skip(ftype)
21582 
      elif fid == 3:
21583 
        if ftype == TType.I64:
21584 
          self.billingDateTo = iprot.readI64();
21585 
        else:
21586 
          iprot.skip(ftype)
21587 
      else:
21588 
        iprot.skip(ftype)
21589 
      iprot.readFieldEnd()
21590 
    iprot.readStructEnd()
21591 
 
21592 
  def write(self, oprot):
21593 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
21594 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
21595 
      return
21596 
    oprot.writeStructBegin('getBilledOrdersForVendor_args')
21597 
    if self.vendorId is not None:
21598 
      oprot.writeFieldBegin('vendorId', TType.I64, 1)
21599 
      oprot.writeI64(self.vendorId)
21600 
      oprot.writeFieldEnd()
21601 
    if self.billingDateFrom is not None:
21602 
      oprot.writeFieldBegin('billingDateFrom', TType.I64, 2)
21603 
      oprot.writeI64(self.billingDateFrom)
21604 
      oprot.writeFieldEnd()
21605 
    if self.billingDateTo is not None:
21606 
      oprot.writeFieldBegin('billingDateTo', TType.I64, 3)
21607 
      oprot.writeI64(self.billingDateTo)
21608 
      oprot.writeFieldEnd()
21609 
    oprot.writeFieldStop()
21610 
    oprot.writeStructEnd()
21611 
 
21612 
  def validate(self):
21613 
    return
21614 
 
21615 
 
21616 
  def __repr__(self):
21617 
    L = ['%s=%r' % (key, value)
21618 
      for key, value in self.__dict__.iteritems()]
21619 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
21620 
 
21621 
  def __eq__(self, other):
21622 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
21623 
 
21624 
  def __ne__(self, other):
21625 
    return not (self == other)
21626 
 
21627 
class getBilledOrdersForVendor_result:
21628 
  """
21629 
  Attributes:
21630 
   - success
21631 
   - ex
21632 
  """
21633 
 
21634 
  thrift_spec = (
21635 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
21636 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
21637 
  )
21638 
 
21639 
  def __init__(self, success=None, ex=None,):
21640 
    self.success = success
21641 
    self.ex = ex
21642 
 
21643 
  def read(self, iprot):
21644 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
21645 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
21646 
      return
21647 
    iprot.readStructBegin()
21648 
    while True:
21649 
      (fname, ftype, fid) = iprot.readFieldBegin()
21650 
      if ftype == TType.STOP:
21651 
        break
21652 
      if fid == 0:
21653 
        if ftype == TType.LIST:
21654 
          self.success = []
6000 mandeep.dh 21655 
          (_etype491, _size488) = iprot.readListBegin()
21656 
          for _i492 in xrange(_size488):
21657 
            _elem493 = Order()
21658 
            _elem493.read(iprot)
21659 
            self.success.append(_elem493)
4600 varun.gupt 21660 
          iprot.readListEnd()
21661 
        else:
21662 
          iprot.skip(ftype)
21663 
      elif fid == 1:
21664 
        if ftype == TType.STRUCT:
21665 
          self.ex = TransactionServiceException()
21666 
          self.ex.read(iprot)
21667 
        else:
21668 
          iprot.skip(ftype)
21669 
      else:
21670 
        iprot.skip(ftype)
21671 
      iprot.readFieldEnd()
21672 
    iprot.readStructEnd()
21673 
 
21674 
  def write(self, oprot):
21675 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
21676 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
21677 
      return
21678 
    oprot.writeStructBegin('getBilledOrdersForVendor_result')
21679 
    if self.success is not None:
21680 
      oprot.writeFieldBegin('success', TType.LIST, 0)
21681 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
6000 mandeep.dh 21682 
      for iter494 in self.success:
21683 
        iter494.write(oprot)
4600 varun.gupt 21684 
      oprot.writeListEnd()
21685 
      oprot.writeFieldEnd()
21686 
    if self.ex is not None:
21687 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
21688 
      self.ex.write(oprot)
21689 
      oprot.writeFieldEnd()
21690 
    oprot.writeFieldStop()
21691 
    oprot.writeStructEnd()
21692 
 
21693 
  def validate(self):
21694 
    return
21695 
 
21696 
 
21697 
  def __repr__(self):
21698 
    L = ['%s=%r' % (key, value)
21699 
      for key, value in self.__dict__.iteritems()]
21700 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
21701 
 
21702 
  def __eq__(self, other):
21703 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
21704 
 
21705 
  def __ne__(self, other):
21706 
    return not (self == other)
21707 
 
4607 rajveer 21708 
class getSlippedSippingDateOrders_args:
21709 
 
21710 
  thrift_spec = (
21711 
  )
21712 
 
21713 
  def read(self, iprot):
21714 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
21715 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
21716 
      return
21717 
    iprot.readStructBegin()
21718 
    while True:
21719 
      (fname, ftype, fid) = iprot.readFieldBegin()
21720 
      if ftype == TType.STOP:
21721 
        break
21722 
      else:
21723 
        iprot.skip(ftype)
21724 
      iprot.readFieldEnd()
21725 
    iprot.readStructEnd()
21726 
 
21727 
  def write(self, oprot):
21728 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
21729 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
21730 
      return
21731 
    oprot.writeStructBegin('getSlippedSippingDateOrders_args')
21732 
    oprot.writeFieldStop()
21733 
    oprot.writeStructEnd()
21734 
 
21735 
  def validate(self):
21736 
    return
21737 
 
21738 
 
21739 
  def __repr__(self):
21740 
    L = ['%s=%r' % (key, value)
21741 
      for key, value in self.__dict__.iteritems()]
21742 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
21743 
 
21744 
  def __eq__(self, other):
21745 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
21746 
 
21747 
  def __ne__(self, other):
21748 
    return not (self == other)
21749 
 
21750 
class getSlippedSippingDateOrders_result:
21751 
  """
21752 
  Attributes:
21753 
   - success
21754 
   - ex
21755 
  """
21756 
 
21757 
  thrift_spec = (
21758 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
21759 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
21760 
  )
21761 
 
21762 
  def __init__(self, success=None, ex=None,):
21763 
    self.success = success
21764 
    self.ex = ex
21765 
 
21766 
  def read(self, iprot):
21767 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
21768 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
21769 
      return
21770 
    iprot.readStructBegin()
21771 
    while True:
21772 
      (fname, ftype, fid) = iprot.readFieldBegin()
21773 
      if ftype == TType.STOP:
21774 
        break
21775 
      if fid == 0:
21776 
        if ftype == TType.LIST:
21777 
          self.success = []
6000 mandeep.dh 21778 
          (_etype498, _size495) = iprot.readListBegin()
21779 
          for _i499 in xrange(_size495):
21780 
            _elem500 = Order()
21781 
            _elem500.read(iprot)
21782 
            self.success.append(_elem500)
4607 rajveer 21783 
          iprot.readListEnd()
21784 
        else:
21785 
          iprot.skip(ftype)
21786 
      elif fid == 1:
21787 
        if ftype == TType.STRUCT:
21788 
          self.ex = TransactionServiceException()
21789 
          self.ex.read(iprot)
21790 
        else:
21791 
          iprot.skip(ftype)
21792 
      else:
21793 
        iprot.skip(ftype)
21794 
      iprot.readFieldEnd()
21795 
    iprot.readStructEnd()
21796 
 
21797 
  def write(self, oprot):
21798 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
21799 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
21800 
      return
21801 
    oprot.writeStructBegin('getSlippedSippingDateOrders_result')
21802 
    if self.success is not None:
21803 
      oprot.writeFieldBegin('success', TType.LIST, 0)
21804 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
6000 mandeep.dh 21805 
      for iter501 in self.success:
21806 
        iter501.write(oprot)
4607 rajveer 21807 
      oprot.writeListEnd()
21808 
      oprot.writeFieldEnd()
21809 
    if self.ex is not None:
21810 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
21811 
      self.ex.write(oprot)
21812 
      oprot.writeFieldEnd()
21813 
    oprot.writeFieldStop()
21814 
    oprot.writeStructEnd()
21815 
 
21816 
  def validate(self):
21817 
    return
21818 
 
21819 
 
21820 
  def __repr__(self):
21821 
    L = ['%s=%r' % (key, value)
21822 
      for key, value in self.__dict__.iteritems()]
21823 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
21824 
 
21825 
  def __eq__(self, other):
21826 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
21827 
 
21828 
  def __ne__(self, other):
21829 
    return not (self == other)
21830 
 
4709 rajveer 21831 
class getCancelledOrders_args:
21832 
  """
21833 
  Attributes:
21834 
   - cancelDateFrom
21835 
   - cancelDateTo
21836 
  """
21837 
 
21838 
  thrift_spec = (
21839 
    None, # 0
21840 
    (1, TType.I64, 'cancelDateFrom', None, None, ), # 1
21841 
    (2, TType.I64, 'cancelDateTo', None, None, ), # 2
21842 
  )
21843 
 
21844 
  def __init__(self, cancelDateFrom=None, cancelDateTo=None,):
21845 
    self.cancelDateFrom = cancelDateFrom
21846 
    self.cancelDateTo = cancelDateTo
21847 
 
21848 
  def read(self, iprot):
21849 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
21850 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
21851 
      return
21852 
    iprot.readStructBegin()
21853 
    while True:
21854 
      (fname, ftype, fid) = iprot.readFieldBegin()
21855 
      if ftype == TType.STOP:
21856 
        break
21857 
      if fid == 1:
21858 
        if ftype == TType.I64:
21859 
          self.cancelDateFrom = iprot.readI64();
21860 
        else:
21861 
          iprot.skip(ftype)
21862 
      elif fid == 2:
21863 
        if ftype == TType.I64:
21864 
          self.cancelDateTo = iprot.readI64();
21865 
        else:
21866 
          iprot.skip(ftype)
21867 
      else:
21868 
        iprot.skip(ftype)
21869 
      iprot.readFieldEnd()
21870 
    iprot.readStructEnd()
21871 
 
21872 
  def write(self, oprot):
21873 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
21874 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
21875 
      return
21876 
    oprot.writeStructBegin('getCancelledOrders_args')
21877 
    if self.cancelDateFrom is not None:
21878 
      oprot.writeFieldBegin('cancelDateFrom', TType.I64, 1)
21879 
      oprot.writeI64(self.cancelDateFrom)
21880 
      oprot.writeFieldEnd()
21881 
    if self.cancelDateTo is not None:
21882 
      oprot.writeFieldBegin('cancelDateTo', TType.I64, 2)
21883 
      oprot.writeI64(self.cancelDateTo)
21884 
      oprot.writeFieldEnd()
21885 
    oprot.writeFieldStop()
21886 
    oprot.writeStructEnd()
21887 
 
21888 
  def validate(self):
21889 
    return
21890 
 
21891 
 
21892 
  def __repr__(self):
21893 
    L = ['%s=%r' % (key, value)
21894 
      for key, value in self.__dict__.iteritems()]
21895 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
21896 
 
21897 
  def __eq__(self, other):
21898 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
21899 
 
21900 
  def __ne__(self, other):
21901 
    return not (self == other)
21902 
 
21903 
class getCancelledOrders_result:
21904 
  """
21905 
  Attributes:
21906 
   - success
21907 
   - ex
21908 
  """
21909 
 
21910 
  thrift_spec = (
21911 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
21912 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
21913 
  )
21914 
 
21915 
  def __init__(self, success=None, ex=None,):
21916 
    self.success = success
21917 
    self.ex = ex
21918 
 
21919 
  def read(self, iprot):
21920 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
21921 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
21922 
      return
21923 
    iprot.readStructBegin()
21924 
    while True:
21925 
      (fname, ftype, fid) = iprot.readFieldBegin()
21926 
      if ftype == TType.STOP:
21927 
        break
21928 
      if fid == 0:
21929 
        if ftype == TType.LIST:
21930 
          self.success = []
6000 mandeep.dh 21931 
          (_etype505, _size502) = iprot.readListBegin()
21932 
          for _i506 in xrange(_size502):
21933 
            _elem507 = Order()
21934 
            _elem507.read(iprot)
21935 
            self.success.append(_elem507)
4709 rajveer 21936 
          iprot.readListEnd()
21937 
        else:
21938 
          iprot.skip(ftype)
21939 
      elif fid == 1:
21940 
        if ftype == TType.STRUCT:
21941 
          self.ex = TransactionServiceException()
21942 
          self.ex.read(iprot)
21943 
        else:
21944 
          iprot.skip(ftype)
21945 
      else:
21946 
        iprot.skip(ftype)
21947 
      iprot.readFieldEnd()
21948 
    iprot.readStructEnd()
21949 
 
21950 
  def write(self, oprot):
21951 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
21952 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
21953 
      return
21954 
    oprot.writeStructBegin('getCancelledOrders_result')
21955 
    if self.success is not None:
21956 
      oprot.writeFieldBegin('success', TType.LIST, 0)
21957 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
6000 mandeep.dh 21958 
      for iter508 in self.success:
21959 
        iter508.write(oprot)
4709 rajveer 21960 
      oprot.writeListEnd()
21961 
      oprot.writeFieldEnd()
21962 
    if self.ex is not None:
21963 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
21964 
      self.ex.write(oprot)
21965 
      oprot.writeFieldEnd()
21966 
    oprot.writeFieldStop()
21967 
    oprot.writeStructEnd()
21968 
 
21969 
  def validate(self):
21970 
    return
21971 
 
21972 
 
21973 
  def __repr__(self):
21974 
    L = ['%s=%r' % (key, value)
21975 
      for key, value in self.__dict__.iteritems()]
21976 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
21977 
 
21978 
  def __eq__(self, other):
21979 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
21980 
 
21981 
  def __ne__(self, other):
21982 
    return not (self == other)
21983 
 
4600 varun.gupt 21984 
class saveBluedartSettlements_args:
21985 
  """
21986 
  Attributes:
21987 
   - mapAWBAndAmount
21988 
  """
21989 
 
21990 
  thrift_spec = (
21991 
    None, # 0
21992 
    (1, TType.MAP, 'mapAWBAndAmount', (TType.I64,None,TType.DOUBLE,None), None, ), # 1
21993 
  )
21994 
 
21995 
  def __init__(self, mapAWBAndAmount=None,):
21996 
    self.mapAWBAndAmount = mapAWBAndAmount
21997 
 
21998 
  def read(self, iprot):
21999 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
22000 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
22001 
      return
22002 
    iprot.readStructBegin()
22003 
    while True:
22004 
      (fname, ftype, fid) = iprot.readFieldBegin()
22005 
      if ftype == TType.STOP:
22006 
        break
22007 
      if fid == 1:
22008 
        if ftype == TType.MAP:
22009 
          self.mapAWBAndAmount = {}
6000 mandeep.dh 22010 
          (_ktype510, _vtype511, _size509 ) = iprot.readMapBegin()
22011 
          for _i513 in xrange(_size509):
22012 
            _key514 = iprot.readI64();
22013 
            _val515 = iprot.readDouble();
22014 
            self.mapAWBAndAmount[_key514] = _val515
4600 varun.gupt 22015 
          iprot.readMapEnd()
22016 
        else:
22017 
          iprot.skip(ftype)
22018 
      else:
22019 
        iprot.skip(ftype)
22020 
      iprot.readFieldEnd()
22021 
    iprot.readStructEnd()
22022 
 
22023 
  def write(self, oprot):
22024 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
22025 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
22026 
      return
22027 
    oprot.writeStructBegin('saveBluedartSettlements_args')
22028 
    if self.mapAWBAndAmount is not None:
22029 
      oprot.writeFieldBegin('mapAWBAndAmount', TType.MAP, 1)
22030 
      oprot.writeMapBegin(TType.I64, TType.DOUBLE, len(self.mapAWBAndAmount))
6000 mandeep.dh 22031 
      for kiter516,viter517 in self.mapAWBAndAmount.items():
22032 
        oprot.writeI64(kiter516)
22033 
        oprot.writeDouble(viter517)
4600 varun.gupt 22034 
      oprot.writeMapEnd()
22035 
      oprot.writeFieldEnd()
22036 
    oprot.writeFieldStop()
22037 
    oprot.writeStructEnd()
22038 
 
22039 
  def validate(self):
22040 
    return
22041 
 
22042 
 
22043 
  def __repr__(self):
22044 
    L = ['%s=%r' % (key, value)
22045 
      for key, value in self.__dict__.iteritems()]
22046 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
22047 
 
22048 
  def __eq__(self, other):
22049 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
22050 
 
22051 
  def __ne__(self, other):
22052 
    return not (self == other)
22053 
 
22054 
class saveBluedartSettlements_result:
22055 
  """
22056 
  Attributes:
22057 
   - ex
22058 
  """
22059 
 
22060 
  thrift_spec = (
22061 
    None, # 0
22062 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
22063 
  )
22064 
 
22065 
  def __init__(self, ex=None,):
22066 
    self.ex = ex
22067 
 
22068 
  def read(self, iprot):
22069 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
22070 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
22071 
      return
22072 
    iprot.readStructBegin()
22073 
    while True:
22074 
      (fname, ftype, fid) = iprot.readFieldBegin()
22075 
      if ftype == TType.STOP:
22076 
        break
22077 
      if fid == 1:
22078 
        if ftype == TType.STRUCT:
22079 
          self.ex = TransactionServiceException()
22080 
          self.ex.read(iprot)
22081 
        else:
22082 
          iprot.skip(ftype)
22083 
      else:
22084 
        iprot.skip(ftype)
22085 
      iprot.readFieldEnd()
22086 
    iprot.readStructEnd()
22087 
 
22088 
  def write(self, oprot):
22089 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
22090 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
22091 
      return
22092 
    oprot.writeStructBegin('saveBluedartSettlements_result')
22093 
    if self.ex is not None:
22094 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
22095 
      self.ex.write(oprot)
22096 
      oprot.writeFieldEnd()
22097 
    oprot.writeFieldStop()
22098 
    oprot.writeStructEnd()
22099 
 
22100 
  def validate(self):
22101 
    return
22102 
 
22103 
 
22104 
  def __repr__(self):
22105 
    L = ['%s=%r' % (key, value)
22106 
      for key, value in self.__dict__.iteritems()]
22107 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
22108 
 
22109 
  def __eq__(self, other):
22110 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
22111 
 
22112 
  def __ne__(self, other):
22113 
    return not (self == other)
22114 
 
22115 
class savePaymentSettlements_args:
22116 
  """
22117 
  Attributes:
22118 
   - settlementDate
22119 
   - paymentGatewayId
4905 varun.gupt 22120 
   - referenceId
4600 varun.gupt 22121 
   - serviceTax
22122 
   - otherCharges
22123 
   - netCollection
22124 
  """
22125 
 
22126 
  thrift_spec = (
22127 
    None, # 0
22128 
    (1, TType.I64, 'settlementDate', None, None, ), # 1
22129 
    (2, TType.I64, 'paymentGatewayId', None, None, ), # 2
4905 varun.gupt 22130 
    (3, TType.I64, 'referenceId', None, None, ), # 3
4600 varun.gupt 22131 
    (4, TType.DOUBLE, 'serviceTax', None, None, ), # 4
22132 
    (5, TType.DOUBLE, 'otherCharges', None, None, ), # 5
22133 
    (6, TType.DOUBLE, 'netCollection', None, None, ), # 6
22134 
  )
22135 
 
4905 varun.gupt 22136 
  def __init__(self, settlementDate=None, paymentGatewayId=None, referenceId=None, serviceTax=None, otherCharges=None, netCollection=None,):
4600 varun.gupt 22137 
    self.settlementDate = settlementDate
22138 
    self.paymentGatewayId = paymentGatewayId
4905 varun.gupt 22139 
    self.referenceId = referenceId
4600 varun.gupt 22140 
    self.serviceTax = serviceTax
22141 
    self.otherCharges = otherCharges
22142 
    self.netCollection = netCollection
22143 
 
22144 
  def read(self, iprot):
22145 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
22146 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
22147 
      return
22148 
    iprot.readStructBegin()
22149 
    while True:
22150 
      (fname, ftype, fid) = iprot.readFieldBegin()
22151 
      if ftype == TType.STOP:
22152 
        break
22153 
      if fid == 1:
22154 
        if ftype == TType.I64:
22155 
          self.settlementDate = iprot.readI64();
22156 
        else:
22157 
          iprot.skip(ftype)
22158 
      elif fid == 2:
22159 
        if ftype == TType.I64:
22160 
          self.paymentGatewayId = iprot.readI64();
22161 
        else:
22162 
          iprot.skip(ftype)
22163 
      elif fid == 3:
22164 
        if ftype == TType.I64:
4905 varun.gupt 22165 
          self.referenceId = iprot.readI64();
4600 varun.gupt 22166 
        else:
22167 
          iprot.skip(ftype)
22168 
      elif fid == 4:
22169 
        if ftype == TType.DOUBLE:
22170 
          self.serviceTax = iprot.readDouble();
22171 
        else:
22172 
          iprot.skip(ftype)
22173 
      elif fid == 5:
22174 
        if ftype == TType.DOUBLE:
22175 
          self.otherCharges = iprot.readDouble();
22176 
        else:
22177 
          iprot.skip(ftype)
22178 
      elif fid == 6:
22179 
        if ftype == TType.DOUBLE:
22180 
          self.netCollection = iprot.readDouble();
22181 
        else:
22182 
          iprot.skip(ftype)
22183 
      else:
22184 
        iprot.skip(ftype)
22185 
      iprot.readFieldEnd()
22186 
    iprot.readStructEnd()
22187 
 
22188 
  def write(self, oprot):
22189 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
22190 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
22191 
      return
22192 
    oprot.writeStructBegin('savePaymentSettlements_args')
22193 
    if self.settlementDate is not None:
22194 
      oprot.writeFieldBegin('settlementDate', TType.I64, 1)
22195 
      oprot.writeI64(self.settlementDate)
22196 
      oprot.writeFieldEnd()
22197 
    if self.paymentGatewayId is not None:
22198 
      oprot.writeFieldBegin('paymentGatewayId', TType.I64, 2)
22199 
      oprot.writeI64(self.paymentGatewayId)
22200 
      oprot.writeFieldEnd()
4905 varun.gupt 22201 
    if self.referenceId is not None:
22202 
      oprot.writeFieldBegin('referenceId', TType.I64, 3)
22203 
      oprot.writeI64(self.referenceId)
4600 varun.gupt 22204 
      oprot.writeFieldEnd()
22205 
    if self.serviceTax is not None:
22206 
      oprot.writeFieldBegin('serviceTax', TType.DOUBLE, 4)
22207 
      oprot.writeDouble(self.serviceTax)
22208 
      oprot.writeFieldEnd()
22209 
    if self.otherCharges is not None:
22210 
      oprot.writeFieldBegin('otherCharges', TType.DOUBLE, 5)
22211 
      oprot.writeDouble(self.otherCharges)
22212 
      oprot.writeFieldEnd()
22213 
    if self.netCollection is not None:
22214 
      oprot.writeFieldBegin('netCollection', TType.DOUBLE, 6)
22215 
      oprot.writeDouble(self.netCollection)
22216 
      oprot.writeFieldEnd()
22217 
    oprot.writeFieldStop()
22218 
    oprot.writeStructEnd()
22219 
 
22220 
  def validate(self):
22221 
    return
22222 
 
22223 
 
22224 
  def __repr__(self):
22225 
    L = ['%s=%r' % (key, value)
22226 
      for key, value in self.__dict__.iteritems()]
22227 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
22228 
 
22229 
  def __eq__(self, other):
22230 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
22231 
 
22232 
  def __ne__(self, other):
22233 
    return not (self == other)
22234 
 
22235 
class savePaymentSettlements_result:
22236 
  """
22237 
  Attributes:
22238 
   - ex
22239 
  """
22240 
 
22241 
  thrift_spec = (
22242 
    None, # 0
22243 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
22244 
  )
22245 
 
22246 
  def __init__(self, ex=None,):
22247 
    self.ex = ex
22248 
 
22249 
  def read(self, iprot):
22250 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
22251 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
22252 
      return
22253 
    iprot.readStructBegin()
22254 
    while True:
22255 
      (fname, ftype, fid) = iprot.readFieldBegin()
22256 
      if ftype == TType.STOP:
22257 
        break
22258 
      if fid == 1:
22259 
        if ftype == TType.STRUCT:
22260 
          self.ex = TransactionServiceException()
22261 
          self.ex.read(iprot)
22262 
        else:
22263 
          iprot.skip(ftype)
22264 
      else:
22265 
        iprot.skip(ftype)
22266 
      iprot.readFieldEnd()
22267 
    iprot.readStructEnd()
22268 
 
22269 
  def write(self, oprot):
22270 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
22271 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
22272 
      return
22273 
    oprot.writeStructBegin('savePaymentSettlements_result')
22274 
    if self.ex is not None:
22275 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
22276 
      self.ex.write(oprot)
22277 
      oprot.writeFieldEnd()
22278 
    oprot.writeFieldStop()
22279 
    oprot.writeStructEnd()
22280 
 
22281 
  def validate(self):
22282 
    return
22283 
 
22284 
 
22285 
  def __repr__(self):
22286 
    L = ['%s=%r' % (key, value)
22287 
      for key, value in self.__dict__.iteritems()]
22288 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
22289 
 
22290 
  def __eq__(self, other):
22291 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
22292 
 
22293 
  def __ne__(self, other):
22294 
    return not (self == other)
22295 
 
22296 
class saveEBSSettlementSummary_args:
22297 
  """
22298 
  Attributes:
22299 
   - settlementId
22300 
   - settlementDate
22301 
   - transactionDateFrom
22302 
   - transactionDateTo
22303 
   - amount
22304 
  """
22305 
 
22306 
  thrift_spec = (
22307 
    None, # 0
22308 
    (1, TType.I64, 'settlementId', None, None, ), # 1
22309 
    (2, TType.I64, 'settlementDate', None, None, ), # 2
22310 
    (3, TType.I64, 'transactionDateFrom', None, None, ), # 3
22311 
    (4, TType.I64, 'transactionDateTo', None, None, ), # 4
22312 
    (5, TType.DOUBLE, 'amount', None, None, ), # 5
22313 
  )
22314 
 
22315 
  def __init__(self, settlementId=None, settlementDate=None, transactionDateFrom=None, transactionDateTo=None, amount=None,):
22316 
    self.settlementId = settlementId
22317 
    self.settlementDate = settlementDate
22318 
    self.transactionDateFrom = transactionDateFrom
22319 
    self.transactionDateTo = transactionDateTo
22320 
    self.amount = amount
22321 
 
22322 
  def read(self, iprot):
22323 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
22324 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
22325 
      return
22326 
    iprot.readStructBegin()
22327 
    while True:
22328 
      (fname, ftype, fid) = iprot.readFieldBegin()
22329 
      if ftype == TType.STOP:
22330 
        break
22331 
      if fid == 1:
22332 
        if ftype == TType.I64:
22333 
          self.settlementId = iprot.readI64();
22334 
        else:
22335 
          iprot.skip(ftype)
22336 
      elif fid == 2:
22337 
        if ftype == TType.I64:
22338 
          self.settlementDate = iprot.readI64();
22339 
        else:
22340 
          iprot.skip(ftype)
22341 
      elif fid == 3:
22342 
        if ftype == TType.I64:
22343 
          self.transactionDateFrom = iprot.readI64();
22344 
        else:
22345 
          iprot.skip(ftype)
22346 
      elif fid == 4:
22347 
        if ftype == TType.I64:
22348 
          self.transactionDateTo = iprot.readI64();
22349 
        else:
22350 
          iprot.skip(ftype)
22351 
      elif fid == 5:
22352 
        if ftype == TType.DOUBLE:
22353 
          self.amount = iprot.readDouble();
22354 
        else:
22355 
          iprot.skip(ftype)
22356 
      else:
22357 
        iprot.skip(ftype)
22358 
      iprot.readFieldEnd()
22359 
    iprot.readStructEnd()
22360 
 
22361 
  def write(self, oprot):
22362 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
22363 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
22364 
      return
22365 
    oprot.writeStructBegin('saveEBSSettlementSummary_args')
22366 
    if self.settlementId is not None:
22367 
      oprot.writeFieldBegin('settlementId', TType.I64, 1)
22368 
      oprot.writeI64(self.settlementId)
22369 
      oprot.writeFieldEnd()
22370 
    if self.settlementDate is not None:
22371 
      oprot.writeFieldBegin('settlementDate', TType.I64, 2)
22372 
      oprot.writeI64(self.settlementDate)
22373 
      oprot.writeFieldEnd()
22374 
    if self.transactionDateFrom is not None:
22375 
      oprot.writeFieldBegin('transactionDateFrom', TType.I64, 3)
22376 
      oprot.writeI64(self.transactionDateFrom)
22377 
      oprot.writeFieldEnd()
22378 
    if self.transactionDateTo is not None:
22379 
      oprot.writeFieldBegin('transactionDateTo', TType.I64, 4)
22380 
      oprot.writeI64(self.transactionDateTo)
22381 
      oprot.writeFieldEnd()
22382 
    if self.amount is not None:
22383 
      oprot.writeFieldBegin('amount', TType.DOUBLE, 5)
22384 
      oprot.writeDouble(self.amount)
22385 
      oprot.writeFieldEnd()
22386 
    oprot.writeFieldStop()
22387 
    oprot.writeStructEnd()
22388 
 
22389 
  def validate(self):
22390 
    return
22391 
 
22392 
 
22393 
  def __repr__(self):
22394 
    L = ['%s=%r' % (key, value)
22395 
      for key, value in self.__dict__.iteritems()]
22396 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
22397 
 
22398 
  def __eq__(self, other):
22399 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
22400 
 
22401 
  def __ne__(self, other):
22402 
    return not (self == other)
22403 
 
22404 
class saveEBSSettlementSummary_result:
22405 
  """
22406 
  Attributes:
22407 
   - ex
22408 
  """
22409 
 
22410 
  thrift_spec = (
22411 
    None, # 0
22412 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
22413 
  )
22414 
 
22415 
  def __init__(self, ex=None,):
22416 
    self.ex = ex
22417 
 
22418 
  def read(self, iprot):
22419 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
22420 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
22421 
      return
22422 
    iprot.readStructBegin()
22423 
    while True:
22424 
      (fname, ftype, fid) = iprot.readFieldBegin()
22425 
      if ftype == TType.STOP:
22426 
        break
22427 
      if fid == 1:
22428 
        if ftype == TType.STRUCT:
22429 
          self.ex = TransactionServiceException()
22430 
          self.ex.read(iprot)
22431 
        else:
22432 
          iprot.skip(ftype)
22433 
      else:
22434 
        iprot.skip(ftype)
22435 
      iprot.readFieldEnd()
22436 
    iprot.readStructEnd()
22437 
 
22438 
  def write(self, oprot):
22439 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
22440 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
22441 
      return
22442 
    oprot.writeStructBegin('saveEBSSettlementSummary_result')
22443 
    if self.ex is not None:
22444 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
22445 
      self.ex.write(oprot)
22446 
      oprot.writeFieldEnd()
22447 
    oprot.writeFieldStop()
22448 
    oprot.writeStructEnd()
22449 
 
22450 
  def validate(self):
22451 
    return
22452 
 
22453 
 
22454 
  def __repr__(self):
22455 
    L = ['%s=%r' % (key, value)
22456 
      for key, value in self.__dict__.iteritems()]
22457 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
22458 
 
22459 
  def __eq__(self, other):
22460 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
22461 
 
22462 
  def __ne__(self, other):
22463 
    return not (self == other)
22464 
 
5386 phani.kuma 22465 
class getSettlementForPrepaid_args:
4600 varun.gupt 22466 
  """
22467 
  Attributes:
5189 varun.gupt 22468 
   - referenceId
22469 
   - isRefund
4600 varun.gupt 22470 
  """
22471 
 
22472 
  thrift_spec = (
22473 
    None, # 0
5189 varun.gupt 22474 
    (1, TType.I64, 'referenceId', None, None, ), # 1
5386 phani.kuma 22475 
    (2, TType.BOOL, 'isRefund', None, None, ), # 2
4600 varun.gupt 22476 
  )
22477 
 
5386 phani.kuma 22478 
  def __init__(self, referenceId=None, isRefund=None,):
5189 varun.gupt 22479 
    self.referenceId = referenceId
22480 
    self.isRefund = isRefund
4600 varun.gupt 22481 
 
22482 
  def read(self, iprot):
22483 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
22484 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
22485 
      return
22486 
    iprot.readStructBegin()
22487 
    while True:
22488 
      (fname, ftype, fid) = iprot.readFieldBegin()
22489 
      if ftype == TType.STOP:
22490 
        break
22491 
      if fid == 1:
22492 
        if ftype == TType.I64:
5189 varun.gupt 22493 
          self.referenceId = iprot.readI64();
4600 varun.gupt 22494 
        else:
22495 
          iprot.skip(ftype)
5189 varun.gupt 22496 
      elif fid == 2:
22497 
        if ftype == TType.BOOL:
22498 
          self.isRefund = iprot.readBool();
22499 
        else:
22500 
          iprot.skip(ftype)
4600 varun.gupt 22501 
      else:
22502 
        iprot.skip(ftype)
22503 
      iprot.readFieldEnd()
22504 
    iprot.readStructEnd()
22505 
 
22506 
  def write(self, oprot):
22507 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
22508 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
22509 
      return
5386 phani.kuma 22510 
    oprot.writeStructBegin('getSettlementForPrepaid_args')
5189 varun.gupt 22511 
    if self.referenceId is not None:
22512 
      oprot.writeFieldBegin('referenceId', TType.I64, 1)
22513 
      oprot.writeI64(self.referenceId)
4600 varun.gupt 22514 
      oprot.writeFieldEnd()
5386 phani.kuma 22515 
    if self.isRefund is not None:
22516 
      oprot.writeFieldBegin('isRefund', TType.BOOL, 2)
22517 
      oprot.writeBool(self.isRefund)
5382 varun.gupt 22518 
      oprot.writeFieldEnd()
5386 phani.kuma 22519 
    oprot.writeFieldStop()
22520 
    oprot.writeStructEnd()
22521 
 
22522 
  def validate(self):
22523 
    return
22524 
 
22525 
 
22526 
  def __repr__(self):
22527 
    L = ['%s=%r' % (key, value)
22528 
      for key, value in self.__dict__.iteritems()]
22529 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
22530 
 
22531 
  def __eq__(self, other):
22532 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
22533 
 
22534 
  def __ne__(self, other):
22535 
    return not (self == other)
22536 
 
22537 
class getSettlementForPrepaid_result:
22538 
  """
22539 
  Attributes:
22540 
   - success
22541 
   - ex
22542 
  """
22543 
 
22544 
  thrift_spec = (
22545 
    (0, TType.STRUCT, 'success', (PaymentSettlement, PaymentSettlement.thrift_spec), None, ), # 0
22546 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
22547 
  )
22548 
 
22549 
  def __init__(self, success=None, ex=None,):
22550 
    self.success = success
22551 
    self.ex = ex
22552 
 
22553 
  def read(self, iprot):
22554 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
22555 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
22556 
      return
22557 
    iprot.readStructBegin()
22558 
    while True:
22559 
      (fname, ftype, fid) = iprot.readFieldBegin()
22560 
      if ftype == TType.STOP:
22561 
        break
22562 
      if fid == 0:
22563 
        if ftype == TType.STRUCT:
22564 
          self.success = PaymentSettlement()
22565 
          self.success.read(iprot)
22566 
        else:
22567 
          iprot.skip(ftype)
22568 
      elif fid == 1:
22569 
        if ftype == TType.STRUCT:
22570 
          self.ex = TransactionServiceException()
22571 
          self.ex.read(iprot)
22572 
        else:
22573 
          iprot.skip(ftype)
22574 
      else:
22575 
        iprot.skip(ftype)
22576 
      iprot.readFieldEnd()
22577 
    iprot.readStructEnd()
22578 
 
22579 
  def write(self, oprot):
22580 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
22581 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
22582 
      return
22583 
    oprot.writeStructBegin('getSettlementForPrepaid_result')
22584 
    if self.success is not None:
22585 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
22586 
      self.success.write(oprot)
22587 
      oprot.writeFieldEnd()
22588 
    if self.ex is not None:
22589 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
22590 
      self.ex.write(oprot)
22591 
      oprot.writeFieldEnd()
22592 
    oprot.writeFieldStop()
22593 
    oprot.writeStructEnd()
22594 
 
22595 
  def validate(self):
22596 
    return
22597 
 
22598 
 
22599 
  def __repr__(self):
22600 
    L = ['%s=%r' % (key, value)
22601 
      for key, value in self.__dict__.iteritems()]
22602 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
22603 
 
22604 
  def __eq__(self, other):
22605 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
22606 
 
22607 
  def __ne__(self, other):
22608 
    return not (self == other)
22609 
 
22610 
class getSettlementForCod_args:
22611 
  """
22612 
  Attributes:
22613 
   - orderId
22614 
   - isRefund
22615 
  """
22616 
 
22617 
  thrift_spec = (
22618 
    None, # 0
22619 
    (1, TType.I64, 'orderId', None, None, ), # 1
22620 
    (2, TType.BOOL, 'isRefund', None, None, ), # 2
22621 
  )
22622 
 
22623 
  def __init__(self, orderId=None, isRefund=None,):
22624 
    self.orderId = orderId
22625 
    self.isRefund = isRefund
22626 
 
22627 
  def read(self, iprot):
22628 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
22629 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
22630 
      return
22631 
    iprot.readStructBegin()
22632 
    while True:
22633 
      (fname, ftype, fid) = iprot.readFieldBegin()
22634 
      if ftype == TType.STOP:
22635 
        break
22636 
      if fid == 1:
22637 
        if ftype == TType.I64:
22638 
          self.orderId = iprot.readI64();
22639 
        else:
22640 
          iprot.skip(ftype)
22641 
      elif fid == 2:
22642 
        if ftype == TType.BOOL:
22643 
          self.isRefund = iprot.readBool();
22644 
        else:
22645 
          iprot.skip(ftype)
22646 
      else:
22647 
        iprot.skip(ftype)
22648 
      iprot.readFieldEnd()
22649 
    iprot.readStructEnd()
22650 
 
22651 
  def write(self, oprot):
22652 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
22653 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
22654 
      return
22655 
    oprot.writeStructBegin('getSettlementForCod_args')
22656 
    if self.orderId is not None:
22657 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
22658 
      oprot.writeI64(self.orderId)
22659 
      oprot.writeFieldEnd()
5189 varun.gupt 22660 
    if self.isRefund is not None:
5386 phani.kuma 22661 
      oprot.writeFieldBegin('isRefund', TType.BOOL, 2)
5189 varun.gupt 22662 
      oprot.writeBool(self.isRefund)
22663 
      oprot.writeFieldEnd()
4600 varun.gupt 22664 
    oprot.writeFieldStop()
22665 
    oprot.writeStructEnd()
22666 
 
22667 
  def validate(self):
22668 
    return
22669 
 
22670 
 
22671 
  def __repr__(self):
22672 
    L = ['%s=%r' % (key, value)
22673 
      for key, value in self.__dict__.iteritems()]
22674 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
22675 
 
22676 
  def __eq__(self, other):
22677 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
22678 
 
22679 
  def __ne__(self, other):
22680 
    return not (self == other)
22681 
 
5386 phani.kuma 22682 
class getSettlementForCod_result:
4600 varun.gupt 22683 
  """
22684 
  Attributes:
22685 
   - success
22686 
   - ex
22687 
  """
22688 
 
22689 
  thrift_spec = (
22690 
    (0, TType.STRUCT, 'success', (PaymentSettlement, PaymentSettlement.thrift_spec), None, ), # 0
22691 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
22692 
  )
22693 
 
22694 
  def __init__(self, success=None, ex=None,):
22695 
    self.success = success
22696 
    self.ex = ex
22697 
 
22698 
  def read(self, iprot):
22699 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
22700 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
22701 
      return
22702 
    iprot.readStructBegin()
22703 
    while True:
22704 
      (fname, ftype, fid) = iprot.readFieldBegin()
22705 
      if ftype == TType.STOP:
22706 
        break
22707 
      if fid == 0:
22708 
        if ftype == TType.STRUCT:
22709 
          self.success = PaymentSettlement()
22710 
          self.success.read(iprot)
22711 
        else:
22712 
          iprot.skip(ftype)
22713 
      elif fid == 1:
22714 
        if ftype == TType.STRUCT:
22715 
          self.ex = TransactionServiceException()
22716 
          self.ex.read(iprot)
22717 
        else:
22718 
          iprot.skip(ftype)
22719 
      else:
22720 
        iprot.skip(ftype)
22721 
      iprot.readFieldEnd()
22722 
    iprot.readStructEnd()
22723 
 
22724 
  def write(self, oprot):
22725 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
22726 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
22727 
      return
5386 phani.kuma 22728 
    oprot.writeStructBegin('getSettlementForCod_result')
4600 varun.gupt 22729 
    if self.success is not None:
22730 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
22731 
      self.success.write(oprot)
22732 
      oprot.writeFieldEnd()
22733 
    if self.ex is not None:
22734 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
22735 
      self.ex.write(oprot)
22736 
      oprot.writeFieldEnd()
22737 
    oprot.writeFieldStop()
22738 
    oprot.writeStructEnd()
22739 
 
22740 
  def validate(self):
22741 
    return
22742 
 
22743 
 
22744 
  def __repr__(self):
22745 
    L = ['%s=%r' % (key, value)
22746 
      for key, value in self.__dict__.iteritems()]
22747 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
22748 
 
22749 
  def __eq__(self, other):
22750 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
22751 
 
22752 
  def __ne__(self, other):
22753 
    return not (self == other)
22754 
 
22755 
class getEBSSettlementSummaries_args:
22756 
 
22757 
  thrift_spec = (
22758 
  )
22759 
 
22760 
  def read(self, iprot):
22761 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
22762 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
22763 
      return
22764 
    iprot.readStructBegin()
22765 
    while True:
22766 
      (fname, ftype, fid) = iprot.readFieldBegin()
22767 
      if ftype == TType.STOP:
22768 
        break
22769 
      else:
22770 
        iprot.skip(ftype)
22771 
      iprot.readFieldEnd()
22772 
    iprot.readStructEnd()
22773 
 
22774 
  def write(self, oprot):
22775 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
22776 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
22777 
      return
22778 
    oprot.writeStructBegin('getEBSSettlementSummaries_args')
22779 
    oprot.writeFieldStop()
22780 
    oprot.writeStructEnd()
22781 
 
22782 
  def validate(self):
22783 
    return
22784 
 
22785 
 
22786 
  def __repr__(self):
22787 
    L = ['%s=%r' % (key, value)
22788 
      for key, value in self.__dict__.iteritems()]
22789 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
22790 
 
22791 
  def __eq__(self, other):
22792 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
22793 
 
22794 
  def __ne__(self, other):
22795 
    return not (self == other)
22796 
 
22797 
class getEBSSettlementSummaries_result:
22798 
  """
22799 
  Attributes:
22800 
   - success
22801 
   - ex
22802 
  """
22803 
 
22804 
  thrift_spec = (
22805 
    (0, TType.MAP, 'success', (TType.I64,None,TType.STRING,None), None, ), # 0
22806 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
22807 
  )
22808 
 
22809 
  def __init__(self, success=None, ex=None,):
22810 
    self.success = success
22811 
    self.ex = ex
22812 
 
22813 
  def read(self, iprot):
22814 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
22815 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
22816 
      return
22817 
    iprot.readStructBegin()
22818 
    while True:
22819 
      (fname, ftype, fid) = iprot.readFieldBegin()
22820 
      if ftype == TType.STOP:
22821 
        break
22822 
      if fid == 0:
22823 
        if ftype == TType.MAP:
22824 
          self.success = {}
6000 mandeep.dh 22825 
          (_ktype519, _vtype520, _size518 ) = iprot.readMapBegin()
22826 
          for _i522 in xrange(_size518):
22827 
            _key523 = iprot.readI64();
22828 
            _val524 = iprot.readString();
22829 
            self.success[_key523] = _val524
4600 varun.gupt 22830 
          iprot.readMapEnd()
22831 
        else:
22832 
          iprot.skip(ftype)
22833 
      elif fid == 1:
22834 
        if ftype == TType.STRUCT:
22835 
          self.ex = TransactionServiceException()
22836 
          self.ex.read(iprot)
22837 
        else:
22838 
          iprot.skip(ftype)
22839 
      else:
22840 
        iprot.skip(ftype)
22841 
      iprot.readFieldEnd()
22842 
    iprot.readStructEnd()
22843 
 
22844 
  def write(self, oprot):
22845 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
22846 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
22847 
      return
22848 
    oprot.writeStructBegin('getEBSSettlementSummaries_result')
22849 
    if self.success is not None:
22850 
      oprot.writeFieldBegin('success', TType.MAP, 0)
22851 
      oprot.writeMapBegin(TType.I64, TType.STRING, len(self.success))
6000 mandeep.dh 22852 
      for kiter525,viter526 in self.success.items():
22853 
        oprot.writeI64(kiter525)
22854 
        oprot.writeString(viter526)
4600 varun.gupt 22855 
      oprot.writeMapEnd()
22856 
      oprot.writeFieldEnd()
22857 
    if self.ex is not None:
22858 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
22859 
      self.ex.write(oprot)
22860 
      oprot.writeFieldEnd()
22861 
    oprot.writeFieldStop()
22862 
    oprot.writeStructEnd()
22863 
 
22864 
  def validate(self):
22865 
    return
22866 
 
22867 
 
22868 
  def __repr__(self):
22869 
    L = ['%s=%r' % (key, value)
22870 
      for key, value in self.__dict__.iteritems()]
22871 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
22872 
 
22873 
  def __eq__(self, other):
22874 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
22875 
 
22876 
  def __ne__(self, other):
22877 
    return not (self == other)
22878 
 
22879 
class markEBSSettlementUploaded_args:
22880 
  """
22881 
  Attributes:
22882 
   - settlementId
22883 
  """
22884 
 
22885 
  thrift_spec = (
22886 
    None, # 0
22887 
    (1, TType.I64, 'settlementId', None, None, ), # 1
22888 
  )
22889 
 
22890 
  def __init__(self, settlementId=None,):
22891 
    self.settlementId = settlementId
22892 
 
22893 
  def read(self, iprot):
22894 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
22895 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
22896 
      return
22897 
    iprot.readStructBegin()
22898 
    while True:
22899 
      (fname, ftype, fid) = iprot.readFieldBegin()
22900 
      if ftype == TType.STOP:
22901 
        break
22902 
      if fid == 1:
22903 
        if ftype == TType.I64:
22904 
          self.settlementId = iprot.readI64();
22905 
        else:
22906 
          iprot.skip(ftype)
22907 
      else:
22908 
        iprot.skip(ftype)
22909 
      iprot.readFieldEnd()
22910 
    iprot.readStructEnd()
22911 
 
22912 
  def write(self, oprot):
22913 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
22914 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
22915 
      return
22916 
    oprot.writeStructBegin('markEBSSettlementUploaded_args')
22917 
    if self.settlementId is not None:
22918 
      oprot.writeFieldBegin('settlementId', TType.I64, 1)
22919 
      oprot.writeI64(self.settlementId)
22920 
      oprot.writeFieldEnd()
22921 
    oprot.writeFieldStop()
22922 
    oprot.writeStructEnd()
22923 
 
22924 
  def validate(self):
22925 
    return
22926 
 
22927 
 
22928 
  def __repr__(self):
22929 
    L = ['%s=%r' % (key, value)
22930 
      for key, value in self.__dict__.iteritems()]
22931 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
22932 
 
22933 
  def __eq__(self, other):
22934 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
22935 
 
22936 
  def __ne__(self, other):
22937 
    return not (self == other)
22938 
 
22939 
class markEBSSettlementUploaded_result:
22940 
  """
22941 
  Attributes:
22942 
   - ex
22943 
  """
22944 
 
22945 
  thrift_spec = (
22946 
    None, # 0
22947 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
22948 
  )
22949 
 
22950 
  def __init__(self, ex=None,):
22951 
    self.ex = ex
22952 
 
22953 
  def read(self, iprot):
22954 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
22955 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
22956 
      return
22957 
    iprot.readStructBegin()
22958 
    while True:
22959 
      (fname, ftype, fid) = iprot.readFieldBegin()
22960 
      if ftype == TType.STOP:
22961 
        break
22962 
      if fid == 1:
22963 
        if ftype == TType.STRUCT:
22964 
          self.ex = TransactionServiceException()
22965 
          self.ex.read(iprot)
22966 
        else:
22967 
          iprot.skip(ftype)
22968 
      else:
22969 
        iprot.skip(ftype)
22970 
      iprot.readFieldEnd()
22971 
    iprot.readStructEnd()
22972 
 
22973 
  def write(self, oprot):
22974 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
22975 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
22976 
      return
22977 
    oprot.writeStructBegin('markEBSSettlementUploaded_result')
22978 
    if self.ex is not None:
22979 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
22980 
      self.ex.write(oprot)
22981 
      oprot.writeFieldEnd()
22982 
    oprot.writeFieldStop()
22983 
    oprot.writeStructEnd()
22984 
 
22985 
  def validate(self):
22986 
    return
22987 
 
22988 
 
22989 
  def __repr__(self):
22990 
    L = ['%s=%r' % (key, value)
22991 
      for key, value in self.__dict__.iteritems()]
22992 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
22993 
 
22994 
  def __eq__(self, other):
22995 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
22996 
 
22997 
  def __ne__(self, other):
22998 
    return not (self == other)
22999 
 
23000 
class getEBSSettlementDate_args:
23001 
  """
23002 
  Attributes:
23003 
   - settlementId
23004 
  """
23005 
 
23006 
  thrift_spec = (
23007 
    None, # 0
23008 
    (1, TType.I64, 'settlementId', None, None, ), # 1
23009 
  )
23010 
 
23011 
  def __init__(self, settlementId=None,):
23012 
    self.settlementId = settlementId
23013 
 
23014 
  def read(self, iprot):
23015 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
23016 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
23017 
      return
23018 
    iprot.readStructBegin()
23019 
    while True:
23020 
      (fname, ftype, fid) = iprot.readFieldBegin()
23021 
      if ftype == TType.STOP:
23022 
        break
23023 
      if fid == 1:
23024 
        if ftype == TType.I64:
23025 
          self.settlementId = iprot.readI64();
23026 
        else:
23027 
          iprot.skip(ftype)
23028 
      else:
23029 
        iprot.skip(ftype)
23030 
      iprot.readFieldEnd()
23031 
    iprot.readStructEnd()
23032 
 
23033 
  def write(self, oprot):
23034 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
23035 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
23036 
      return
23037 
    oprot.writeStructBegin('getEBSSettlementDate_args')
23038 
    if self.settlementId is not None:
23039 
      oprot.writeFieldBegin('settlementId', TType.I64, 1)
23040 
      oprot.writeI64(self.settlementId)
23041 
      oprot.writeFieldEnd()
23042 
    oprot.writeFieldStop()
23043 
    oprot.writeStructEnd()
23044 
 
23045 
  def validate(self):
23046 
    return
23047 
 
23048 
 
23049 
  def __repr__(self):
23050 
    L = ['%s=%r' % (key, value)
23051 
      for key, value in self.__dict__.iteritems()]
23052 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
23053 
 
23054 
  def __eq__(self, other):
23055 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
23056 
 
23057 
  def __ne__(self, other):
23058 
    return not (self == other)
23059 
 
23060 
class getEBSSettlementDate_result:
23061 
  """
23062 
  Attributes:
23063 
   - success
23064 
   - ex
23065 
  """
23066 
 
23067 
  thrift_spec = (
23068 
    (0, TType.I64, 'success', None, None, ), # 0
23069 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
23070 
  )
23071 
 
23072 
  def __init__(self, success=None, ex=None,):
23073 
    self.success = success
23074 
    self.ex = ex
23075 
 
23076 
  def read(self, iprot):
23077 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
23078 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
23079 
      return
23080 
    iprot.readStructBegin()
23081 
    while True:
23082 
      (fname, ftype, fid) = iprot.readFieldBegin()
23083 
      if ftype == TType.STOP:
23084 
        break
23085 
      if fid == 0:
23086 
        if ftype == TType.I64:
23087 
          self.success = iprot.readI64();
23088 
        else:
23089 
          iprot.skip(ftype)
23090 
      elif fid == 1:
23091 
        if ftype == TType.STRUCT:
23092 
          self.ex = TransactionServiceException()
23093 
          self.ex.read(iprot)
23094 
        else:
23095 
          iprot.skip(ftype)
23096 
      else:
23097 
        iprot.skip(ftype)
23098 
      iprot.readFieldEnd()
23099 
    iprot.readStructEnd()
23100 
 
23101 
  def write(self, oprot):
23102 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
23103 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
23104 
      return
23105 
    oprot.writeStructBegin('getEBSSettlementDate_result')
23106 
    if self.success is not None:
23107 
      oprot.writeFieldBegin('success', TType.I64, 0)
23108 
      oprot.writeI64(self.success)
23109 
      oprot.writeFieldEnd()
23110 
    if self.ex is not None:
23111 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
23112 
      self.ex.write(oprot)
23113 
      oprot.writeFieldEnd()
23114 
    oprot.writeFieldStop()
23115 
    oprot.writeStructEnd()
23116 
 
23117 
  def validate(self):
23118 
    return
23119 
 
23120 
 
23121 
  def __repr__(self):
23122 
    L = ['%s=%r' % (key, value)
23123 
      for key, value in self.__dict__.iteritems()]
23124 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
23125 
 
23126 
  def __eq__(self, other):
23127 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
23128 
 
23129 
  def __ne__(self, other):
23130 
    return not (self == other)
4715 varun.gupt 23131 
 
23132 
class getSettlementsByDate_args:
23133 
  """
23134 
  Attributes:
23135 
   - settlementDateFrom
23136 
   - settlementDateTo
23137 
   - isRefund
23138 
  """
23139 
 
23140 
  thrift_spec = (
23141 
    None, # 0
23142 
    (1, TType.I64, 'settlementDateFrom', None, None, ), # 1
23143 
    (2, TType.I64, 'settlementDateTo', None, None, ), # 2
23144 
    (3, TType.BOOL, 'isRefund', None, None, ), # 3
23145 
  )
23146 
 
23147 
  def __init__(self, settlementDateFrom=None, settlementDateTo=None, isRefund=None,):
23148 
    self.settlementDateFrom = settlementDateFrom
23149 
    self.settlementDateTo = settlementDateTo
23150 
    self.isRefund = isRefund
23151 
 
23152 
  def read(self, iprot):
23153 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
23154 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
23155 
      return
23156 
    iprot.readStructBegin()
23157 
    while True:
23158 
      (fname, ftype, fid) = iprot.readFieldBegin()
23159 
      if ftype == TType.STOP:
23160 
        break
23161 
      if fid == 1:
23162 
        if ftype == TType.I64:
23163 
          self.settlementDateFrom = iprot.readI64();
23164 
        else:
23165 
          iprot.skip(ftype)
23166 
      elif fid == 2:
23167 
        if ftype == TType.I64:
23168 
          self.settlementDateTo = iprot.readI64();
23169 
        else:
23170 
          iprot.skip(ftype)
23171 
      elif fid == 3:
23172 
        if ftype == TType.BOOL:
23173 
          self.isRefund = iprot.readBool();
23174 
        else:
23175 
          iprot.skip(ftype)
23176 
      else:
23177 
        iprot.skip(ftype)
23178 
      iprot.readFieldEnd()
23179 
    iprot.readStructEnd()
23180 
 
23181 
  def write(self, oprot):
23182 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
23183 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
23184 
      return
23185 
    oprot.writeStructBegin('getSettlementsByDate_args')
23186 
    if self.settlementDateFrom is not None:
23187 
      oprot.writeFieldBegin('settlementDateFrom', TType.I64, 1)
23188 
      oprot.writeI64(self.settlementDateFrom)
23189 
      oprot.writeFieldEnd()
23190 
    if self.settlementDateTo is not None:
23191 
      oprot.writeFieldBegin('settlementDateTo', TType.I64, 2)
23192 
      oprot.writeI64(self.settlementDateTo)
23193 
      oprot.writeFieldEnd()
23194 
    if self.isRefund is not None:
23195 
      oprot.writeFieldBegin('isRefund', TType.BOOL, 3)
23196 
      oprot.writeBool(self.isRefund)
23197 
      oprot.writeFieldEnd()
23198 
    oprot.writeFieldStop()
23199 
    oprot.writeStructEnd()
23200 
 
23201 
  def validate(self):
23202 
    return
23203 
 
23204 
 
23205 
  def __repr__(self):
23206 
    L = ['%s=%r' % (key, value)
23207 
      for key, value in self.__dict__.iteritems()]
23208 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
23209 
 
23210 
  def __eq__(self, other):
23211 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
23212 
 
23213 
  def __ne__(self, other):
23214 
    return not (self == other)
23215 
 
23216 
class getSettlementsByDate_result:
23217 
  """
23218 
  Attributes:
23219 
   - success
23220 
   - ex
23221 
  """
23222 
 
23223 
  thrift_spec = (
23224 
    (0, TType.LIST, 'success', (TType.STRUCT,(PaymentSettlement, PaymentSettlement.thrift_spec)), None, ), # 0
23225 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
23226 
  )
23227 
 
23228 
  def __init__(self, success=None, ex=None,):
23229 
    self.success = success
23230 
    self.ex = ex
23231 
 
23232 
  def read(self, iprot):
23233 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
23234 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
23235 
      return
23236 
    iprot.readStructBegin()
23237 
    while True:
23238 
      (fname, ftype, fid) = iprot.readFieldBegin()
23239 
      if ftype == TType.STOP:
23240 
        break
23241 
      if fid == 0:
23242 
        if ftype == TType.LIST:
23243 
          self.success = []
6000 mandeep.dh 23244 
          (_etype530, _size527) = iprot.readListBegin()
23245 
          for _i531 in xrange(_size527):
23246 
            _elem532 = PaymentSettlement()
23247 
            _elem532.read(iprot)
23248 
            self.success.append(_elem532)
4715 varun.gupt 23249 
          iprot.readListEnd()
23250 
        else:
23251 
          iprot.skip(ftype)
23252 
      elif fid == 1:
23253 
        if ftype == TType.STRUCT:
23254 
          self.ex = TransactionServiceException()
23255 
          self.ex.read(iprot)
23256 
        else:
23257 
          iprot.skip(ftype)
23258 
      else:
23259 
        iprot.skip(ftype)
23260 
      iprot.readFieldEnd()
23261 
    iprot.readStructEnd()
23262 
 
23263 
  def write(self, oprot):
23264 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
23265 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
23266 
      return
23267 
    oprot.writeStructBegin('getSettlementsByDate_result')
23268 
    if self.success is not None:
23269 
      oprot.writeFieldBegin('success', TType.LIST, 0)
23270 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
6000 mandeep.dh 23271 
      for iter533 in self.success:
23272 
        iter533.write(oprot)
4715 varun.gupt 23273 
      oprot.writeListEnd()
23274 
      oprot.writeFieldEnd()
23275 
    if self.ex is not None:
23276 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
23277 
      self.ex.write(oprot)
23278 
      oprot.writeFieldEnd()
23279 
    oprot.writeFieldStop()
23280 
    oprot.writeStructEnd()
23281 
 
23282 
  def validate(self):
23283 
    return
23284 
 
23285 
 
23286 
  def __repr__(self):
23287 
    L = ['%s=%r' % (key, value)
23288 
      for key, value in self.__dict__.iteritems()]
23289 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
23290 
 
23291 
  def __eq__(self, other):
23292 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
23293 
 
23294 
  def __ne__(self, other):
23295 
    return not (self == other)
23296 
 
23297 
class getReshippedOrderIds_args:
23298 
  """
23299 
  Attributes:
23300 
   - orderIds
23301 
  """
23302 
 
23303 
  thrift_spec = (
23304 
    None, # 0
23305 
    (1, TType.LIST, 'orderIds', (TType.I64,None), None, ), # 1
23306 
  )
23307 
 
23308 
  def __init__(self, orderIds=None,):
23309 
    self.orderIds = orderIds
23310 
 
23311 
  def read(self, iprot):
23312 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
23313 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
23314 
      return
23315 
    iprot.readStructBegin()
23316 
    while True:
23317 
      (fname, ftype, fid) = iprot.readFieldBegin()
23318 
      if ftype == TType.STOP:
23319 
        break
23320 
      if fid == 1:
23321 
        if ftype == TType.LIST:
23322 
          self.orderIds = []
6000 mandeep.dh 23323 
          (_etype537, _size534) = iprot.readListBegin()
23324 
          for _i538 in xrange(_size534):
23325 
            _elem539 = iprot.readI64();
23326 
            self.orderIds.append(_elem539)
4715 varun.gupt 23327 
          iprot.readListEnd()
23328 
        else:
23329 
          iprot.skip(ftype)
23330 
      else:
23331 
        iprot.skip(ftype)
23332 
      iprot.readFieldEnd()
23333 
    iprot.readStructEnd()
23334 
 
23335 
  def write(self, oprot):
23336 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
23337 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
23338 
      return
23339 
    oprot.writeStructBegin('getReshippedOrderIds_args')
23340 
    if self.orderIds is not None:
23341 
      oprot.writeFieldBegin('orderIds', TType.LIST, 1)
23342 
      oprot.writeListBegin(TType.I64, len(self.orderIds))
6000 mandeep.dh 23343 
      for iter540 in self.orderIds:
23344 
        oprot.writeI64(iter540)
4715 varun.gupt 23345 
      oprot.writeListEnd()
23346 
      oprot.writeFieldEnd()
23347 
    oprot.writeFieldStop()
23348 
    oprot.writeStructEnd()
23349 
 
23350 
  def validate(self):
23351 
    return
23352 
 
23353 
 
23354 
  def __repr__(self):
23355 
    L = ['%s=%r' % (key, value)
23356 
      for key, value in self.__dict__.iteritems()]
23357 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
23358 
 
23359 
  def __eq__(self, other):
23360 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
23361 
 
23362 
  def __ne__(self, other):
23363 
    return not (self == other)
23364 
 
23365 
class getReshippedOrderIds_result:
23366 
  """
23367 
  Attributes:
23368 
   - success
23369 
   - ex
23370 
  """
23371 
 
23372 
  thrift_spec = (
23373 
    (0, TType.LIST, 'success', (TType.I64,None), None, ), # 0
23374 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
23375 
  )
23376 
 
23377 
  def __init__(self, success=None, ex=None,):
23378 
    self.success = success
23379 
    self.ex = ex
23380 
 
23381 
  def read(self, iprot):
23382 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
23383 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
23384 
      return
23385 
    iprot.readStructBegin()
23386 
    while True:
23387 
      (fname, ftype, fid) = iprot.readFieldBegin()
23388 
      if ftype == TType.STOP:
23389 
        break
23390 
      if fid == 0:
23391 
        if ftype == TType.LIST:
23392 
          self.success = []
6000 mandeep.dh 23393 
          (_etype544, _size541) = iprot.readListBegin()
23394 
          for _i545 in xrange(_size541):
23395 
            _elem546 = iprot.readI64();
23396 
            self.success.append(_elem546)
4715 varun.gupt 23397 
          iprot.readListEnd()
23398 
        else:
23399 
          iprot.skip(ftype)
23400 
      elif fid == 1:
23401 
        if ftype == TType.STRUCT:
23402 
          self.ex = TransactionServiceException()
23403 
          self.ex.read(iprot)
23404 
        else:
23405 
          iprot.skip(ftype)
23406 
      else:
23407 
        iprot.skip(ftype)
23408 
      iprot.readFieldEnd()
23409 
    iprot.readStructEnd()
23410 
 
23411 
  def write(self, oprot):
23412 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
23413 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
23414 
      return
23415 
    oprot.writeStructBegin('getReshippedOrderIds_result')
23416 
    if self.success is not None:
23417 
      oprot.writeFieldBegin('success', TType.LIST, 0)
23418 
      oprot.writeListBegin(TType.I64, len(self.success))
6000 mandeep.dh 23419 
      for iter547 in self.success:
23420 
        oprot.writeI64(iter547)
4715 varun.gupt 23421 
      oprot.writeListEnd()
23422 
      oprot.writeFieldEnd()
23423 
    if self.ex is not None:
23424 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
23425 
      self.ex.write(oprot)
23426 
      oprot.writeFieldEnd()
23427 
    oprot.writeFieldStop()
23428 
    oprot.writeStructEnd()
23429 
 
23430 
  def validate(self):
23431 
    return
23432 
 
23433 
 
23434 
  def __repr__(self):
23435 
    L = ['%s=%r' % (key, value)
23436 
      for key, value in self.__dict__.iteritems()]
23437 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
23438 
 
23439 
  def __eq__(self, other):
23440 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
23441 
 
23442 
  def __ne__(self, other):
23443 
    return not (self == other)
4757 mandeep.dh 23444 
 
5481 phani.kuma 23445 
class getBilledOrders_args:
4875 varun.gupt 23446 
  """
23447 
  Attributes:
23448 
   - vendorId
5481 phani.kuma 23449 
   - onlyVendorNotPaid
23450 
   - billingDateFrom
23451 
   - billingDateTo
4875 varun.gupt 23452 
  """
23453 
 
23454 
  thrift_spec = (
23455 
    None, # 0
23456 
    (1, TType.I64, 'vendorId', None, None, ), # 1
5481 phani.kuma 23457 
    (2, TType.BOOL, 'onlyVendorNotPaid', None, None, ), # 2
23458 
    (3, TType.I64, 'billingDateFrom', None, None, ), # 3
23459 
    (4, TType.I64, 'billingDateTo', None, None, ), # 4
4875 varun.gupt 23460 
  )
23461 
 
5481 phani.kuma 23462 
  def __init__(self, vendorId=None, onlyVendorNotPaid=None, billingDateFrom=None, billingDateTo=None,):
4875 varun.gupt 23463 
    self.vendorId = vendorId
5481 phani.kuma 23464 
    self.onlyVendorNotPaid = onlyVendorNotPaid
23465 
    self.billingDateFrom = billingDateFrom
23466 
    self.billingDateTo = billingDateTo
4875 varun.gupt 23467 
 
23468 
  def read(self, iprot):
23469 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
23470 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
23471 
      return
23472 
    iprot.readStructBegin()
23473 
    while True:
23474 
      (fname, ftype, fid) = iprot.readFieldBegin()
23475 
      if ftype == TType.STOP:
23476 
        break
23477 
      if fid == 1:
23478 
        if ftype == TType.I64:
23479 
          self.vendorId = iprot.readI64();
23480 
        else:
23481 
          iprot.skip(ftype)
5481 phani.kuma 23482 
      elif fid == 2:
23483 
        if ftype == TType.BOOL:
23484 
          self.onlyVendorNotPaid = iprot.readBool();
23485 
        else:
23486 
          iprot.skip(ftype)
23487 
      elif fid == 3:
23488 
        if ftype == TType.I64:
23489 
          self.billingDateFrom = iprot.readI64();
23490 
        else:
23491 
          iprot.skip(ftype)
23492 
      elif fid == 4:
23493 
        if ftype == TType.I64:
23494 
          self.billingDateTo = iprot.readI64();
23495 
        else:
23496 
          iprot.skip(ftype)
4875 varun.gupt 23497 
      else:
23498 
        iprot.skip(ftype)
23499 
      iprot.readFieldEnd()
23500 
    iprot.readStructEnd()
23501 
 
23502 
  def write(self, oprot):
23503 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
23504 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
23505 
      return
5481 phani.kuma 23506 
    oprot.writeStructBegin('getBilledOrders_args')
4875 varun.gupt 23507 
    if self.vendorId is not None:
23508 
      oprot.writeFieldBegin('vendorId', TType.I64, 1)
23509 
      oprot.writeI64(self.vendorId)
23510 
      oprot.writeFieldEnd()
5481 phani.kuma 23511 
    if self.onlyVendorNotPaid is not None:
23512 
      oprot.writeFieldBegin('onlyVendorNotPaid', TType.BOOL, 2)
23513 
      oprot.writeBool(self.onlyVendorNotPaid)
23514 
      oprot.writeFieldEnd()
23515 
    if self.billingDateFrom is not None:
23516 
      oprot.writeFieldBegin('billingDateFrom', TType.I64, 3)
23517 
      oprot.writeI64(self.billingDateFrom)
23518 
      oprot.writeFieldEnd()
23519 
    if self.billingDateTo is not None:
23520 
      oprot.writeFieldBegin('billingDateTo', TType.I64, 4)
23521 
      oprot.writeI64(self.billingDateTo)
23522 
      oprot.writeFieldEnd()
4875 varun.gupt 23523 
    oprot.writeFieldStop()
23524 
    oprot.writeStructEnd()
23525 
 
23526 
  def validate(self):
23527 
    return
23528 
 
23529 
 
23530 
  def __repr__(self):
23531 
    L = ['%s=%r' % (key, value)
23532 
      for key, value in self.__dict__.iteritems()]
23533 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
23534 
 
23535 
  def __eq__(self, other):
23536 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
23537 
 
23538 
  def __ne__(self, other):
23539 
    return not (self == other)
23540 
 
5481 phani.kuma 23541 
class getBilledOrders_result:
4875 varun.gupt 23542 
  """
23543 
  Attributes:
23544 
   - success
23545 
   - ex
23546 
  """
23547 
 
23548 
  thrift_spec = (
23549 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
23550 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
23551 
  )
23552 
 
23553 
  def __init__(self, success=None, ex=None,):
23554 
    self.success = success
23555 
    self.ex = ex
23556 
 
23557 
  def read(self, iprot):
23558 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
23559 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
23560 
      return
23561 
    iprot.readStructBegin()
23562 
    while True:
23563 
      (fname, ftype, fid) = iprot.readFieldBegin()
23564 
      if ftype == TType.STOP:
23565 
        break
23566 
      if fid == 0:
23567 
        if ftype == TType.LIST:
23568 
          self.success = []
6000 mandeep.dh 23569 
          (_etype551, _size548) = iprot.readListBegin()
23570 
          for _i552 in xrange(_size548):
23571 
            _elem553 = Order()
23572 
            _elem553.read(iprot)
23573 
            self.success.append(_elem553)
4875 varun.gupt 23574 
          iprot.readListEnd()
23575 
        else:
23576 
          iprot.skip(ftype)
23577 
      elif fid == 1:
23578 
        if ftype == TType.STRUCT:
23579 
          self.ex = TransactionServiceException()
23580 
          self.ex.read(iprot)
23581 
        else:
23582 
          iprot.skip(ftype)
23583 
      else:
23584 
        iprot.skip(ftype)
23585 
      iprot.readFieldEnd()
23586 
    iprot.readStructEnd()
23587 
 
23588 
  def write(self, oprot):
23589 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
23590 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
23591 
      return
5481 phani.kuma 23592 
    oprot.writeStructBegin('getBilledOrders_result')
4875 varun.gupt 23593 
    if self.success is not None:
23594 
      oprot.writeFieldBegin('success', TType.LIST, 0)
23595 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
6000 mandeep.dh 23596 
      for iter554 in self.success:
23597 
        iter554.write(oprot)
4875 varun.gupt 23598 
      oprot.writeListEnd()
23599 
      oprot.writeFieldEnd()
23600 
    if self.ex is not None:
23601 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
23602 
      self.ex.write(oprot)
23603 
      oprot.writeFieldEnd()
23604 
    oprot.writeFieldStop()
23605 
    oprot.writeStructEnd()
23606 
 
23607 
  def validate(self):
23608 
    return
23609 
 
23610 
 
23611 
  def __repr__(self):
23612 
    L = ['%s=%r' % (key, value)
23613 
      for key, value in self.__dict__.iteritems()]
23614 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
23615 
 
23616 
  def __eq__(self, other):
23617 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
23618 
 
23619 
  def __ne__(self, other):
23620 
    return not (self == other)
5031 varun.gupt 23621 
 
23622 
class getStatusDistributionOfOrders_args:
23623 
  """
23624 
  Attributes:
23625 
   - startDate
23626 
   - endDate
23627 
  """
23628 
 
23629 
  thrift_spec = (
23630 
    None, # 0
23631 
    (1, TType.I64, 'startDate', None, None, ), # 1
23632 
    (2, TType.I64, 'endDate', None, None, ), # 2
23633 
  )
23634 
 
23635 
  def __init__(self, startDate=None, endDate=None,):
23636 
    self.startDate = startDate
23637 
    self.endDate = endDate
23638 
 
23639 
  def read(self, iprot):
23640 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
23641 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
23642 
      return
23643 
    iprot.readStructBegin()
23644 
    while True:
23645 
      (fname, ftype, fid) = iprot.readFieldBegin()
23646 
      if ftype == TType.STOP:
23647 
        break
23648 
      if fid == 1:
23649 
        if ftype == TType.I64:
23650 
          self.startDate = iprot.readI64();
23651 
        else:
23652 
          iprot.skip(ftype)
23653 
      elif fid == 2:
23654 
        if ftype == TType.I64:
23655 
          self.endDate = iprot.readI64();
23656 
        else:
23657 
          iprot.skip(ftype)
23658 
      else:
23659 
        iprot.skip(ftype)
23660 
      iprot.readFieldEnd()
23661 
    iprot.readStructEnd()
23662 
 
23663 
  def write(self, oprot):
23664 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
23665 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
23666 
      return
23667 
    oprot.writeStructBegin('getStatusDistributionOfOrders_args')
23668 
    if self.startDate is not None:
23669 
      oprot.writeFieldBegin('startDate', TType.I64, 1)
23670 
      oprot.writeI64(self.startDate)
23671 
      oprot.writeFieldEnd()
23672 
    if self.endDate is not None:
23673 
      oprot.writeFieldBegin('endDate', TType.I64, 2)
23674 
      oprot.writeI64(self.endDate)
23675 
      oprot.writeFieldEnd()
23676 
    oprot.writeFieldStop()
23677 
    oprot.writeStructEnd()
23678 
 
23679 
  def validate(self):
23680 
    return
23681 
 
23682 
 
23683 
  def __repr__(self):
23684 
    L = ['%s=%r' % (key, value)
23685 
      for key, value in self.__dict__.iteritems()]
23686 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
23687 
 
23688 
  def __eq__(self, other):
23689 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
23690 
 
23691 
  def __ne__(self, other):
23692 
    return not (self == other)
23693 
 
23694 
class getStatusDistributionOfOrders_result:
23695 
  """
23696 
  Attributes:
23697 
   - success
23698 
   - ex
23699 
  """
23700 
 
23701 
  thrift_spec = (
23702 
    (0, TType.MAP, 'success', (TType.I64,None,TType.I64,None), None, ), # 0
23703 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
23704 
  )
23705 
 
23706 
  def __init__(self, success=None, ex=None,):
23707 
    self.success = success
23708 
    self.ex = ex
23709 
 
23710 
  def read(self, iprot):
23711 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
23712 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
23713 
      return
23714 
    iprot.readStructBegin()
23715 
    while True:
23716 
      (fname, ftype, fid) = iprot.readFieldBegin()
23717 
      if ftype == TType.STOP:
23718 
        break
23719 
      if fid == 0:
23720 
        if ftype == TType.MAP:
23721 
          self.success = {}
6000 mandeep.dh 23722 
          (_ktype556, _vtype557, _size555 ) = iprot.readMapBegin()
23723 
          for _i559 in xrange(_size555):
23724 
            _key560 = iprot.readI64();
23725 
            _val561 = iprot.readI64();
23726 
            self.success[_key560] = _val561
5031 varun.gupt 23727 
          iprot.readMapEnd()
23728 
        else:
23729 
          iprot.skip(ftype)
23730 
      elif fid == 1:
23731 
        if ftype == TType.STRUCT:
23732 
          self.ex = TransactionServiceException()
23733 
          self.ex.read(iprot)
23734 
        else:
23735 
          iprot.skip(ftype)
23736 
      else:
23737 
        iprot.skip(ftype)
23738 
      iprot.readFieldEnd()
23739 
    iprot.readStructEnd()
23740 
 
23741 
  def write(self, oprot):
23742 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
23743 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
23744 
      return
23745 
    oprot.writeStructBegin('getStatusDistributionOfOrders_result')
23746 
    if self.success is not None:
23747 
      oprot.writeFieldBegin('success', TType.MAP, 0)
23748 
      oprot.writeMapBegin(TType.I64, TType.I64, len(self.success))
6000 mandeep.dh 23749 
      for kiter562,viter563 in self.success.items():
23750 
        oprot.writeI64(kiter562)
23751 
        oprot.writeI64(viter563)
5031 varun.gupt 23752 
      oprot.writeMapEnd()
23753 
      oprot.writeFieldEnd()
23754 
    if self.ex is not None:
23755 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
23756 
      self.ex.write(oprot)
23757 
      oprot.writeFieldEnd()
23758 
    oprot.writeFieldStop()
23759 
    oprot.writeStructEnd()
23760 
 
23761 
  def validate(self):
23762 
    return
23763 
 
23764 
 
23765 
  def __repr__(self):
23766 
    L = ['%s=%r' % (key, value)
23767 
      for key, value in self.__dict__.iteritems()]
23768 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
23769 
 
23770 
  def __eq__(self, other):
23771 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
23772 
 
23773 
  def __ne__(self, other):
23774 
    return not (self == other)
5067 varun.gupt 23775 
 
23776 
class getOrderIdsForStatus_args:
23777 
  """
23778 
  Attributes:
23779 
   - status
23780 
   - startDatetime
23781 
   - endDatetime
23782 
  """
23783 
 
23784 
  thrift_spec = (
23785 
    None, # 0
23786 
    (1, TType.I64, 'status', None, None, ), # 1
23787 
    (2, TType.I64, 'startDatetime', None, None, ), # 2
23788 
    (3, TType.I64, 'endDatetime', None, None, ), # 3
23789 
  )
23790 
 
23791 
  def __init__(self, status=None, startDatetime=None, endDatetime=None,):
23792 
    self.status = status
23793 
    self.startDatetime = startDatetime
23794 
    self.endDatetime = endDatetime
23795 
 
23796 
  def read(self, iprot):
23797 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
23798 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
23799 
      return
23800 
    iprot.readStructBegin()
23801 
    while True:
23802 
      (fname, ftype, fid) = iprot.readFieldBegin()
23803 
      if ftype == TType.STOP:
23804 
        break
23805 
      if fid == 1:
23806 
        if ftype == TType.I64:
23807 
          self.status = iprot.readI64();
23808 
        else:
23809 
          iprot.skip(ftype)
23810 
      elif fid == 2:
23811 
        if ftype == TType.I64:
23812 
          self.startDatetime = iprot.readI64();
23813 
        else:
23814 
          iprot.skip(ftype)
23815 
      elif fid == 3:
23816 
        if ftype == TType.I64:
23817 
          self.endDatetime = iprot.readI64();
23818 
        else:
23819 
          iprot.skip(ftype)
23820 
      else:
23821 
        iprot.skip(ftype)
23822 
      iprot.readFieldEnd()
23823 
    iprot.readStructEnd()
23824 
 
23825 
  def write(self, oprot):
23826 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
23827 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
23828 
      return
23829 
    oprot.writeStructBegin('getOrderIdsForStatus_args')
23830 
    if self.status is not None:
23831 
      oprot.writeFieldBegin('status', TType.I64, 1)
23832 
      oprot.writeI64(self.status)
23833 
      oprot.writeFieldEnd()
23834 
    if self.startDatetime is not None:
23835 
      oprot.writeFieldBegin('startDatetime', TType.I64, 2)
23836 
      oprot.writeI64(self.startDatetime)
23837 
      oprot.writeFieldEnd()
23838 
    if self.endDatetime is not None:
23839 
      oprot.writeFieldBegin('endDatetime', TType.I64, 3)
23840 
      oprot.writeI64(self.endDatetime)
23841 
      oprot.writeFieldEnd()
23842 
    oprot.writeFieldStop()
23843 
    oprot.writeStructEnd()
23844 
 
23845 
  def validate(self):
23846 
    return
23847 
 
23848 
 
23849 
  def __repr__(self):
23850 
    L = ['%s=%r' % (key, value)
23851 
      for key, value in self.__dict__.iteritems()]
23852 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
23853 
 
23854 
  def __eq__(self, other):
23855 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
23856 
 
23857 
  def __ne__(self, other):
23858 
    return not (self == other)
23859 
 
23860 
class getOrderIdsForStatus_result:
23861 
  """
23862 
  Attributes:
23863 
   - success
23864 
   - ex
23865 
  """
23866 
 
23867 
  thrift_spec = (
23868 
    (0, TType.LIST, 'success', (TType.I64,None), None, ), # 0
23869 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
23870 
  )
23871 
 
23872 
  def __init__(self, success=None, ex=None,):
23873 
    self.success = success
23874 
    self.ex = ex
23875 
 
23876 
  def read(self, iprot):
23877 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
23878 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
23879 
      return
23880 
    iprot.readStructBegin()
23881 
    while True:
23882 
      (fname, ftype, fid) = iprot.readFieldBegin()
23883 
      if ftype == TType.STOP:
23884 
        break
23885 
      if fid == 0:
23886 
        if ftype == TType.LIST:
23887 
          self.success = []
6000 mandeep.dh 23888 
          (_etype567, _size564) = iprot.readListBegin()
23889 
          for _i568 in xrange(_size564):
23890 
            _elem569 = iprot.readI64();
23891 
            self.success.append(_elem569)
5067 varun.gupt 23892 
          iprot.readListEnd()
23893 
        else:
23894 
          iprot.skip(ftype)
23895 
      elif fid == 1:
23896 
        if ftype == TType.STRUCT:
23897 
          self.ex = TransactionServiceException()
23898 
          self.ex.read(iprot)
23899 
        else:
23900 
          iprot.skip(ftype)
23901 
      else:
23902 
        iprot.skip(ftype)
23903 
      iprot.readFieldEnd()
23904 
    iprot.readStructEnd()
23905 
 
23906 
  def write(self, oprot):
23907 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
23908 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
23909 
      return
23910 
    oprot.writeStructBegin('getOrderIdsForStatus_result')
23911 
    if self.success is not None:
23912 
      oprot.writeFieldBegin('success', TType.LIST, 0)
23913 
      oprot.writeListBegin(TType.I64, len(self.success))
6000 mandeep.dh 23914 
      for iter570 in self.success:
23915 
        oprot.writeI64(iter570)
5067 varun.gupt 23916 
      oprot.writeListEnd()
23917 
      oprot.writeFieldEnd()
23918 
    if self.ex is not None:
23919 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
23920 
      self.ex.write(oprot)
23921 
      oprot.writeFieldEnd()
23922 
    oprot.writeFieldStop()
23923 
    oprot.writeStructEnd()
23924 
 
23925 
  def validate(self):
23926 
    return
23927 
 
23928 
 
23929 
  def __repr__(self):
23930 
    L = ['%s=%r' % (key, value)
23931 
      for key, value in self.__dict__.iteritems()]
23932 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
23933 
 
23934 
  def __eq__(self, other):
23935 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
23936 
 
23937 
  def __ne__(self, other):
23938 
    return not (self == other)
5099 varun.gupt 23939 
 
5348 anupam.sin 23940 
class updateCODAgent_args:
23941 
  """
23942 
  Attributes:
23943 
   - agent
23944 
   - orderId
23945 
  """
23946 
 
23947 
  thrift_spec = (
23948 
    None, # 0
23949 
    (1, TType.STRING, 'agent', None, None, ), # 1
23950 
    (2, TType.I64, 'orderId', None, None, ), # 2
23951 
  )
23952 
 
23953 
  def __init__(self, agent=None, orderId=None,):
23954 
    self.agent = agent
23955 
    self.orderId = orderId
23956 
 
23957 
  def read(self, iprot):
23958 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
23959 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
23960 
      return
23961 
    iprot.readStructBegin()
23962 
    while True:
23963 
      (fname, ftype, fid) = iprot.readFieldBegin()
23964 
      if ftype == TType.STOP:
23965 
        break
23966 
      if fid == 1:
23967 
        if ftype == TType.STRING:
23968 
          self.agent = iprot.readString();
23969 
        else:
23970 
          iprot.skip(ftype)
23971 
      elif fid == 2:
23972 
        if ftype == TType.I64:
23973 
          self.orderId = iprot.readI64();
23974 
        else:
23975 
          iprot.skip(ftype)
23976 
      else:
23977 
        iprot.skip(ftype)
23978 
      iprot.readFieldEnd()
23979 
    iprot.readStructEnd()
23980 
 
23981 
  def write(self, oprot):
23982 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
23983 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
23984 
      return
23985 
    oprot.writeStructBegin('updateCODAgent_args')
23986 
    if self.agent is not None:
23987 
      oprot.writeFieldBegin('agent', TType.STRING, 1)
23988 
      oprot.writeString(self.agent)
23989 
      oprot.writeFieldEnd()
23990 
    if self.orderId is not None:
23991 
      oprot.writeFieldBegin('orderId', TType.I64, 2)
23992 
      oprot.writeI64(self.orderId)
23993 
      oprot.writeFieldEnd()
23994 
    oprot.writeFieldStop()
23995 
    oprot.writeStructEnd()
23996 
 
23997 
  def validate(self):
23998 
    return
23999 
 
24000 
 
24001 
  def __repr__(self):
24002 
    L = ['%s=%r' % (key, value)
24003 
      for key, value in self.__dict__.iteritems()]
24004 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
24005 
 
24006 
  def __eq__(self, other):
24007 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
24008 
 
24009 
  def __ne__(self, other):
24010 
    return not (self == other)
24011 
 
24012 
class updateCODAgent_result:
24013 
  """
24014 
  Attributes:
24015 
   - ex
24016 
  """
24017 
 
24018 
  thrift_spec = (
24019 
    None, # 0
24020 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
24021 
  )
24022 
 
24023 
  def __init__(self, ex=None,):
24024 
    self.ex = ex
24025 
 
24026 
  def read(self, iprot):
24027 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
24028 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
24029 
      return
24030 
    iprot.readStructBegin()
24031 
    while True:
24032 
      (fname, ftype, fid) = iprot.readFieldBegin()
24033 
      if ftype == TType.STOP:
24034 
        break
24035 
      if fid == 1:
24036 
        if ftype == TType.STRUCT:
24037 
          self.ex = TransactionServiceException()
24038 
          self.ex.read(iprot)
24039 
        else:
24040 
          iprot.skip(ftype)
24041 
      else:
24042 
        iprot.skip(ftype)
24043 
      iprot.readFieldEnd()
24044 
    iprot.readStructEnd()
24045 
 
24046 
  def write(self, oprot):
24047 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
24048 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
24049 
      return
24050 
    oprot.writeStructBegin('updateCODAgent_result')
24051 
    if self.ex is not None:
24052 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
24053 
      self.ex.write(oprot)
24054 
      oprot.writeFieldEnd()
24055 
    oprot.writeFieldStop()
24056 
    oprot.writeStructEnd()
24057 
 
24058 
  def validate(self):
24059 
    return
24060 
 
24061 
 
24062 
  def __repr__(self):
24063 
    L = ['%s=%r' % (key, value)
24064 
      for key, value in self.__dict__.iteritems()]
24065 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
24066 
 
24067 
  def __eq__(self, other):
24068 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
24069 
 
24070 
  def __ne__(self, other):
24071 
    return not (self == other)
24072 
 
5099 varun.gupt 24073 
class updateOrderAsPaidToVendor_args:
24074 
  """
24075 
  Attributes:
24076 
   - orderId
24077 
  """
24078 
 
24079 
  thrift_spec = (
24080 
    None, # 0
24081 
    (1, TType.I64, 'orderId', None, None, ), # 1
24082 
  )
24083 
 
24084 
  def __init__(self, orderId=None,):
24085 
    self.orderId = orderId
24086 
 
24087 
  def read(self, iprot):
24088 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
24089 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
24090 
      return
24091 
    iprot.readStructBegin()
24092 
    while True:
24093 
      (fname, ftype, fid) = iprot.readFieldBegin()
24094 
      if ftype == TType.STOP:
24095 
        break
24096 
      if fid == 1:
24097 
        if ftype == TType.I64:
24098 
          self.orderId = iprot.readI64();
24099 
        else:
24100 
          iprot.skip(ftype)
24101 
      else:
24102 
        iprot.skip(ftype)
24103 
      iprot.readFieldEnd()
24104 
    iprot.readStructEnd()
24105 
 
24106 
  def write(self, oprot):
24107 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
24108 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
24109 
      return
24110 
    oprot.writeStructBegin('updateOrderAsPaidToVendor_args')
24111 
    if self.orderId is not None:
24112 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
24113 
      oprot.writeI64(self.orderId)
24114 
      oprot.writeFieldEnd()
24115 
    oprot.writeFieldStop()
24116 
    oprot.writeStructEnd()
24117 
 
24118 
  def validate(self):
24119 
    return
24120 
 
24121 
 
24122 
  def __repr__(self):
24123 
    L = ['%s=%r' % (key, value)
24124 
      for key, value in self.__dict__.iteritems()]
24125 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
24126 
 
24127 
  def __eq__(self, other):
24128 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
24129 
 
24130 
  def __ne__(self, other):
24131 
    return not (self == other)
24132 
 
24133 
class updateOrderAsPaidToVendor_result:
24134 
  """
24135 
  Attributes:
24136 
   - ex
24137 
  """
24138 
 
24139 
  thrift_spec = (
24140 
    None, # 0
24141 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
24142 
  )
24143 
 
24144 
  def __init__(self, ex=None,):
24145 
    self.ex = ex
24146 
 
24147 
  def read(self, iprot):
24148 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
24149 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
24150 
      return
24151 
    iprot.readStructBegin()
24152 
    while True:
24153 
      (fname, ftype, fid) = iprot.readFieldBegin()
24154 
      if ftype == TType.STOP:
24155 
        break
24156 
      if fid == 1:
24157 
        if ftype == TType.STRUCT:
24158 
          self.ex = TransactionServiceException()
24159 
          self.ex.read(iprot)
24160 
        else:
24161 
          iprot.skip(ftype)
24162 
      else:
24163 
        iprot.skip(ftype)
24164 
      iprot.readFieldEnd()
24165 
    iprot.readStructEnd()
24166 
 
24167 
  def write(self, oprot):
24168 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
24169 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
24170 
      return
24171 
    oprot.writeStructBegin('updateOrderAsPaidToVendor_result')
24172 
    if self.ex is not None:
24173 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
24174 
      self.ex.write(oprot)
24175 
      oprot.writeFieldEnd()
24176 
    oprot.writeFieldStop()
24177 
    oprot.writeStructEnd()
24178 
 
24179 
  def validate(self):
24180 
    return
24181 
 
24182 
 
24183 
  def __repr__(self):
24184 
    L = ['%s=%r' % (key, value)
24185 
      for key, value in self.__dict__.iteritems()]
24186 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
24187 
 
24188 
  def __eq__(self, other):
24189 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
24190 
 
24191 
  def __ne__(self, other):
24192 
    return not (self == other)
5208 varun.gupt 24193 
 
5386 phani.kuma 24194 
class updateOrderOnlyAsPaidToVendor_args:
24195 
  """
24196 
  Attributes:
24197 
   - orderId
24198 
  """
24199 
 
24200 
  thrift_spec = (
24201 
    None, # 0
24202 
    (1, TType.I64, 'orderId', None, None, ), # 1
24203 
  )
24204 
 
24205 
  def __init__(self, orderId=None,):
24206 
    self.orderId = orderId
24207 
 
24208 
  def read(self, iprot):
24209 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
24210 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
24211 
      return
24212 
    iprot.readStructBegin()
24213 
    while True:
24214 
      (fname, ftype, fid) = iprot.readFieldBegin()
24215 
      if ftype == TType.STOP:
24216 
        break
24217 
      if fid == 1:
24218 
        if ftype == TType.I64:
24219 
          self.orderId = iprot.readI64();
24220 
        else:
24221 
          iprot.skip(ftype)
24222 
      else:
24223 
        iprot.skip(ftype)
24224 
      iprot.readFieldEnd()
24225 
    iprot.readStructEnd()
24226 
 
24227 
  def write(self, oprot):
24228 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
24229 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
24230 
      return
24231 
    oprot.writeStructBegin('updateOrderOnlyAsPaidToVendor_args')
24232 
    if self.orderId is not None:
24233 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
24234 
      oprot.writeI64(self.orderId)
24235 
      oprot.writeFieldEnd()
24236 
    oprot.writeFieldStop()
24237 
    oprot.writeStructEnd()
24238 
 
24239 
  def validate(self):
24240 
    return
24241 
 
24242 
 
24243 
  def __repr__(self):
24244 
    L = ['%s=%r' % (key, value)
24245 
      for key, value in self.__dict__.iteritems()]
24246 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
24247 
 
24248 
  def __eq__(self, other):
24249 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
24250 
 
24251 
  def __ne__(self, other):
24252 
    return not (self == other)
24253 
 
24254 
class updateOrderOnlyAsPaidToVendor_result:
24255 
  """
24256 
  Attributes:
24257 
   - ex
24258 
  """
24259 
 
24260 
  thrift_spec = (
24261 
    None, # 0
24262 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
24263 
  )
24264 
 
24265 
  def __init__(self, ex=None,):
24266 
    self.ex = ex
24267 
 
24268 
  def read(self, iprot):
24269 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
24270 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
24271 
      return
24272 
    iprot.readStructBegin()
24273 
    while True:
24274 
      (fname, ftype, fid) = iprot.readFieldBegin()
24275 
      if ftype == TType.STOP:
24276 
        break
24277 
      if fid == 1:
24278 
        if ftype == TType.STRUCT:
24279 
          self.ex = TransactionServiceException()
24280 
          self.ex.read(iprot)
24281 
        else:
24282 
          iprot.skip(ftype)
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('updateOrderOnlyAsPaidToVendor_result')
24293 
    if self.ex is not None:
24294 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
24295 
      self.ex.write(oprot)
24296 
      oprot.writeFieldEnd()
24297 
    oprot.writeFieldStop()
24298 
    oprot.writeStructEnd()
24299 
 
24300 
  def validate(self):
24301 
    return
24302 
 
24303 
 
24304 
  def __repr__(self):
24305 
    L = ['%s=%r' % (key, value)
24306 
      for key, value in self.__dict__.iteritems()]
24307 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
24308 
 
24309 
  def __eq__(self, other):
24310 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
24311 
 
24312 
  def __ne__(self, other):
24313 
    return not (self == other)
24314 
 
5208 varun.gupt 24315 
class getRefundedOrdersMarkedPaid_args:
24316 
 
24317 
  thrift_spec = (
24318 
  )
24319 
 
24320 
  def read(self, iprot):
24321 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
24322 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
24323 
      return
24324 
    iprot.readStructBegin()
24325 
    while True:
24326 
      (fname, ftype, fid) = iprot.readFieldBegin()
24327 
      if ftype == TType.STOP:
24328 
        break
24329 
      else:
24330 
        iprot.skip(ftype)
24331 
      iprot.readFieldEnd()
24332 
    iprot.readStructEnd()
24333 
 
24334 
  def write(self, oprot):
24335 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
24336 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
24337 
      return
24338 
    oprot.writeStructBegin('getRefundedOrdersMarkedPaid_args')
24339 
    oprot.writeFieldStop()
24340 
    oprot.writeStructEnd()
24341 
 
24342 
  def validate(self):
24343 
    return
24344 
 
24345 
 
24346 
  def __repr__(self):
24347 
    L = ['%s=%r' % (key, value)
24348 
      for key, value in self.__dict__.iteritems()]
24349 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
24350 
 
24351 
  def __eq__(self, other):
24352 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
24353 
 
24354 
  def __ne__(self, other):
24355 
    return not (self == other)
24356 
 
24357 
class getRefundedOrdersMarkedPaid_result:
24358 
  """
24359 
  Attributes:
24360 
   - success
24361 
   - ex
24362 
  """
24363 
 
24364 
  thrift_spec = (
24365 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
24366 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
24367 
  )
24368 
 
24369 
  def __init__(self, success=None, ex=None,):
24370 
    self.success = success
24371 
    self.ex = ex
24372 
 
24373 
  def read(self, iprot):
24374 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
24375 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
24376 
      return
24377 
    iprot.readStructBegin()
24378 
    while True:
24379 
      (fname, ftype, fid) = iprot.readFieldBegin()
24380 
      if ftype == TType.STOP:
24381 
        break
24382 
      if fid == 0:
24383 
        if ftype == TType.LIST:
24384 
          self.success = []
6000 mandeep.dh 24385 
          (_etype574, _size571) = iprot.readListBegin()
24386 
          for _i575 in xrange(_size571):
24387 
            _elem576 = Order()
24388 
            _elem576.read(iprot)
24389 
            self.success.append(_elem576)
5208 varun.gupt 24390 
          iprot.readListEnd()
24391 
        else:
24392 
          iprot.skip(ftype)
24393 
      elif fid == 1:
24394 
        if ftype == TType.STRUCT:
24395 
          self.ex = TransactionServiceException()
24396 
          self.ex.read(iprot)
24397 
        else:
24398 
          iprot.skip(ftype)
24399 
      else:
24400 
        iprot.skip(ftype)
24401 
      iprot.readFieldEnd()
24402 
    iprot.readStructEnd()
24403 
 
24404 
  def write(self, oprot):
24405 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
24406 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
24407 
      return
24408 
    oprot.writeStructBegin('getRefundedOrdersMarkedPaid_result')
24409 
    if self.success is not None:
24410 
      oprot.writeFieldBegin('success', TType.LIST, 0)
24411 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
6000 mandeep.dh 24412 
      for iter577 in self.success:
24413 
        iter577.write(oprot)
5208 varun.gupt 24414 
      oprot.writeListEnd()
24415 
      oprot.writeFieldEnd()
24416 
    if self.ex is not None:
24417 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
24418 
      self.ex.write(oprot)
24419 
      oprot.writeFieldEnd()
24420 
    oprot.writeFieldStop()
24421 
    oprot.writeStructEnd()
24422 
 
24423 
  def validate(self):
24424 
    return
24425 
 
24426 
 
24427 
  def __repr__(self):
24428 
    L = ['%s=%r' % (key, value)
24429 
      for key, value in self.__dict__.iteritems()]
24430 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
24431 
 
24432 
  def __eq__(self, other):
24433 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
24434 
 
24435 
  def __ne__(self, other):
24436 
    return not (self == other)
5447 anupam.sin 24437 
 
24438 
class getAllVerificationAgents_args:
24439 
  """
24440 
  Attributes:
24441 
   - minOrderId
24442 
   - maxOrderId
24443 
  """
24444 
 
24445 
  thrift_spec = (
24446 
    None, # 0
24447 
    (1, TType.I64, 'minOrderId', None, None, ), # 1
24448 
    (2, TType.I64, 'maxOrderId', None, None, ), # 2
24449 
  )
24450 
 
24451 
  def __init__(self, minOrderId=None, maxOrderId=None,):
24452 
    self.minOrderId = minOrderId
24453 
    self.maxOrderId = maxOrderId
24454 
 
24455 
  def read(self, iprot):
24456 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
24457 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
24458 
      return
24459 
    iprot.readStructBegin()
24460 
    while True:
24461 
      (fname, ftype, fid) = iprot.readFieldBegin()
24462 
      if ftype == TType.STOP:
24463 
        break
24464 
      if fid == 1:
24465 
        if ftype == TType.I64:
24466 
          self.minOrderId = iprot.readI64();
24467 
        else:
24468 
          iprot.skip(ftype)
24469 
      elif fid == 2:
24470 
        if ftype == TType.I64:
24471 
          self.maxOrderId = iprot.readI64();
24472 
        else:
24473 
          iprot.skip(ftype)
24474 
      else:
24475 
        iprot.skip(ftype)
24476 
      iprot.readFieldEnd()
24477 
    iprot.readStructEnd()
24478 
 
24479 
  def write(self, oprot):
24480 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
24481 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
24482 
      return
24483 
    oprot.writeStructBegin('getAllVerificationAgents_args')
24484 
    if self.minOrderId is not None:
24485 
      oprot.writeFieldBegin('minOrderId', TType.I64, 1)
24486 
      oprot.writeI64(self.minOrderId)
24487 
      oprot.writeFieldEnd()
24488 
    if self.maxOrderId is not None:
24489 
      oprot.writeFieldBegin('maxOrderId', TType.I64, 2)
24490 
      oprot.writeI64(self.maxOrderId)
24491 
      oprot.writeFieldEnd()
24492 
    oprot.writeFieldStop()
24493 
    oprot.writeStructEnd()
24494 
 
24495 
  def validate(self):
24496 
    return
24497 
 
24498 
 
24499 
  def __repr__(self):
24500 
    L = ['%s=%r' % (key, value)
24501 
      for key, value in self.__dict__.iteritems()]
24502 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
24503 
 
24504 
  def __eq__(self, other):
24505 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
24506 
 
24507 
  def __ne__(self, other):
24508 
    return not (self == other)
24509 
 
24510 
class getAllVerificationAgents_result:
24511 
  """
24512 
  Attributes:
24513 
   - success
24514 
  """
24515 
 
24516 
  thrift_spec = (
24517 
    (0, TType.LIST, 'success', (TType.STRUCT,(CODVerificationAgent, CODVerificationAgent.thrift_spec)), None, ), # 0
24518 
  )
24519 
 
24520 
  def __init__(self, success=None,):
24521 
    self.success = success
24522 
 
24523 
  def read(self, iprot):
24524 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
24525 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
24526 
      return
24527 
    iprot.readStructBegin()
24528 
    while True:
24529 
      (fname, ftype, fid) = iprot.readFieldBegin()
24530 
      if ftype == TType.STOP:
24531 
        break
24532 
      if fid == 0:
24533 
        if ftype == TType.LIST:
24534 
          self.success = []
6000 mandeep.dh 24535 
          (_etype581, _size578) = iprot.readListBegin()
24536 
          for _i582 in xrange(_size578):
24537 
            _elem583 = CODVerificationAgent()
24538 
            _elem583.read(iprot)
24539 
            self.success.append(_elem583)
5447 anupam.sin 24540 
          iprot.readListEnd()
24541 
        else:
24542 
          iprot.skip(ftype)
24543 
      else:
24544 
        iprot.skip(ftype)
24545 
      iprot.readFieldEnd()
24546 
    iprot.readStructEnd()
24547 
 
24548 
  def write(self, oprot):
24549 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
24550 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
24551 
      return
24552 
    oprot.writeStructBegin('getAllVerificationAgents_result')
24553 
    if self.success is not None:
24554 
      oprot.writeFieldBegin('success', TType.LIST, 0)
24555 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
6000 mandeep.dh 24556 
      for iter584 in self.success:
24557 
        iter584.write(oprot)
5447 anupam.sin 24558 
      oprot.writeListEnd()
24559 
      oprot.writeFieldEnd()
24560 
    oprot.writeFieldStop()
24561 
    oprot.writeStructEnd()
24562 
 
24563 
  def validate(self):
24564 
    return
24565 
 
24566 
 
24567 
  def __repr__(self):
24568 
    L = ['%s=%r' % (key, value)
24569 
      for key, value in self.__dict__.iteritems()]
24570 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
24571 
 
24572 
  def __eq__(self, other):
24573 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
24574 
 
24575 
  def __ne__(self, other):
24576 
    return not (self == other)
5527 anupam.sin 24577 
 
24578 
class getAllAttributesForOrderId_args:
24579 
  """
24580 
  Attributes:
24581 
   - orderId
24582 
  """
24583 
 
24584 
  thrift_spec = (
24585 
    None, # 0
24586 
    (1, TType.I64, 'orderId', None, None, ), # 1
24587 
  )
24588 
 
24589 
  def __init__(self, orderId=None,):
24590 
    self.orderId = orderId
24591 
 
24592 
  def read(self, iprot):
24593 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
24594 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
24595 
      return
24596 
    iprot.readStructBegin()
24597 
    while True:
24598 
      (fname, ftype, fid) = iprot.readFieldBegin()
24599 
      if ftype == TType.STOP:
24600 
        break
24601 
      if fid == 1:
24602 
        if ftype == TType.I64:
24603 
          self.orderId = iprot.readI64();
24604 
        else:
24605 
          iprot.skip(ftype)
24606 
      else:
24607 
        iprot.skip(ftype)
24608 
      iprot.readFieldEnd()
24609 
    iprot.readStructEnd()
24610 
 
24611 
  def write(self, oprot):
24612 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
24613 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
24614 
      return
24615 
    oprot.writeStructBegin('getAllAttributesForOrderId_args')
24616 
    if self.orderId is not None:
24617 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
24618 
      oprot.writeI64(self.orderId)
24619 
      oprot.writeFieldEnd()
24620 
    oprot.writeFieldStop()
24621 
    oprot.writeStructEnd()
24622 
 
24623 
  def validate(self):
24624 
    return
24625 
 
24626 
 
24627 
  def __repr__(self):
24628 
    L = ['%s=%r' % (key, value)
24629 
      for key, value in self.__dict__.iteritems()]
24630 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
24631 
 
24632 
  def __eq__(self, other):
24633 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
24634 
 
24635 
  def __ne__(self, other):
24636 
    return not (self == other)
24637 
 
24638 
class getAllAttributesForOrderId_result:
24639 
  """
24640 
  Attributes:
24641 
   - success
24642 
  """
24643 
 
24644 
  thrift_spec = (
24645 
    (0, TType.LIST, 'success', (TType.STRUCT,(Attribute, Attribute.thrift_spec)), None, ), # 0
24646 
  )
24647 
 
24648 
  def __init__(self, success=None,):
24649 
    self.success = success
24650 
 
24651 
  def read(self, iprot):
24652 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
24653 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
24654 
      return
24655 
    iprot.readStructBegin()
24656 
    while True:
24657 
      (fname, ftype, fid) = iprot.readFieldBegin()
24658 
      if ftype == TType.STOP:
24659 
        break
24660 
      if fid == 0:
24661 
        if ftype == TType.LIST:
24662 
          self.success = []
6000 mandeep.dh 24663 
          (_etype588, _size585) = iprot.readListBegin()
24664 
          for _i589 in xrange(_size585):
24665 
            _elem590 = Attribute()
24666 
            _elem590.read(iprot)
24667 
            self.success.append(_elem590)
5527 anupam.sin 24668 
          iprot.readListEnd()
24669 
        else:
24670 
          iprot.skip(ftype)
24671 
      else:
24672 
        iprot.skip(ftype)
24673 
      iprot.readFieldEnd()
24674 
    iprot.readStructEnd()
24675 
 
24676 
  def write(self, oprot):
24677 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
24678 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
24679 
      return
24680 
    oprot.writeStructBegin('getAllAttributesForOrderId_result')
24681 
    if self.success is not None:
24682 
      oprot.writeFieldBegin('success', TType.LIST, 0)
24683 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
6000 mandeep.dh 24684 
      for iter591 in self.success:
24685 
        iter591.write(oprot)
5527 anupam.sin 24686 
      oprot.writeListEnd()
24687 
      oprot.writeFieldEnd()
24688 
    oprot.writeFieldStop()
24689 
    oprot.writeStructEnd()
24690 
 
24691 
  def validate(self):
24692 
    return
24693 
 
24694 
 
24695 
  def __repr__(self):
24696 
    L = ['%s=%r' % (key, value)
24697 
      for key, value in self.__dict__.iteritems()]
24698 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
24699 
 
24700 
  def __eq__(self, other):
24701 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
24702 
 
24703 
  def __ne__(self, other):
24704 
    return not (self == other)
24705 
 
5676 rajveer 24706 
class setOrderAttributes_args:
24707 
  """
24708 
  Attributes:
24709 
   - orderId
24710 
   - attributes
24711 
  """
24712 
 
24713 
  thrift_spec = None
24714 
  def __init__(self, orderId=None, attributes=None,):
24715 
    self.orderId = orderId
24716 
    self.attributes = attributes
24717 
 
24718 
  def read(self, iprot):
24719 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
24720 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
24721 
      return
24722 
    iprot.readStructBegin()
24723 
    while True:
24724 
      (fname, ftype, fid) = iprot.readFieldBegin()
24725 
      if ftype == TType.STOP:
24726 
        break
24727 
      if fid == 1:
24728 
        if ftype == TType.I64:
24729 
          self.orderId = iprot.readI64();
24730 
        else:
24731 
          iprot.skip(ftype)
24732 
      elif fid == -1:
24733 
        if ftype == TType.LIST:
24734 
          self.attributes = []
6000 mandeep.dh 24735 
          (_etype595, _size592) = iprot.readListBegin()
24736 
          for _i596 in xrange(_size592):
24737 
            _elem597 = Attribute()
24738 
            _elem597.read(iprot)
24739 
            self.attributes.append(_elem597)
5676 rajveer 24740 
          iprot.readListEnd()
24741 
        else:
24742 
          iprot.skip(ftype)
24743 
      else:
24744 
        iprot.skip(ftype)
24745 
      iprot.readFieldEnd()
24746 
    iprot.readStructEnd()
24747 
 
24748 
  def write(self, oprot):
24749 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
24750 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
24751 
      return
24752 
    oprot.writeStructBegin('setOrderAttributes_args')
24753 
    if self.attributes is not None:
24754 
      oprot.writeFieldBegin('attributes', TType.LIST, -1)
24755 
      oprot.writeListBegin(TType.STRUCT, len(self.attributes))
6000 mandeep.dh 24756 
      for iter598 in self.attributes:
24757 
        iter598.write(oprot)
5676 rajveer 24758 
      oprot.writeListEnd()
24759 
      oprot.writeFieldEnd()
24760 
    if self.orderId is not None:
24761 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
24762 
      oprot.writeI64(self.orderId)
24763 
      oprot.writeFieldEnd()
24764 
    oprot.writeFieldStop()
24765 
    oprot.writeStructEnd()
24766 
 
24767 
  def validate(self):
24768 
    return
24769 
 
24770 
 
24771 
  def __repr__(self):
24772 
    L = ['%s=%r' % (key, value)
24773 
      for key, value in self.__dict__.iteritems()]
24774 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
24775 
 
24776 
  def __eq__(self, other):
24777 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
24778 
 
24779 
  def __ne__(self, other):
24780 
    return not (self == other)
24781 
 
24782 
class setOrderAttributes_result:
24783 
 
24784 
  thrift_spec = (
24785 
  )
24786 
 
24787 
  def read(self, iprot):
24788 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
24789 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
24790 
      return
24791 
    iprot.readStructBegin()
24792 
    while True:
24793 
      (fname, ftype, fid) = iprot.readFieldBegin()
24794 
      if ftype == TType.STOP:
24795 
        break
24796 
      else:
24797 
        iprot.skip(ftype)
24798 
      iprot.readFieldEnd()
24799 
    iprot.readStructEnd()
24800 
 
24801 
  def write(self, oprot):
24802 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
24803 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
24804 
      return
24805 
    oprot.writeStructBegin('setOrderAttributes_result')
24806 
    oprot.writeFieldStop()
24807 
    oprot.writeStructEnd()
24808 
 
24809 
  def validate(self):
24810 
    return
24811 
 
24812 
 
24813 
  def __repr__(self):
24814 
    L = ['%s=%r' % (key, value)
24815 
      for key, value in self.__dict__.iteritems()]
24816 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
24817 
 
24818 
  def __eq__(self, other):
24819 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
24820 
 
24821 
  def __ne__(self, other):
24822 
    return not (self == other)
24823 
 
5527 anupam.sin 24824 
class setOrderAttributeForTransaction_args:
24825 
  """
24826 
  Attributes:
24827 
   - transactionId
24828 
   - attribute
24829 
  """
24830 
 
24831 
  thrift_spec = None
24832 
  def __init__(self, transactionId=None, attribute=None,):
24833 
    self.transactionId = transactionId
24834 
    self.attribute = attribute
24835 
 
24836 
  def read(self, iprot):
24837 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
24838 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
24839 
      return
24840 
    iprot.readStructBegin()
24841 
    while True:
24842 
      (fname, ftype, fid) = iprot.readFieldBegin()
24843 
      if ftype == TType.STOP:
24844 
        break
24845 
      if fid == 1:
24846 
        if ftype == TType.I64:
24847 
          self.transactionId = iprot.readI64();
24848 
        else:
24849 
          iprot.skip(ftype)
24850 
      elif fid == -1:
24851 
        if ftype == TType.STRUCT:
24852 
          self.attribute = Attribute()
24853 
          self.attribute.read(iprot)
24854 
        else:
24855 
          iprot.skip(ftype)
24856 
      else:
24857 
        iprot.skip(ftype)
24858 
      iprot.readFieldEnd()
24859 
    iprot.readStructEnd()
24860 
 
24861 
  def write(self, oprot):
24862 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
24863 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
24864 
      return
24865 
    oprot.writeStructBegin('setOrderAttributeForTransaction_args')
24866 
    if self.attribute is not None:
24867 
      oprot.writeFieldBegin('attribute', TType.STRUCT, -1)
24868 
      self.attribute.write(oprot)
24869 
      oprot.writeFieldEnd()
24870 
    if self.transactionId is not None:
24871 
      oprot.writeFieldBegin('transactionId', TType.I64, 1)
24872 
      oprot.writeI64(self.transactionId)
24873 
      oprot.writeFieldEnd()
24874 
    oprot.writeFieldStop()
24875 
    oprot.writeStructEnd()
24876 
 
24877 
  def validate(self):
24878 
    return
24879 
 
24880 
 
24881 
  def __repr__(self):
24882 
    L = ['%s=%r' % (key, value)
24883 
      for key, value in self.__dict__.iteritems()]
24884 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
24885 
 
24886 
  def __eq__(self, other):
24887 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
24888 
 
24889 
  def __ne__(self, other):
24890 
    return not (self == other)
24891 
 
24892 
class setOrderAttributeForTransaction_result:
24893 
 
24894 
  thrift_spec = (
24895 
  )
24896 
 
24897 
  def read(self, iprot):
24898 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
24899 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
24900 
      return
24901 
    iprot.readStructBegin()
24902 
    while True:
24903 
      (fname, ftype, fid) = iprot.readFieldBegin()
24904 
      if ftype == TType.STOP:
24905 
        break
24906 
      else:
24907 
        iprot.skip(ftype)
24908 
      iprot.readFieldEnd()
24909 
    iprot.readStructEnd()
24910 
 
24911 
  def write(self, oprot):
24912 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
24913 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
24914 
      return
24915 
    oprot.writeStructBegin('setOrderAttributeForTransaction_result')
24916 
    oprot.writeFieldStop()
24917 
    oprot.writeStructEnd()
24918 
 
24919 
  def validate(self):
24920 
    return
24921 
 
24922 
 
24923 
  def __repr__(self):
24924 
    L = ['%s=%r' % (key, value)
24925 
      for key, value in self.__dict__.iteritems()]
24926 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
24927 
 
24928 
  def __eq__(self, other):
24929 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
24930 
 
24931 
  def __ne__(self, other):
24932 
    return not (self == other)
5553 rajveer 24933 
 
24934 
class getReceivePendingOrders_args:
24935 
  """
24936 
  Attributes:
24937 
   - storeId
24938 
  """
24939 
 
24940 
  thrift_spec = (
24941 
    None, # 0
24942 
    (1, TType.I64, 'storeId', None, None, ), # 1
24943 
  )
24944 
 
24945 
  def __init__(self, storeId=None,):
24946 
    self.storeId = storeId
24947 
 
24948 
  def read(self, iprot):
24949 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
24950 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
24951 
      return
24952 
    iprot.readStructBegin()
24953 
    while True:
24954 
      (fname, ftype, fid) = iprot.readFieldBegin()
24955 
      if ftype == TType.STOP:
24956 
        break
24957 
      if fid == 1:
24958 
        if ftype == TType.I64:
24959 
          self.storeId = iprot.readI64();
24960 
        else:
24961 
          iprot.skip(ftype)
24962 
      else:
24963 
        iprot.skip(ftype)
24964 
      iprot.readFieldEnd()
24965 
    iprot.readStructEnd()
24966 
 
24967 
  def write(self, oprot):
24968 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
24969 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
24970 
      return
24971 
    oprot.writeStructBegin('getReceivePendingOrders_args')
24972 
    if self.storeId is not None:
24973 
      oprot.writeFieldBegin('storeId', TType.I64, 1)
24974 
      oprot.writeI64(self.storeId)
24975 
      oprot.writeFieldEnd()
24976 
    oprot.writeFieldStop()
24977 
    oprot.writeStructEnd()
24978 
 
24979 
  def validate(self):
24980 
    return
24981 
 
24982 
 
24983 
  def __repr__(self):
24984 
    L = ['%s=%r' % (key, value)
24985 
      for key, value in self.__dict__.iteritems()]
24986 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
24987 
 
24988 
  def __eq__(self, other):
24989 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
24990 
 
24991 
  def __ne__(self, other):
24992 
    return not (self == other)
24993 
 
24994 
class getReceivePendingOrders_result:
24995 
  """
24996 
  Attributes:
24997 
   - success
24998 
  """
24999 
 
25000 
  thrift_spec = (
25001 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
25002 
  )
25003 
 
25004 
  def __init__(self, success=None,):
25005 
    self.success = success
25006 
 
25007 
  def read(self, iprot):
25008 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
25009 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
25010 
      return
25011 
    iprot.readStructBegin()
25012 
    while True:
25013 
      (fname, ftype, fid) = iprot.readFieldBegin()
25014 
      if ftype == TType.STOP:
25015 
        break
25016 
      if fid == 0:
25017 
        if ftype == TType.LIST:
25018 
          self.success = []
6000 mandeep.dh 25019 
          (_etype602, _size599) = iprot.readListBegin()
25020 
          for _i603 in xrange(_size599):
25021 
            _elem604 = Order()
25022 
            _elem604.read(iprot)
25023 
            self.success.append(_elem604)
5553 rajveer 25024 
          iprot.readListEnd()
25025 
        else:
25026 
          iprot.skip(ftype)
25027 
      else:
25028 
        iprot.skip(ftype)
25029 
      iprot.readFieldEnd()
25030 
    iprot.readStructEnd()
25031 
 
25032 
  def write(self, oprot):
25033 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
25034 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
25035 
      return
25036 
    oprot.writeStructBegin('getReceivePendingOrders_result')
25037 
    if self.success is not None:
25038 
      oprot.writeFieldBegin('success', TType.LIST, 0)
25039 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
6000 mandeep.dh 25040 
      for iter605 in self.success:
25041 
        iter605.write(oprot)
5553 rajveer 25042 
      oprot.writeListEnd()
25043 
      oprot.writeFieldEnd()
25044 
    oprot.writeFieldStop()
25045 
    oprot.writeStructEnd()
25046 
 
25047 
  def validate(self):
25048 
    return
25049 
 
25050 
 
25051 
  def __repr__(self):
25052 
    L = ['%s=%r' % (key, value)
25053 
      for key, value in self.__dict__.iteritems()]
25054 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
25055 
 
25056 
  def __eq__(self, other):
25057 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
25058 
 
25059 
  def __ne__(self, other):
25060 
    return not (self == other)
25061 
 
25062 
class getReceivedAtStoreOrders_args:
25063 
  """
25064 
  Attributes:
25065 
   - storeId
25066 
  """
25067 
 
25068 
  thrift_spec = (
25069 
    None, # 0
25070 
    (1, TType.I64, 'storeId', None, None, ), # 1
25071 
  )
25072 
 
25073 
  def __init__(self, storeId=None,):
25074 
    self.storeId = storeId
25075 
 
25076 
  def read(self, iprot):
25077 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
25078 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
25079 
      return
25080 
    iprot.readStructBegin()
25081 
    while True:
25082 
      (fname, ftype, fid) = iprot.readFieldBegin()
25083 
      if ftype == TType.STOP:
25084 
        break
25085 
      if fid == 1:
25086 
        if ftype == TType.I64:
25087 
          self.storeId = iprot.readI64();
25088 
        else:
25089 
          iprot.skip(ftype)
25090 
      else:
25091 
        iprot.skip(ftype)
25092 
      iprot.readFieldEnd()
25093 
    iprot.readStructEnd()
25094 
 
25095 
  def write(self, oprot):
25096 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
25097 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
25098 
      return
25099 
    oprot.writeStructBegin('getReceivedAtStoreOrders_args')
25100 
    if self.storeId is not None:
25101 
      oprot.writeFieldBegin('storeId', TType.I64, 1)
25102 
      oprot.writeI64(self.storeId)
25103 
      oprot.writeFieldEnd()
25104 
    oprot.writeFieldStop()
25105 
    oprot.writeStructEnd()
25106 
 
25107 
  def validate(self):
25108 
    return
25109 
 
25110 
 
25111 
  def __repr__(self):
25112 
    L = ['%s=%r' % (key, value)
25113 
      for key, value in self.__dict__.iteritems()]
25114 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
25115 
 
25116 
  def __eq__(self, other):
25117 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
25118 
 
25119 
  def __ne__(self, other):
25120 
    return not (self == other)
25121 
 
25122 
class getReceivedAtStoreOrders_result:
25123 
  """
25124 
  Attributes:
25125 
   - success
25126 
  """
25127 
 
25128 
  thrift_spec = (
25129 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
25130 
  )
25131 
 
25132 
  def __init__(self, success=None,):
25133 
    self.success = success
25134 
 
25135 
  def read(self, iprot):
25136 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
25137 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
25138 
      return
25139 
    iprot.readStructBegin()
25140 
    while True:
25141 
      (fname, ftype, fid) = iprot.readFieldBegin()
25142 
      if ftype == TType.STOP:
25143 
        break
25144 
      if fid == 0:
25145 
        if ftype == TType.LIST:
25146 
          self.success = []
6000 mandeep.dh 25147 
          (_etype609, _size606) = iprot.readListBegin()
25148 
          for _i610 in xrange(_size606):
25149 
            _elem611 = Order()
25150 
            _elem611.read(iprot)
25151 
            self.success.append(_elem611)
5553 rajveer 25152 
          iprot.readListEnd()
25153 
        else:
25154 
          iprot.skip(ftype)
25155 
      else:
25156 
        iprot.skip(ftype)
25157 
      iprot.readFieldEnd()
25158 
    iprot.readStructEnd()
25159 
 
25160 
  def write(self, oprot):
25161 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
25162 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
25163 
      return
25164 
    oprot.writeStructBegin('getReceivedAtStoreOrders_result')
25165 
    if self.success is not None:
25166 
      oprot.writeFieldBegin('success', TType.LIST, 0)
25167 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
6000 mandeep.dh 25168 
      for iter612 in self.success:
25169 
        iter612.write(oprot)
5553 rajveer 25170 
      oprot.writeListEnd()
25171 
      oprot.writeFieldEnd()
25172 
    oprot.writeFieldStop()
25173 
    oprot.writeStructEnd()
25174 
 
25175 
  def validate(self):
25176 
    return
25177 
 
25178 
 
25179 
  def __repr__(self):
25180 
    L = ['%s=%r' % (key, value)
25181 
      for key, value in self.__dict__.iteritems()]
25182 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
25183 
 
25184 
  def __eq__(self, other):
25185 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
25186 
 
25187 
  def __ne__(self, other):
25188 
    return not (self == other)
5593 mandeep.dh 25189 
 
5713 rajveer 25190 
class getOrdersCollectionAtStore_args:
25191 
  """
25192 
  Attributes:
25193 
   - storeId
25194 
   - fromDate
25195 
   - toDate
25196 
   - onlyCod
25197 
  """
25198 
 
25199 
  thrift_spec = (
25200 
    None, # 0
25201 
    (1, TType.I64, 'storeId', None, None, ), # 1
25202 
    (2, TType.I64, 'fromDate', None, None, ), # 2
25203 
    (3, TType.I64, 'toDate', None, None, ), # 3
25204 
    (4, TType.BOOL, 'onlyCod', None, None, ), # 4
25205 
  )
25206 
 
25207 
  def __init__(self, storeId=None, fromDate=None, toDate=None, onlyCod=None,):
25208 
    self.storeId = storeId
25209 
    self.fromDate = fromDate
25210 
    self.toDate = toDate
25211 
    self.onlyCod = onlyCod
25212 
 
25213 
  def read(self, iprot):
25214 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
25215 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
25216 
      return
25217 
    iprot.readStructBegin()
25218 
    while True:
25219 
      (fname, ftype, fid) = iprot.readFieldBegin()
25220 
      if ftype == TType.STOP:
25221 
        break
25222 
      if fid == 1:
25223 
        if ftype == TType.I64:
25224 
          self.storeId = iprot.readI64();
25225 
        else:
25226 
          iprot.skip(ftype)
25227 
      elif fid == 2:
25228 
        if ftype == TType.I64:
25229 
          self.fromDate = iprot.readI64();
25230 
        else:
25231 
          iprot.skip(ftype)
25232 
      elif fid == 3:
25233 
        if ftype == TType.I64:
25234 
          self.toDate = iprot.readI64();
25235 
        else:
25236 
          iprot.skip(ftype)
25237 
      elif fid == 4:
25238 
        if ftype == TType.BOOL:
25239 
          self.onlyCod = iprot.readBool();
25240 
        else:
25241 
          iprot.skip(ftype)
25242 
      else:
25243 
        iprot.skip(ftype)
25244 
      iprot.readFieldEnd()
25245 
    iprot.readStructEnd()
25246 
 
25247 
  def write(self, oprot):
25248 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
25249 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
25250 
      return
25251 
    oprot.writeStructBegin('getOrdersCollectionAtStore_args')
25252 
    if self.storeId is not None:
25253 
      oprot.writeFieldBegin('storeId', TType.I64, 1)
25254 
      oprot.writeI64(self.storeId)
25255 
      oprot.writeFieldEnd()
25256 
    if self.fromDate is not None:
25257 
      oprot.writeFieldBegin('fromDate', TType.I64, 2)
25258 
      oprot.writeI64(self.fromDate)
25259 
      oprot.writeFieldEnd()
25260 
    if self.toDate is not None:
25261 
      oprot.writeFieldBegin('toDate', TType.I64, 3)
25262 
      oprot.writeI64(self.toDate)
25263 
      oprot.writeFieldEnd()
25264 
    if self.onlyCod is not None:
25265 
      oprot.writeFieldBegin('onlyCod', TType.BOOL, 4)
25266 
      oprot.writeBool(self.onlyCod)
25267 
      oprot.writeFieldEnd()
25268 
    oprot.writeFieldStop()
25269 
    oprot.writeStructEnd()
25270 
 
25271 
  def validate(self):
25272 
    return
25273 
 
25274 
 
25275 
  def __repr__(self):
25276 
    L = ['%s=%r' % (key, value)
25277 
      for key, value in self.__dict__.iteritems()]
25278 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
25279 
 
25280 
  def __eq__(self, other):
25281 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
25282 
 
25283 
  def __ne__(self, other):
25284 
    return not (self == other)
25285 
 
25286 
class getOrdersCollectionAtStore_result:
25287 
  """
25288 
  Attributes:
25289 
   - success
25290 
  """
25291 
 
25292 
  thrift_spec = (
25293 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
25294 
  )
25295 
 
25296 
  def __init__(self, success=None,):
25297 
    self.success = success
25298 
 
25299 
  def read(self, iprot):
25300 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
25301 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
25302 
      return
25303 
    iprot.readStructBegin()
25304 
    while True:
25305 
      (fname, ftype, fid) = iprot.readFieldBegin()
25306 
      if ftype == TType.STOP:
25307 
        break
25308 
      if fid == 0:
25309 
        if ftype == TType.LIST:
25310 
          self.success = []
6000 mandeep.dh 25311 
          (_etype616, _size613) = iprot.readListBegin()
25312 
          for _i617 in xrange(_size613):
25313 
            _elem618 = Order()
25314 
            _elem618.read(iprot)
25315 
            self.success.append(_elem618)
5713 rajveer 25316 
          iprot.readListEnd()
25317 
        else:
25318 
          iprot.skip(ftype)
25319 
      else:
25320 
        iprot.skip(ftype)
25321 
      iprot.readFieldEnd()
25322 
    iprot.readStructEnd()
25323 
 
25324 
  def write(self, oprot):
25325 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
25326 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
25327 
      return
25328 
    oprot.writeStructBegin('getOrdersCollectionAtStore_result')
25329 
    if self.success is not None:
25330 
      oprot.writeFieldBegin('success', TType.LIST, 0)
25331 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
6000 mandeep.dh 25332 
      for iter619 in self.success:
25333 
        iter619.write(oprot)
5713 rajveer 25334 
      oprot.writeListEnd()
25335 
      oprot.writeFieldEnd()
25336 
    oprot.writeFieldStop()
25337 
    oprot.writeStructEnd()
25338 
 
25339 
  def validate(self):
25340 
    return
25341 
 
25342 
 
25343 
  def __repr__(self):
25344 
    L = ['%s=%r' % (key, value)
25345 
      for key, value in self.__dict__.iteritems()]
25346 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
25347 
 
25348 
  def __eq__(self, other):
25349 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
25350 
 
25351 
  def __ne__(self, other):
25352 
    return not (self == other)
25353 
 
5833 rajveer 25354 
class getOrderAttributeValue_args:
25355 
  """
25356 
  Attributes:
25357 
   - orderId
25358 
   - attributeName
25359 
  """
25360 
 
25361 
  thrift_spec = None
25362 
  def __init__(self, orderId=None, attributeName=None,):
25363 
    self.orderId = orderId
25364 
    self.attributeName = attributeName
25365 
 
25366 
  def read(self, iprot):
25367 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
25368 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
25369 
      return
25370 
    iprot.readStructBegin()
25371 
    while True:
25372 
      (fname, ftype, fid) = iprot.readFieldBegin()
25373 
      if ftype == TType.STOP:
25374 
        break
25375 
      if fid == 1:
25376 
        if ftype == TType.I64:
25377 
          self.orderId = iprot.readI64();
25378 
        else:
25379 
          iprot.skip(ftype)
25380 
      elif fid == -1:
25381 
        if ftype == TType.STRING:
25382 
          self.attributeName = iprot.readString();
25383 
        else:
25384 
          iprot.skip(ftype)
25385 
      else:
25386 
        iprot.skip(ftype)
25387 
      iprot.readFieldEnd()
25388 
    iprot.readStructEnd()
25389 
 
25390 
  def write(self, oprot):
25391 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
25392 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
25393 
      return
25394 
    oprot.writeStructBegin('getOrderAttributeValue_args')
25395 
    if self.attributeName is not None:
25396 
      oprot.writeFieldBegin('attributeName', TType.STRING, -1)
25397 
      oprot.writeString(self.attributeName)
25398 
      oprot.writeFieldEnd()
25399 
    if self.orderId is not None:
25400 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
25401 
      oprot.writeI64(self.orderId)
25402 
      oprot.writeFieldEnd()
25403 
    oprot.writeFieldStop()
25404 
    oprot.writeStructEnd()
25405 
 
25406 
  def validate(self):
25407 
    return
25408 
 
25409 
 
25410 
  def __repr__(self):
25411 
    L = ['%s=%r' % (key, value)
25412 
      for key, value in self.__dict__.iteritems()]
25413 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
25414 
 
25415 
  def __eq__(self, other):
25416 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
25417 
 
25418 
  def __ne__(self, other):
25419 
    return not (self == other)
25420 
 
25421 
class getOrderAttributeValue_result:
25422 
  """
25423 
  Attributes:
25424 
   - success
25425 
  """
25426 
 
25427 
  thrift_spec = (
25428 
    (0, TType.STRING, 'success', None, None, ), # 0
25429 
  )
25430 
 
25431 
  def __init__(self, success=None,):
25432 
    self.success = success
25433 
 
25434 
  def read(self, iprot):
25435 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
25436 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
25437 
      return
25438 
    iprot.readStructBegin()
25439 
    while True:
25440 
      (fname, ftype, fid) = iprot.readFieldBegin()
25441 
      if ftype == TType.STOP:
25442 
        break
25443 
      if fid == 0:
25444 
        if ftype == TType.STRING:
25445 
          self.success = iprot.readString();
25446 
        else:
25447 
          iprot.skip(ftype)
25448 
      else:
25449 
        iprot.skip(ftype)
25450 
      iprot.readFieldEnd()
25451 
    iprot.readStructEnd()
25452 
 
25453 
  def write(self, oprot):
25454 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
25455 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
25456 
      return
25457 
    oprot.writeStructBegin('getOrderAttributeValue_result')
25458 
    if self.success is not None:
25459 
      oprot.writeFieldBegin('success', TType.STRING, 0)
25460 
      oprot.writeString(self.success)
25461 
      oprot.writeFieldEnd()
25462 
    oprot.writeFieldStop()
25463 
    oprot.writeStructEnd()
25464 
 
25465 
  def validate(self):
25466 
    return
25467 
 
25468 
 
25469 
  def __repr__(self):
25470 
    L = ['%s=%r' % (key, value)
25471 
      for key, value in self.__dict__.iteritems()]
25472 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
25473 
 
25474 
  def __eq__(self, other):
25475 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
25476 
 
25477 
  def __ne__(self, other):
25478 
    return not (self == other)
25479 
 
6019 rajveer 25480 
class changeJacketNumber_args:
25481 
  """
25482 
  Attributes:
25483 
   - orderId
25484 
   - jacketNumber
25485 
  """
25486 
 
25487 
  thrift_spec = (
25488 
    None, # 0
25489 
    (1, TType.I64, 'orderId', None, None, ), # 1
25490 
    (2, TType.I64, 'jacketNumber', None, None, ), # 2
25491 
  )
25492 
 
25493 
  def __init__(self, orderId=None, jacketNumber=None,):
25494 
    self.orderId = orderId
25495 
    self.jacketNumber = jacketNumber
25496 
 
25497 
  def read(self, iprot):
25498 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
25499 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
25500 
      return
25501 
    iprot.readStructBegin()
25502 
    while True:
25503 
      (fname, ftype, fid) = iprot.readFieldBegin()
25504 
      if ftype == TType.STOP:
25505 
        break
25506 
      if fid == 1:
25507 
        if ftype == TType.I64:
25508 
          self.orderId = iprot.readI64();
25509 
        else:
25510 
          iprot.skip(ftype)
25511 
      elif fid == 2:
25512 
        if ftype == TType.I64:
25513 
          self.jacketNumber = iprot.readI64();
25514 
        else:
25515 
          iprot.skip(ftype)
25516 
      else:
25517 
        iprot.skip(ftype)
25518 
      iprot.readFieldEnd()
25519 
    iprot.readStructEnd()
25520 
 
25521 
  def write(self, oprot):
25522 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
25523 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
25524 
      return
25525 
    oprot.writeStructBegin('changeJacketNumber_args')
25526 
    if self.orderId is not None:
25527 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
25528 
      oprot.writeI64(self.orderId)
25529 
      oprot.writeFieldEnd()
25530 
    if self.jacketNumber is not None:
25531 
      oprot.writeFieldBegin('jacketNumber', TType.I64, 2)
25532 
      oprot.writeI64(self.jacketNumber)
25533 
      oprot.writeFieldEnd()
25534 
    oprot.writeFieldStop()
25535 
    oprot.writeStructEnd()
25536 
 
25537 
  def validate(self):
25538 
    return
25539 
 
25540 
 
25541 
  def __repr__(self):
25542 
    L = ['%s=%r' % (key, value)
25543 
      for key, value in self.__dict__.iteritems()]
25544 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
25545 
 
25546 
  def __eq__(self, other):
25547 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
25548 
 
25549 
  def __ne__(self, other):
25550 
    return not (self == other)
25551 
 
25552 
class changeJacketNumber_result:
25553 
  """
25554 
  Attributes:
25555 
   - success
25556 
  """
25557 
 
25558 
  thrift_spec = (
25559 
    (0, TType.BOOL, 'success', None, None, ), # 0
25560 
  )
25561 
 
25562 
  def __init__(self, success=None,):
25563 
    self.success = success
25564 
 
25565 
  def read(self, iprot):
25566 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
25567 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
25568 
      return
25569 
    iprot.readStructBegin()
25570 
    while True:
25571 
      (fname, ftype, fid) = iprot.readFieldBegin()
25572 
      if ftype == TType.STOP:
25573 
        break
25574 
      if fid == 0:
25575 
        if ftype == TType.BOOL:
25576 
          self.success = iprot.readBool();
25577 
        else:
25578 
          iprot.skip(ftype)
25579 
      else:
25580 
        iprot.skip(ftype)
25581 
      iprot.readFieldEnd()
25582 
    iprot.readStructEnd()
25583 
 
25584 
  def write(self, oprot):
25585 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
25586 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
25587 
      return
25588 
    oprot.writeStructBegin('changeJacketNumber_result')
25589 
    if self.success is not None:
25590 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
25591 
      oprot.writeBool(self.success)
25592 
      oprot.writeFieldEnd()
25593 
    oprot.writeFieldStop()
25594 
    oprot.writeStructEnd()
25595 
 
25596 
  def validate(self):
25597 
    return
25598 
 
25599 
 
25600 
  def __repr__(self):
25601 
    L = ['%s=%r' % (key, value)
25602 
      for key, value in self.__dict__.iteritems()]
25603 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
25604 
 
25605 
  def __eq__(self, other):
25606 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
25607 
 
25608 
  def __ne__(self, other):
25609 
    return not (self == other)
25610 
 
25611 
class markOrderAsRtoInTransit_args:
25612 
  """
25613 
  Attributes:
25614 
   - orderId
25615 
  """
25616 
 
25617 
  thrift_spec = (
25618 
    None, # 0
25619 
    (1, TType.I64, 'orderId', None, None, ), # 1
25620 
  )
25621 
 
25622 
  def __init__(self, orderId=None,):
25623 
    self.orderId = orderId
25624 
 
25625 
  def read(self, iprot):
25626 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
25627 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
25628 
      return
25629 
    iprot.readStructBegin()
25630 
    while True:
25631 
      (fname, ftype, fid) = iprot.readFieldBegin()
25632 
      if ftype == TType.STOP:
25633 
        break
25634 
      if fid == 1:
25635 
        if ftype == TType.I64:
25636 
          self.orderId = iprot.readI64();
25637 
        else:
25638 
          iprot.skip(ftype)
25639 
      else:
25640 
        iprot.skip(ftype)
25641 
      iprot.readFieldEnd()
25642 
    iprot.readStructEnd()
25643 
 
25644 
  def write(self, oprot):
25645 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
25646 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
25647 
      return
25648 
    oprot.writeStructBegin('markOrderAsRtoInTransit_args')
25649 
    if self.orderId is not None:
25650 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
25651 
      oprot.writeI64(self.orderId)
25652 
      oprot.writeFieldEnd()
25653 
    oprot.writeFieldStop()
25654 
    oprot.writeStructEnd()
25655 
 
25656 
  def validate(self):
25657 
    return
25658 
 
25659 
 
25660 
  def __repr__(self):
25661 
    L = ['%s=%r' % (key, value)
25662 
      for key, value in self.__dict__.iteritems()]
25663 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
25664 
 
25665 
  def __eq__(self, other):
25666 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
25667 
 
25668 
  def __ne__(self, other):
25669 
    return not (self == other)
25670 
 
25671 
class markOrderAsRtoInTransit_result:
25672 
  """
25673 
  Attributes:
25674 
   - success
25675 
  """
25676 
 
25677 
  thrift_spec = (
25678 
    (0, TType.BOOL, 'success', None, None, ), # 0
25679 
  )
25680 
 
25681 
  def __init__(self, success=None,):
25682 
    self.success = success
25683 
 
25684 
  def read(self, iprot):
25685 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
25686 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
25687 
      return
25688 
    iprot.readStructBegin()
25689 
    while True:
25690 
      (fname, ftype, fid) = iprot.readFieldBegin()
25691 
      if ftype == TType.STOP:
25692 
        break
25693 
      if fid == 0:
25694 
        if ftype == TType.BOOL:
25695 
          self.success = iprot.readBool();
25696 
        else:
25697 
          iprot.skip(ftype)
25698 
      else:
25699 
        iprot.skip(ftype)
25700 
      iprot.readFieldEnd()
25701 
    iprot.readStructEnd()
25702 
 
25703 
  def write(self, oprot):
25704 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
25705 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
25706 
      return
25707 
    oprot.writeStructBegin('markOrderAsRtoInTransit_result')
25708 
    if self.success is not None:
25709 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
25710 
      oprot.writeBool(self.success)
25711 
      oprot.writeFieldEnd()
25712 
    oprot.writeFieldStop()
25713 
    oprot.writeStructEnd()
25714 
 
25715 
  def validate(self):
25716 
    return
25717 
 
25718 
 
25719 
  def __repr__(self):
25720 
    L = ['%s=%r' % (key, value)
25721 
      for key, value in self.__dict__.iteritems()]
25722 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
25723 
 
25724 
  def __eq__(self, other):
25725 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
25726 
 
25727 
  def __ne__(self, other):
25728 
    return not (self == other)
25729 
 
5593 mandeep.dh 25730 
class acceptOrderForItem_args:
25731 
  """
25732 
  Attributes:
25733 
   - itemId
25734 
   - quantity
25735 
   - fulfilmentWarehouseId
25736 
   - billingWarehouseId
25737 
  """
25738 
 
25739 
  thrift_spec = (
25740 
    None, # 0
25741 
    (1, TType.I64, 'itemId', None, None, ), # 1
25742 
    (2, TType.I64, 'quantity', None, None, ), # 2
25743 
    (3, TType.I64, 'fulfilmentWarehouseId', None, None, ), # 3
25744 
    (4, TType.I64, 'billingWarehouseId', None, None, ), # 4
25745 
  )
25746 
 
25747 
  def __init__(self, itemId=None, quantity=None, fulfilmentWarehouseId=None, billingWarehouseId=None,):
25748 
    self.itemId = itemId
25749 
    self.quantity = quantity
25750 
    self.fulfilmentWarehouseId = fulfilmentWarehouseId
25751 
    self.billingWarehouseId = billingWarehouseId
25752 
 
25753 
  def read(self, iprot):
25754 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
25755 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
25756 
      return
25757 
    iprot.readStructBegin()
25758 
    while True:
25759 
      (fname, ftype, fid) = iprot.readFieldBegin()
25760 
      if ftype == TType.STOP:
25761 
        break
25762 
      if fid == 1:
25763 
        if ftype == TType.I64:
25764 
          self.itemId = iprot.readI64();
25765 
        else:
25766 
          iprot.skip(ftype)
25767 
      elif fid == 2:
25768 
        if ftype == TType.I64:
25769 
          self.quantity = iprot.readI64();
25770 
        else:
25771 
          iprot.skip(ftype)
25772 
      elif fid == 3:
25773 
        if ftype == TType.I64:
25774 
          self.fulfilmentWarehouseId = iprot.readI64();
25775 
        else:
25776 
          iprot.skip(ftype)
25777 
      elif fid == 4:
25778 
        if ftype == TType.I64:
25779 
          self.billingWarehouseId = iprot.readI64();
25780 
        else:
25781 
          iprot.skip(ftype)
25782 
      else:
25783 
        iprot.skip(ftype)
25784 
      iprot.readFieldEnd()
25785 
    iprot.readStructEnd()
25786 
 
25787 
  def write(self, oprot):
25788 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
25789 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
25790 
      return
25791 
    oprot.writeStructBegin('acceptOrderForItem_args')
25792 
    if self.itemId is not None:
25793 
      oprot.writeFieldBegin('itemId', TType.I64, 1)
25794 
      oprot.writeI64(self.itemId)
25795 
      oprot.writeFieldEnd()
25796 
    if self.quantity is not None:
25797 
      oprot.writeFieldBegin('quantity', TType.I64, 2)
25798 
      oprot.writeI64(self.quantity)
25799 
      oprot.writeFieldEnd()
25800 
    if self.fulfilmentWarehouseId is not None:
25801 
      oprot.writeFieldBegin('fulfilmentWarehouseId', TType.I64, 3)
25802 
      oprot.writeI64(self.fulfilmentWarehouseId)
25803 
      oprot.writeFieldEnd()
25804 
    if self.billingWarehouseId is not None:
25805 
      oprot.writeFieldBegin('billingWarehouseId', TType.I64, 4)
25806 
      oprot.writeI64(self.billingWarehouseId)
25807 
      oprot.writeFieldEnd()
25808 
    oprot.writeFieldStop()
25809 
    oprot.writeStructEnd()
25810 
 
25811 
  def validate(self):
25812 
    return
25813 
 
25814 
 
25815 
  def __repr__(self):
25816 
    L = ['%s=%r' % (key, value)
25817 
      for key, value in self.__dict__.iteritems()]
25818 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
25819 
 
25820 
  def __eq__(self, other):
25821 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
25822 
 
25823 
  def __ne__(self, other):
25824 
    return not (self == other)
25825 
 
25826 
class acceptOrderForItem_result:
25827 
 
25828 
  thrift_spec = (
25829 
  )
25830 
 
25831 
  def read(self, iprot):
25832 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
25833 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
25834 
      return
25835 
    iprot.readStructBegin()
25836 
    while True:
25837 
      (fname, ftype, fid) = iprot.readFieldBegin()
25838 
      if ftype == TType.STOP:
25839 
        break
25840 
      else:
25841 
        iprot.skip(ftype)
25842 
      iprot.readFieldEnd()
25843 
    iprot.readStructEnd()
25844 
 
25845 
  def write(self, oprot):
25846 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
25847 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
25848 
      return
25849 
    oprot.writeStructBegin('acceptOrderForItem_result')
25850 
    oprot.writeFieldStop()
25851 
    oprot.writeStructEnd()
25852 
 
25853 
  def validate(self):
25854 
    return
25855 
 
25856 
 
25857 
  def __repr__(self):
25858 
    L = ['%s=%r' % (key, value)
25859 
      for key, value in self.__dict__.iteritems()]
25860 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
25861 
 
25862 
  def __eq__(self, other):
25863 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
25864 
 
25865 
  def __ne__(self, other):
25866 
    return not (self == other)
6000 mandeep.dh 25867 
 
25868 
class createRechargeOrder_args:
25869 
  """
25870 
  Attributes:
25871 
   - rechargeOrder
25872 
  """
25873 
 
25874 
  thrift_spec = (
25875 
    None, # 0
25876 
    (1, TType.STRUCT, 'rechargeOrder', (RechargeOrder, RechargeOrder.thrift_spec), None, ), # 1
25877 
  )
25878 
 
25879 
  def __init__(self, rechargeOrder=None,):
25880 
    self.rechargeOrder = rechargeOrder
25881 
 
25882 
  def read(self, iprot):
25883 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
25884 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
25885 
      return
25886 
    iprot.readStructBegin()
25887 
    while True:
25888 
      (fname, ftype, fid) = iprot.readFieldBegin()
25889 
      if ftype == TType.STOP:
25890 
        break
25891 
      if fid == 1:
25892 
        if ftype == TType.STRUCT:
25893 
          self.rechargeOrder = RechargeOrder()
25894 
          self.rechargeOrder.read(iprot)
25895 
        else:
25896 
          iprot.skip(ftype)
25897 
      else:
25898 
        iprot.skip(ftype)
25899 
      iprot.readFieldEnd()
25900 
    iprot.readStructEnd()
25901 
 
25902 
  def write(self, oprot):
25903 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
25904 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
25905 
      return
25906 
    oprot.writeStructBegin('createRechargeOrder_args')
25907 
    if self.rechargeOrder is not None:
25908 
      oprot.writeFieldBegin('rechargeOrder', TType.STRUCT, 1)
25909 
      self.rechargeOrder.write(oprot)
25910 
      oprot.writeFieldEnd()
25911 
    oprot.writeFieldStop()
25912 
    oprot.writeStructEnd()
25913 
 
25914 
  def validate(self):
25915 
    return
25916 
 
25917 
 
25918 
  def __repr__(self):
25919 
    L = ['%s=%r' % (key, value)
25920 
      for key, value in self.__dict__.iteritems()]
25921 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
25922 
 
25923 
  def __eq__(self, other):
25924 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
25925 
 
25926 
  def __ne__(self, other):
25927 
    return not (self == other)
25928 
 
25929 
class createRechargeOrder_result:
25930 
  """
25931 
  Attributes:
25932 
   - success
25933 
   - ex
25934 
  """
25935 
 
25936 
  thrift_spec = (
25937 
    (0, TType.STRUCT, 'success', (RechargeOrder, RechargeOrder.thrift_spec), None, ), # 0
25938 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
25939 
  )
25940 
 
25941 
  def __init__(self, success=None, ex=None,):
25942 
    self.success = success
25943 
    self.ex = ex
25944 
 
25945 
  def read(self, iprot):
25946 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
25947 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
25948 
      return
25949 
    iprot.readStructBegin()
25950 
    while True:
25951 
      (fname, ftype, fid) = iprot.readFieldBegin()
25952 
      if ftype == TType.STOP:
25953 
        break
25954 
      if fid == 0:
25955 
        if ftype == TType.STRUCT:
25956 
          self.success = RechargeOrder()
25957 
          self.success.read(iprot)
25958 
        else:
25959 
          iprot.skip(ftype)
25960 
      elif fid == 1:
25961 
        if ftype == TType.STRUCT:
25962 
          self.ex = TransactionServiceException()
25963 
          self.ex.read(iprot)
25964 
        else:
25965 
          iprot.skip(ftype)
25966 
      else:
25967 
        iprot.skip(ftype)
25968 
      iprot.readFieldEnd()
25969 
    iprot.readStructEnd()
25970 
 
25971 
  def write(self, oprot):
25972 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
25973 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
25974 
      return
25975 
    oprot.writeStructBegin('createRechargeOrder_result')
25976 
    if self.success is not None:
25977 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
25978 
      self.success.write(oprot)
25979 
      oprot.writeFieldEnd()
25980 
    if self.ex is not None:
25981 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
25982 
      self.ex.write(oprot)
25983 
      oprot.writeFieldEnd()
25984 
    oprot.writeFieldStop()
25985 
    oprot.writeStructEnd()
25986 
 
25987 
  def validate(self):
25988 
    return
25989 
 
25990 
 
25991 
  def __repr__(self):
25992 
    L = ['%s=%r' % (key, value)
25993 
      for key, value in self.__dict__.iteritems()]
25994 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
25995 
 
25996 
  def __eq__(self, other):
25997 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
25998 
 
25999 
  def __ne__(self, other):
26000 
    return not (self == other)
26001 
 
26002 
class updateRechargeOrderStatus_args:
26003 
  """
26004 
  Attributes:
26005 
   - rechargeOrderId
26006 
   - rechargeOrderStatus
26007 
  """
26008 
 
26009 
  thrift_spec = (
26010 
    None, # 0
26011 
    (1, TType.I64, 'rechargeOrderId', None, None, ), # 1
26012 
    (2, TType.I32, 'rechargeOrderStatus', None, None, ), # 2
26013 
  )
26014 
 
26015 
  def __init__(self, rechargeOrderId=None, rechargeOrderStatus=None,):
26016 
    self.rechargeOrderId = rechargeOrderId
26017 
    self.rechargeOrderStatus = rechargeOrderStatus
26018 
 
26019 
  def read(self, iprot):
26020 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
26021 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
26022 
      return
26023 
    iprot.readStructBegin()
26024 
    while True:
26025 
      (fname, ftype, fid) = iprot.readFieldBegin()
26026 
      if ftype == TType.STOP:
26027 
        break
26028 
      if fid == 1:
26029 
        if ftype == TType.I64:
26030 
          self.rechargeOrderId = iprot.readI64();
26031 
        else:
26032 
          iprot.skip(ftype)
26033 
      elif fid == 2:
26034 
        if ftype == TType.I32:
26035 
          self.rechargeOrderStatus = iprot.readI32();
26036 
        else:
26037 
          iprot.skip(ftype)
26038 
      else:
26039 
        iprot.skip(ftype)
26040 
      iprot.readFieldEnd()
26041 
    iprot.readStructEnd()
26042 
 
26043 
  def write(self, oprot):
26044 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
26045 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
26046 
      return
26047 
    oprot.writeStructBegin('updateRechargeOrderStatus_args')
26048 
    if self.rechargeOrderId is not None:
26049 
      oprot.writeFieldBegin('rechargeOrderId', TType.I64, 1)
26050 
      oprot.writeI64(self.rechargeOrderId)
26051 
      oprot.writeFieldEnd()
26052 
    if self.rechargeOrderStatus is not None:
26053 
      oprot.writeFieldBegin('rechargeOrderStatus', TType.I32, 2)
26054 
      oprot.writeI32(self.rechargeOrderStatus)
26055 
      oprot.writeFieldEnd()
26056 
    oprot.writeFieldStop()
26057 
    oprot.writeStructEnd()
26058 
 
26059 
  def validate(self):
26060 
    return
26061 
 
26062 
 
26063 
  def __repr__(self):
26064 
    L = ['%s=%r' % (key, value)
26065 
      for key, value in self.__dict__.iteritems()]
26066 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
26067 
 
26068 
  def __eq__(self, other):
26069 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
26070 
 
26071 
  def __ne__(self, other):
26072 
    return not (self == other)
26073 
 
26074 
class updateRechargeOrderStatus_result:
26075 
  """
26076 
  Attributes:
26077 
   - ex
26078 
  """
26079 
 
26080 
  thrift_spec = (
26081 
    None, # 0
26082 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
26083 
  )
26084 
 
26085 
  def __init__(self, ex=None,):
26086 
    self.ex = ex
26087 
 
26088 
  def read(self, iprot):
26089 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
26090 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
26091 
      return
26092 
    iprot.readStructBegin()
26093 
    while True:
26094 
      (fname, ftype, fid) = iprot.readFieldBegin()
26095 
      if ftype == TType.STOP:
26096 
        break
26097 
      if fid == 1:
26098 
        if ftype == TType.STRUCT:
26099 
          self.ex = TransactionServiceException()
26100 
          self.ex.read(iprot)
26101 
        else:
26102 
          iprot.skip(ftype)
26103 
      else:
26104 
        iprot.skip(ftype)
26105 
      iprot.readFieldEnd()
26106 
    iprot.readStructEnd()
26107 
 
26108 
  def write(self, oprot):
26109 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
26110 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
26111 
      return
26112 
    oprot.writeStructBegin('updateRechargeOrderStatus_result')
26113 
    if self.ex is not None:
26114 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
26115 
      self.ex.write(oprot)
26116 
      oprot.writeFieldEnd()
26117 
    oprot.writeFieldStop()
26118 
    oprot.writeStructEnd()
26119 
 
26120 
  def validate(self):
26121 
    return
26122 
 
26123 
 
26124 
  def __repr__(self):
26125 
    L = ['%s=%r' % (key, value)
26126 
      for key, value in self.__dict__.iteritems()]
26127 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
26128 
 
26129 
  def __eq__(self, other):
26130 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
26131 
 
26132 
  def __ne__(self, other):
26133 
    return not (self == other)
26134 
 
26135 
class activateRechargeTxn_args:
26136 
  """
26137 
  Attributes:
26138 
   - rechargeCoupons
26139 
  """
26140 
 
26141 
  thrift_spec = (
26142 
    None, # 0
26143 
    (1, TType.LIST, 'rechargeCoupons', (TType.STRUCT,(RechargeCoupon, RechargeCoupon.thrift_spec)), None, ), # 1
26144 
  )
26145 
 
26146 
  def __init__(self, rechargeCoupons=None,):
26147 
    self.rechargeCoupons = rechargeCoupons
26148 
 
26149 
  def read(self, iprot):
26150 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
26151 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
26152 
      return
26153 
    iprot.readStructBegin()
26154 
    while True:
26155 
      (fname, ftype, fid) = iprot.readFieldBegin()
26156 
      if ftype == TType.STOP:
26157 
        break
26158 
      if fid == 1:
26159 
        if ftype == TType.LIST:
26160 
          self.rechargeCoupons = []
26161 
          (_etype623, _size620) = iprot.readListBegin()
26162 
          for _i624 in xrange(_size620):
26163 
            _elem625 = RechargeCoupon()
26164 
            _elem625.read(iprot)
26165 
            self.rechargeCoupons.append(_elem625)
26166 
          iprot.readListEnd()
26167 
        else:
26168 
          iprot.skip(ftype)
26169 
      else:
26170 
        iprot.skip(ftype)
26171 
      iprot.readFieldEnd()
26172 
    iprot.readStructEnd()
26173 
 
26174 
  def write(self, oprot):
26175 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
26176 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
26177 
      return
26178 
    oprot.writeStructBegin('activateRechargeTxn_args')
26179 
    if self.rechargeCoupons is not None:
26180 
      oprot.writeFieldBegin('rechargeCoupons', TType.LIST, 1)
26181 
      oprot.writeListBegin(TType.STRUCT, len(self.rechargeCoupons))
26182 
      for iter626 in self.rechargeCoupons:
26183 
        iter626.write(oprot)
26184 
      oprot.writeListEnd()
26185 
      oprot.writeFieldEnd()
26186 
    oprot.writeFieldStop()
26187 
    oprot.writeStructEnd()
26188 
 
26189 
  def validate(self):
26190 
    return
26191 
 
26192 
 
26193 
  def __repr__(self):
26194 
    L = ['%s=%r' % (key, value)
26195 
      for key, value in self.__dict__.iteritems()]
26196 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
26197 
 
26198 
  def __eq__(self, other):
26199 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
26200 
 
26201 
  def __ne__(self, other):
26202 
    return not (self == other)
26203 
 
26204 
class activateRechargeTxn_result:
26205 
  """
26206 
  Attributes:
26207 
   - success
26208 
   - ex
26209 
  """
26210 
 
26211 
  thrift_spec = (
26212 
    (0, TType.STRUCT, 'success', (RechargeResponse, RechargeResponse.thrift_spec), None, ), # 0
26213 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
26214 
  )
26215 
 
26216 
  def __init__(self, success=None, ex=None,):
26217 
    self.success = success
26218 
    self.ex = ex
26219 
 
26220 
  def read(self, iprot):
26221 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
26222 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
26223 
      return
26224 
    iprot.readStructBegin()
26225 
    while True:
26226 
      (fname, ftype, fid) = iprot.readFieldBegin()
26227 
      if ftype == TType.STOP:
26228 
        break
26229 
      if fid == 0:
26230 
        if ftype == TType.STRUCT:
26231 
          self.success = RechargeResponse()
26232 
          self.success.read(iprot)
26233 
        else:
26234 
          iprot.skip(ftype)
26235 
      elif fid == 1:
26236 
        if ftype == TType.STRUCT:
26237 
          self.ex = TransactionServiceException()
26238 
          self.ex.read(iprot)
26239 
        else:
26240 
          iprot.skip(ftype)
26241 
      else:
26242 
        iprot.skip(ftype)
26243 
      iprot.readFieldEnd()
26244 
    iprot.readStructEnd()
26245 
 
26246 
  def write(self, oprot):
26247 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
26248 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
26249 
      return
26250 
    oprot.writeStructBegin('activateRechargeTxn_result')
26251 
    if self.success is not None:
26252 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
26253 
      self.success.write(oprot)
26254 
      oprot.writeFieldEnd()
26255 
    if self.ex is not None:
26256 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
26257 
      self.ex.write(oprot)
26258 
      oprot.writeFieldEnd()
26259 
    oprot.writeFieldStop()
26260 
    oprot.writeStructEnd()
26261 
 
26262 
  def validate(self):
26263 
    return
26264 
 
26265 
 
26266 
  def __repr__(self):
26267 
    L = ['%s=%r' % (key, value)
26268 
      for key, value in self.__dict__.iteritems()]
26269 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
26270 
 
26271 
  def __eq__(self, other):
26272 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
26273 
 
26274 
  def __ne__(self, other):
26275 
    return not (self == other)
26276 
 
26277 
class getRechargeOrders_args:
26278 
  """
26279 
  Attributes:
26280 
   - customerId
26281 
  """
26282 
 
26283 
  thrift_spec = (
26284 
    None, # 0
26285 
    (1, TType.I64, 'customerId', None, None, ), # 1
26286 
  )
26287 
 
26288 
  def __init__(self, customerId=None,):
26289 
    self.customerId = customerId
26290 
 
26291 
  def read(self, iprot):
26292 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
26293 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
26294 
      return
26295 
    iprot.readStructBegin()
26296 
    while True:
26297 
      (fname, ftype, fid) = iprot.readFieldBegin()
26298 
      if ftype == TType.STOP:
26299 
        break
26300 
      if fid == 1:
26301 
        if ftype == TType.I64:
26302 
          self.customerId = iprot.readI64();
26303 
        else:
26304 
          iprot.skip(ftype)
26305 
      else:
26306 
        iprot.skip(ftype)
26307 
      iprot.readFieldEnd()
26308 
    iprot.readStructEnd()
26309 
 
26310 
  def write(self, oprot):
26311 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
26312 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
26313 
      return
26314 
    oprot.writeStructBegin('getRechargeOrders_args')
26315 
    if self.customerId is not None:
26316 
      oprot.writeFieldBegin('customerId', TType.I64, 1)
26317 
      oprot.writeI64(self.customerId)
26318 
      oprot.writeFieldEnd()
26319 
    oprot.writeFieldStop()
26320 
    oprot.writeStructEnd()
26321 
 
26322 
  def validate(self):
26323 
    return
26324 
 
26325 
 
26326 
  def __repr__(self):
26327 
    L = ['%s=%r' % (key, value)
26328 
      for key, value in self.__dict__.iteritems()]
26329 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
26330 
 
26331 
  def __eq__(self, other):
26332 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
26333 
 
26334 
  def __ne__(self, other):
26335 
    return not (self == other)
26336 
 
26337 
class getRechargeOrders_result:
26338 
  """
26339 
  Attributes:
26340 
   - success
26341 
  """
26342 
 
26343 
  thrift_spec = (
26344 
    (0, TType.LIST, 'success', (TType.STRUCT,(RechargeOrder, RechargeOrder.thrift_spec)), None, ), # 0
26345 
  )
26346 
 
26347 
  def __init__(self, success=None,):
26348 
    self.success = success
26349 
 
26350 
  def read(self, iprot):
26351 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
26352 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
26353 
      return
26354 
    iprot.readStructBegin()
26355 
    while True:
26356 
      (fname, ftype, fid) = iprot.readFieldBegin()
26357 
      if ftype == TType.STOP:
26358 
        break
26359 
      if fid == 0:
26360 
        if ftype == TType.LIST:
26361 
          self.success = []
26362 
          (_etype630, _size627) = iprot.readListBegin()
26363 
          for _i631 in xrange(_size627):
26364 
            _elem632 = RechargeOrder()
26365 
            _elem632.read(iprot)
26366 
            self.success.append(_elem632)
26367 
          iprot.readListEnd()
26368 
        else:
26369 
          iprot.skip(ftype)
26370 
      else:
26371 
        iprot.skip(ftype)
26372 
      iprot.readFieldEnd()
26373 
    iprot.readStructEnd()
26374 
 
26375 
  def write(self, oprot):
26376 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
26377 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
26378 
      return
26379 
    oprot.writeStructBegin('getRechargeOrders_result')
26380 
    if self.success is not None:
26381 
      oprot.writeFieldBegin('success', TType.LIST, 0)
26382 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
26383 
      for iter633 in self.success:
26384 
        iter633.write(oprot)
26385 
      oprot.writeListEnd()
26386 
      oprot.writeFieldEnd()
26387 
    oprot.writeFieldStop()
26388 
    oprot.writeStructEnd()
26389 
 
26390 
  def validate(self):
26391 
    return
26392 
 
26393 
 
26394 
  def __repr__(self):
26395 
    L = ['%s=%r' % (key, value)
26396 
      for key, value in self.__dict__.iteritems()]
26397 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
26398 
 
26399 
  def __eq__(self, other):
26400 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
26401 
 
26402 
  def __ne__(self, other):
26403 
    return not (self == other)
26404 
 
26405 
class getRechargeCoupons_args:
26406 
  """
26407 
  Attributes:
26408 
   - customerId
26409 
   - rechargeCouponStatus
26410 
  """
26411 
 
26412 
  thrift_spec = (
26413 
    None, # 0
26414 
    (1, TType.I64, 'customerId', None, None, ), # 1
26415 
    (2, TType.I32, 'rechargeCouponStatus', None, None, ), # 2
26416 
  )
26417 
 
26418 
  def __init__(self, customerId=None, rechargeCouponStatus=None,):
26419 
    self.customerId = customerId
26420 
    self.rechargeCouponStatus = rechargeCouponStatus
26421 
 
26422 
  def read(self, iprot):
26423 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
26424 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
26425 
      return
26426 
    iprot.readStructBegin()
26427 
    while True:
26428 
      (fname, ftype, fid) = iprot.readFieldBegin()
26429 
      if ftype == TType.STOP:
26430 
        break
26431 
      if fid == 1:
26432 
        if ftype == TType.I64:
26433 
          self.customerId = iprot.readI64();
26434 
        else:
26435 
          iprot.skip(ftype)
26436 
      elif fid == 2:
26437 
        if ftype == TType.I32:
26438 
          self.rechargeCouponStatus = iprot.readI32();
26439 
        else:
26440 
          iprot.skip(ftype)
26441 
      else:
26442 
        iprot.skip(ftype)
26443 
      iprot.readFieldEnd()
26444 
    iprot.readStructEnd()
26445 
 
26446 
  def write(self, oprot):
26447 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
26448 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
26449 
      return
26450 
    oprot.writeStructBegin('getRechargeCoupons_args')
26451 
    if self.customerId is not None:
26452 
      oprot.writeFieldBegin('customerId', TType.I64, 1)
26453 
      oprot.writeI64(self.customerId)
26454 
      oprot.writeFieldEnd()
26455 
    if self.rechargeCouponStatus is not None:
26456 
      oprot.writeFieldBegin('rechargeCouponStatus', TType.I32, 2)
26457 
      oprot.writeI32(self.rechargeCouponStatus)
26458 
      oprot.writeFieldEnd()
26459 
    oprot.writeFieldStop()
26460 
    oprot.writeStructEnd()
26461 
 
26462 
  def validate(self):
26463 
    return
26464 
 
26465 
 
26466 
  def __repr__(self):
26467 
    L = ['%s=%r' % (key, value)
26468 
      for key, value in self.__dict__.iteritems()]
26469 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
26470 
 
26471 
  def __eq__(self, other):
26472 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
26473 
 
26474 
  def __ne__(self, other):
26475 
    return not (self == other)
26476 
 
26477 
class getRechargeCoupons_result:
26478 
  """
26479 
  Attributes:
26480 
   - success
26481 
  """
26482 
 
26483 
  thrift_spec = (
26484 
    (0, TType.LIST, 'success', (TType.STRUCT,(RechargeCoupon, RechargeCoupon.thrift_spec)), None, ), # 0
26485 
  )
26486 
 
26487 
  def __init__(self, success=None,):
26488 
    self.success = success
26489 
 
26490 
  def read(self, iprot):
26491 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
26492 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
26493 
      return
26494 
    iprot.readStructBegin()
26495 
    while True:
26496 
      (fname, ftype, fid) = iprot.readFieldBegin()
26497 
      if ftype == TType.STOP:
26498 
        break
26499 
      if fid == 0:
26500 
        if ftype == TType.LIST:
26501 
          self.success = []
26502 
          (_etype637, _size634) = iprot.readListBegin()
26503 
          for _i638 in xrange(_size634):
26504 
            _elem639 = RechargeCoupon()
26505 
            _elem639.read(iprot)
26506 
            self.success.append(_elem639)
26507 
          iprot.readListEnd()
26508 
        else:
26509 
          iprot.skip(ftype)
26510 
      else:
26511 
        iprot.skip(ftype)
26512 
      iprot.readFieldEnd()
26513 
    iprot.readStructEnd()
26514 
 
26515 
  def write(self, oprot):
26516 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
26517 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
26518 
      return
26519 
    oprot.writeStructBegin('getRechargeCoupons_result')
26520 
    if self.success is not None:
26521 
      oprot.writeFieldBegin('success', TType.LIST, 0)
26522 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
26523 
      for iter640 in self.success:
26524 
        iter640.write(oprot)
26525 
      oprot.writeListEnd()
26526 
      oprot.writeFieldEnd()
26527 
    oprot.writeFieldStop()
26528 
    oprot.writeStructEnd()
26529 
 
26530 
  def validate(self):
26531 
    return
26532 
 
26533 
 
26534 
  def __repr__(self):
26535 
    L = ['%s=%r' % (key, value)
26536 
      for key, value in self.__dict__.iteritems()]
26537 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
26538 
 
26539 
  def __eq__(self, other):
26540 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
26541 
 
26542 
  def __ne__(self, other):
26543 
    return not (self == other)