Subversion Repositories SmartDukaan

Rev

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

Rev Author Line No. Line
94 ashish 1 
#
3431 rajveer 2 
# Autogenerated by Thrift Compiler (0.7.0)
94 ashish 3 
#
4 
# DO NOT EDIT UNLESS YOU ARE SURE THAT YOU KNOW WHAT YOU ARE DOING
5 
#
6 
 
7 
from thrift.Thrift import *
3376 rajveer 8 
import shop2020.thriftpy.generic.GenericService
94 ashish 9 
from ttypes import *
10 
from thrift.Thrift import TProcessor
11 
from thrift.transport import TTransport
3431 rajveer 12 
from thrift.protocol import TBinaryProtocol, TProtocol
94 ashish 13 
try:
14 
  from thrift.protocol import fastbinary
15 
except:
16 
  fastbinary = None
17 
 
18 
 
3376 rajveer 19 
class Iface(shop2020.thriftpy.generic.GenericService.Iface):
94 ashish 20 
  def createTransaction(self, transaction):
21 
    """
22 
    Parameters:
23 
     - transaction
24 
    """
25 
    pass
26 
 
27 
  def getTransaction(self, id):
28 
    """
29 
    Parameters:
30 
     - id
31 
    """
32 
    pass
33 
 
34 
  def getTransactionsForCustomer(self, customerId, from_date, to_date, status):
35 
    """
36 
    Parameters:
37 
     - customerId
38 
     - from_date
39 
     - to_date
40 
     - status
41 
    """
42 
    pass
43 
 
132 ashish 44 
  def getTransactionsForShoppingCartId(self, shoppingCartId):
45 
    """
46 
    Parameters:
47 
     - shoppingCartId
48 
    """
49 
    pass
50 
 
94 ashish 51 
  def getTransactionStatus(self, transactionId):
52 
    """
53 
    Parameters:
54 
     - transactionId
55 
    """
56 
    pass
57 
 
5527 anupam.sin 58 
  def changeTransactionStatus(self, transactionId, status, description, pickUp, orderType):
94 ashish 59 
    """
60 
    Parameters:
61 
     - transactionId
62 
     - status
63 
     - description
5527 anupam.sin 64 
     - pickUp
65 
     - orderType
94 ashish 66 
    """
67 
    pass
68 
 
1398 varun.gupt 69 
  def enqueueTransactionInfoEmail(self, transactionId):
1382 varun.gupt 70 
    """
71 
    Parameters:
72 
     - transactionId
73 
    """
74 
    pass
75 
 
4801 anupam.sin 76 
  def getAllOrders(self, statuses, from_date, to_date, warehouse_id):
94 ashish 77 
    """
78 
    Parameters:
4801 anupam.sin 79 
     - statuses
483 rajveer 80 
     - from_date
81 
     - to_date
82 
     - warehouse_id
94 ashish 83 
    """
84 
    pass
85 
 
4133 chandransh 86 
  def getOrdersInBatch(self, statuses, offset, limit, warehouse_id):
87 
    """
88 
    Returns at most 'limit' orders with the given statuses for the given warehouse starting from the given offset.
89 
    Pass the status as null and the limit as 0 to ignore them.
90 
 
91 
    Parameters:
92 
     - statuses
93 
     - offset
94 
     - limit
95 
     - warehouse_id
96 
    """
97 
    pass
98 
 
99 
  def getOrderCount(self, statuses, warehouseId):
100 
    """
101 
    Returns the count of orders with the given statuses assigned to the given warehouse.
102 
 
103 
    Parameters:
104 
     - statuses
105 
     - warehouseId
106 
    """
107 
    pass
108 
 
999 varun.gupt 109 
  def getOrdersByBillingDate(self, status, start_billing_date, end_billing_date, warehouse_id):
110 
    """
1132 chandransh 111 
    Returns orders within a range of their billing dates
3431 rajveer 112 
 
999 varun.gupt 113 
    Parameters:
114 
     - status
115 
     - start_billing_date
116 
     - end_billing_date
117 
     - warehouse_id
118 
    """
119 
    pass
120 
 
3451 chandransh 121 
  def getOrdersByShippingDate(self, fromShippingDate, toShippingDate, providerId, warehouseId, cod):
3427 chandransh 122 
    """
123 
    Returns orders for a particular provider and warehouse which were shipped between the given dates.
3451 chandransh 124 
    Returned orders comprise of COD orders if cod parameter is true. It comprises of prepaid orders otherwise.
125 
    Pass providerId and warehouseId as -1 to ignore both these parameters.
3431 rajveer 126 
 
3427 chandransh 127 
    Parameters:
128 
     - fromShippingDate
129 
     - toShippingDate
130 
     - providerId
131 
     - warehouseId
3451 chandransh 132 
     - cod
3427 chandransh 133 
    """
134 
    pass
135 
 
1382 varun.gupt 136 
  def getReturnableOrdersForCustomer(self, customer_id, limit):
137 
    """
138 
    Returns order ids for orders which can be returned
3431 rajveer 139 
 
1382 varun.gupt 140 
    Parameters:
141 
     - customer_id
142 
     - limit
143 
    """
144 
    pass
145 
 
146 
  def getCancellableOrdersForCustomer(self, customer_id, limit):
147 
    """
148 
    Returns order ids for orders which can be cancelled
3431 rajveer 149 
 
1382 varun.gupt 150 
    Parameters:
151 
     - customer_id
152 
     - limit
153 
    """
154 
    pass
155 
 
483 rajveer 156 
  def changeOrderStatus(self, orderId, status, description):
94 ashish 157 
    """
158 
    Parameters:
483 rajveer 159 
     - orderId
160 
     - status
161 
     - description
94 ashish 162 
    """
163 
    pass
164 
 
1528 ankur.sing 165 
  def getOrdersForTransaction(self, transactionId, customerId):
94 ashish 166 
    """
1528 ankur.sing 167 
    Returns list of orders for given transaction Id. Also filters based on customer Id so that
168 
    only user who owns the transaction can view its order details.
3431 rajveer 169 
 
94 ashish 170 
    Parameters:
171 
     - transactionId
1528 ankur.sing 172 
     - customerId
94 ashish 173 
    """
174 
    pass
175 
 
3014 chandransh 176 
  def getOrdersForCustomer(self, customerId, from_date, to_date, statuses):
94 ashish 177 
    """
3014 chandransh 178 
    Returns list of orders for the given customer created between the given dates and having the given statuses.
179 
    Pass and empty list to ignore filtering on statuses.
3431 rajveer 180 
 
94 ashish 181 
    Parameters:
483 rajveer 182 
     - customerId
183 
     - from_date
184 
     - to_date
3014 chandransh 185 
     - statuses
94 ashish 186 
    """
187 
    pass
188 
 
483 rajveer 189 
  def createOrder(self, order):
94 ashish 190 
    """
191 
    Parameters:
483 rajveer 192 
     - order
94 ashish 193 
    """
194 
    pass
195 
 
483 rajveer 196 
  def getOrder(self, id):
94 ashish 197 
    """
198 
    Parameters:
483 rajveer 199 
     - id
94 ashish 200 
    """
201 
    pass
202 
 
483 rajveer 203 
  def getLineItemsForOrder(self, orderId):
94 ashish 204 
    """
205 
    Parameters:
483 rajveer 206 
     - orderId
94 ashish 207 
    """
208 
    pass
209 
 
4999 phani.kuma 210 
  def getOrderList(self, order_ids):
211 
    """
212 
    Parameters:
213 
     - order_ids
214 
    """
215 
    pass
216 
 
5386 phani.kuma 217 
  def getOrderListForVendor(self, order_ids, vendorId):
218 
    """
219 
    Parameters:
220 
     - order_ids
221 
     - vendorId
222 
    """
223 
    pass
224 
 
1528 ankur.sing 225 
  def getOrderForCustomer(self, orderId, customerId):
226 
    """
227 
    Returns an order for the order Id. Also checks if the order belongs to the customer whose Id is passed.
228 
    Throws exception if either order Id is invalid or order does not below to the customer whose Id is passed.
3431 rajveer 229 
 
1528 ankur.sing 230 
    Parameters:
231 
     - orderId
232 
     - customerId
233 
    """
234 
    pass
235 
 
4444 rajveer 236 
  def getAlerts(self, type, warehouseId, status, timestamp):
3064 chandransh 237 
    """
238 
    Parameters:
4394 rajveer 239 
     - type
4444 rajveer 240 
     - warehouseId
4394 rajveer 241 
     - status
242 
     - timestamp
3064 chandransh 243 
    """
244 
    pass
245 
 
4444 rajveer 246 
  def addAlert(self, type, warehouseId, description):
3064 chandransh 247 
    """
248 
    Parameters:
249 
     - type
4444 rajveer 250 
     - warehouseId
4394 rajveer 251 
     - description
3064 chandransh 252 
    """
253 
    pass
254 
 
4444 rajveer 255 
  def markAlertsAsSeen(self, warehouseId):
256 
    """
257 
    Parameters:
258 
     - warehouseId
259 
    """
260 
    pass
261 
 
3064 chandransh 262 
  def getValidOrderCount(self, ):
263 
    """
264 
    Return the number of valid orders. (OrderStatus >= OrderStatus.SUBMITTED_FOR_PROCESSING)
265 
    """
266 
    pass
267 
 
268 
  def getNoOfCustomersWithSuccessfulTransaction(self, ):
269 
    """
270 
    Returns the number of distinct customers who have done successful transactions
271 
    """
272 
    pass
273 
 
274 
  def getValidOrdersAmountRange(self, ):
275 
    """
276 
    Returns the minimum and maximum amounts of a valid order. (OrderStatus >= OrderStatus.SUBMITTED_FOR_PROCESSING)
277 
    List contains two values, first minimum amount and second maximum amount.
278 
    """
279 
    pass
280 
 
281 
  def getValidOrders(self, limit):
282 
    """
283 
    Returns list of Orders in descending order by Order creation date. List is restricted to limit Orders.
284 
    If limit is passed as 0, then all valid Orders are returned.
3431 rajveer 285 
 
3064 chandransh 286 
    Parameters:
287 
     - limit
288 
    """
289 
    pass
290 
 
1220 chandransh 291 
  def batchOrders(self, warehouseId):
292 
    """
293 
    Create a batch of all the pending orders for the given warehouse.
294 
    The returned list is orderd by created_timestamp.
295 
    If there are no pending orders, an empty list is returned.
3431 rajveer 296 
 
1220 chandransh 297 
    Parameters:
298 
     - warehouseId
299 
    """
300 
    pass
301 
 
1208 chandransh 302 
  def markOrderAsOutOfStock(self, orderId):
303 
    """
304 
    Mark the given order as out of stock. Throws an exception if the order with the given Id couldn't be found.
3431 rajveer 305 
 
1208 chandransh 306 
    Parameters:
307 
     - orderId
308 
    """
309 
    pass
310 
 
3064 chandransh 311 
  def verifyOrder(self, orderId):
759 chandransh 312 
    """
3064 chandransh 313 
    Marks the given order as SUBMITTED_FOR_PROCESSING and updates the verified
314 
    timestamp. It is intended to be used for COD orders but can be harmlessly
315 
    used for all other orders as well.
316 
    Throws an exception if no such order exists.
3431 rajveer 317 
 
759 chandransh 318 
    Parameters:
3064 chandransh 319 
     - orderId
320 
    """
321 
    pass
322 
 
323 
  def acceptOrder(self, orderId):
324 
    """
325 
    Marks the given order as ACCEPTED and updates the accepted timestamp. If the
326 
    given order is not a COD order, it also captures the payment if the same has
327 
    not been captured.
328 
    Throws an exception if no such order exists.
3431 rajveer 329 
 
3064 chandransh 330 
    Parameters:
331 
     - orderId
332 
    """
333 
    pass
334 
 
5110 mandeep.dh 335 
  def addBillingDetails(self, orderId, invoice_number, serialNumber, itemNumber, billed_by, jacketNumber, billingType, fulfilmentWarehouseId, authorize):
3064 chandransh 336 
    """
337 
    Add billing details such as the bill number and the biller to the Order.
4658 mandeep.dh 338 
    Adds jacket number, item number and Serial no. to the order. Doesn't update
3064 chandransh 339 
    the IMEI no. if a -1 is supplied.
340 
    Also, it generates an invoice number for the order, marks the order as
341 
    BILLED and sets the billing timestamp.
342 
    Returns false if it doesn't find the order with the given ID.
3431 rajveer 343 
 
3064 chandransh 344 
    Parameters:
345 
     - orderId
4283 anupam.sin 346 
     - invoice_number
4658 mandeep.dh 347 
     - serialNumber
3064 chandransh 348 
     - itemNumber
4283 anupam.sin 349 
     - billed_by
350 
     - jacketNumber
3064 chandransh 351 
     - billingType
5110 mandeep.dh 352 
     - fulfilmentWarehouseId
4763 rajveer 353 
     - authorize
3064 chandransh 354 
    """
355 
    pass
356 
 
4763 rajveer 357 
  def addInvoiceNumber(self, orderId, invoiceNumber, color):
4579 rajveer 358 
    """
359 
    Add the invoice number to the order.
360 
 
361 
    Parameters:
362 
     - orderId
363 
     - invoiceNumber
4763 rajveer 364 
     - color
4579 rajveer 365 
    """
366 
    pass
367 
 
4910 phani.kuma 368 
  def markOrdersAsShippedFromWarehouse(self, warehouseId, providerId, cod, orderIds):
3064 chandransh 369 
    """
370 
    Depending on the third parameter, marks either all prepaid or all cod orders BILLED by the
4910 phani.kuma 371 
    given warehouse and were picked up by the given provider as SHIPPED_FROM_WH.
4410 rajveer 372 
 
373 
    Parameters:
374 
     - warehouseId
375 
     - providerId
376 
     - cod
4910 phani.kuma 377 
     - orderIds
4410 rajveer 378 
    """
379 
    pass
380 
 
4910 phani.kuma 381 
  def markOrdersAsPickedUp(self, providerId, pickupDetails):
4410 rajveer 382 
    """
4910 phani.kuma 383 
    Marks all SHIPPED_FROM_WH orders of the previous day for a provider as SHIPPED_TO_LOGISTICS.
384 
    Raises an exception if we encounter report for an AWB number that we did not ship.
3431 rajveer 385 
 
3064 chandransh 386 
    Parameters:
759 chandransh 387 
     - providerId
4910 phani.kuma 388 
     - pickupDetails
759 chandransh 389 
    """
390 
    pass
391 
 
4910 phani.kuma 392 
  def getOrdersNotPickedUp(self, providerId):
1113 chandransh 393 
    """
394 
    Returns a list of orders that were shipped from warehouse but did not appear in the pick-up report.
3431 rajveer 395 
 
1113 chandransh 396 
    Parameters:
397 
     - providerId
398 
    """
399 
    pass
400 
 
1132 chandransh 401 
  def markOrdersAsDelivered(self, providerId, deliveredOrders):
402 
    """
403 
    Marks all orders with AWBs in the given map as delivered. Also sets the delivery timestamp and
404 
    the name of the receiver.
405 
    Raises an exception if we encounter report for an AWB number that we did not ship.
3431 rajveer 406 
 
1132 chandransh 407 
    Parameters:
408 
     - providerId
409 
     - deliveredOrders
410 
    """
411 
    pass
412 
 
4910 phani.kuma 413 
  def markAsRTOrders(self, providerId, returnedOrders):
1135 chandransh 414 
    """
4910 phani.kuma 415 
    Mark all orders with AWBs in the given map as RTO. Also sets the delivery timestamp.
1135 chandransh 416 
    Raises an exception if we encounter report for an AWB number that we did not ship.
3431 rajveer 417 
 
1135 chandransh 418 
    Parameters:
419 
     - providerId
420 
     - returnedOrders
421 
    """
422 
    pass
423 
 
4910 phani.kuma 424 
  def getRTOrders(self, providerId):
425 
    """
426 
    Returns a list of orders that were returned by courier.
427 
 
428 
    Parameters:
429 
     - providerId
430 
    """
431 
    pass
432 
 
1246 chandransh 433 
  def updateNonDeliveryReason(self, providerId, undeliveredOrders):
434 
    """
435 
    Update the status description of orders whose AWB numbers are keys of the Map.
3431 rajveer 436 
 
1246 chandransh 437 
    Parameters:
438 
     - providerId
439 
     - undeliveredOrders
440 
    """
441 
    pass
442 
 
4910 phani.kuma 443 
  def getNonDeliveredOrdersbyCourier(self, providerId):
444 
    """
445 
    Returns a list of orders that were picked up or shipped four days ago but did not get delivered.
446 
 
447 
    Parameters:
448 
     - providerId
449 
    """
450 
    pass
451 
 
452 
  def markOrdersAsLocalConnected(self, providerId, local_connected_orders):
453 
    """
454 
    Mark all orders with AWBs in the given map as local connected. Also sets the local connected timestamp.
455 
 
456 
    Parameters:
457 
     - providerId
458 
     - local_connected_orders
459 
    """
460 
    pass
461 
 
462 
  def getOrdersNotLocalConnected(self, providerId):
463 
    """
464 
    Returns a list of orders that were picked up or shipped but pending local connection.
465 
 
466 
    Parameters:
467 
     - providerId
468 
    """
469 
    pass
470 
 
471 
  def markOrdersAsDestinationCityReached(self, providerId, destination_city_reached_orders):
472 
    """
473 
    Mark all orders with AWBs in the given map as reached destination city. Also sets the reached destination timestamp.
474 
 
475 
    Parameters:
476 
     - providerId
477 
     - destination_city_reached_orders
478 
    """
479 
    pass
480 
 
481 
  def markOrdersAsFirstDeliveryAttempted(self, providerId, first_atdl_orders):
482 
    """
483 
    Mark all orders with AWBs in the given map as first delivery attempt made. Also sets the first delivery attempted timestamp.
484 
 
485 
    Parameters:
486 
     - providerId
487 
     - first_atdl_orders
488 
    """
489 
    pass
490 
 
1408 ankur.sing 491 
  def getUndeliveredOrders(self, providerId, warehouseId):
492 
    """
493 
    Returns the list of orders whose delivery time has passed but have not been
494 
    delivered yet for the given provider and warehouse. To get a complete list of
495 
    undelivered orders, pass them as -1.
496 
    Returns an empty list if no such orders exist.
3431 rajveer 497 
 
1408 ankur.sing 498 
    Parameters:
499 
     - providerId
500 
     - warehouseId
501 
    """
502 
    pass
503 
 
4783 phani.kuma 504 
  def getUndeliveredOrdersExpectedDeliveryDateNotMet(self, ):
505 
    """
506 
    Returns the list of orders whose expected delivery date has passed but have not been
507 
    delivered yet.
508 
    Returns an empty list if no such orders exist.
509 
    """
510 
    pass
511 
 
2536 chandransh 512 
  def toggleDOAFlag(self, orderId):
513 
    """
514 
    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.
515 
    Returns the final flag status.
516 
    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 517 
 
2536 chandransh 518 
    Parameters:
519 
     - orderId
520 
    """
521 
    pass
1886 ankur.sing 522 
 
4712 rajveer 523 
  def markOrderAsDelivered(self, orderId, deliveryTimestamp, receiver):
524 
    """
525 
    Parameters:
526 
     - orderId
527 
     - deliveryTimestamp
528 
     - receiver
529 
    """
530 
    pass
531 
 
4454 rajveer 532 
  def markOrderDoaRequestReceived(self, orderId):
533 
    """
534 
    Once user raise the request for a DOA, order status will be changed from DELVIERY_SUCCESS to DOA_REQUEST_RECEIVED
535 
 
536 
    Parameters:
537 
     - orderId
538 
    """
539 
    pass
540 
 
541 
  def markOrderDoaRequestAuthorized(self, orderId, isAuthorized):
542 
    """
543 
    CRM person can authorize or deny the request reised by customer. If he authorizes order will change from DOA_REQUEST_RECEIVED
544 
    to DOA_REQUEST_AUTHORIZED. If he denies, status will be changed back to DELVIERY_SUCCESS.
545 
 
546 
    Parameters:
547 
     - orderId
548 
     - isAuthorized
549 
    """
550 
    pass
551 
 
4488 rajveer 552 
  def markOrderReturnRequestReceived(self, orderId):
553 
    """
554 
    Once user raise the request for a RET, order status will be changed from DELVIERY_SUCCESS to RET_REQUEST_RECEIVED
555 
 
556 
    Parameters:
557 
     - orderId
558 
    """
559 
    pass
560 
 
561 
  def markOrderReturnRequestAuthorized(self, orderId, isAuthorized):
562 
    """
563 
    CRM person can authorize or deny the request reised by customer. If he authorizes order will change from RET_REQUEST_RECEIVED
564 
    to RET_REQUEST_AUTHORIZED. If he denies, status will be changed back to DELVIERY_SUCCESS.
565 
 
566 
    Parameters:
567 
     - orderId
568 
     - isAuthorized
569 
    """
570 
    pass
571 
 
4579 rajveer 572 
  def requestPickupNumber(self, orderId, providerId):
2536 chandransh 573 
    """
574 
    Sends out an email to the account manager of the original courier provider used to ship the order.
4452 rajveer 575 
    If the order status was DELIVERY_SUCCESS, it is changed to be DOA_PICKUP_REQUEST_RAISED.
576 
    If the order status was DOA_PICKUP_REQUEST_RAISED, it is left unchanged.
2536 chandransh 577 
    For any other status, it returns false.
578 
    Throws an exception if the order with the given id couldn't be found.
3431 rajveer 579 
 
2536 chandransh 580 
    Parameters:
581 
     - orderId
4579 rajveer 582 
     - providerId
2536 chandransh 583 
    """
584 
    pass
585 
 
4602 rajveer 586 
  def authorizePickup(self, orderId, pickupNumber, providerId):
2536 chandransh 587 
    """
4452 rajveer 588 
    If the order status is DOA_PICKUP_REQUEST_RAISED, it does the following
2536 chandransh 589 
    	1. Sends out an email to the customer with the dispatch advice that he has to print as an attachment.
590 
    	2. Changes order status to be DOA_PICKUP_AUTHORIZED.
591 
    	3. Returns true
2591 chandransh 592 
    If the order is in any other status, it returns false.
2536 chandransh 593 
    Throws an exception if the order with the given id couldn't be found.
3431 rajveer 594 
 
2536 chandransh 595 
    Parameters:
596 
     - orderId
597 
     - pickupNumber
4602 rajveer 598 
     - providerId
2536 chandransh 599 
    """
600 
    pass
601 
 
2764 chandransh 602 
  def markDoasAsPickedUp(self, providerId, pickupDetails):
603 
    """
604 
    Marks all DOA_PICKUP_AUTHORIZED orders of the previous day for a provider as DOA_RETURN_IN_TRANSIT.
3431 rajveer 605 
 
2764 chandransh 606 
    Parameters:
607 
     - providerId
608 
     - pickupDetails
609 
    """
610 
    pass
611 
 
4910 phani.kuma 612 
  def getDoasNotPickedUp(self, providerId):
613 
    """
614 
    Returns a list of orders that were authorized for pickup but did not appear in the pick-up report.
615 
 
616 
    Parameters:
617 
     - providerId
618 
    """
619 
    pass
620 
 
4741 phani.kuma 621 
  def markReturnOrdersAsPickedUp(self, providerId, pickupDetails):
622 
    """
623 
    Marks all RET_PICKUP_CONFIRMED orders of the previous day for a provider as RET_RETURN_IN_TRANSIT.
624 
 
625 
    Parameters:
626 
     - providerId
627 
     - pickupDetails
628 
    """
629 
    pass
630 
 
4910 phani.kuma 631 
  def getReturnOrdersNotPickedUp(self, providerId):
632 
    """
633 
    Returns a list of orders that were authorized for pickup but did not appear in the pick-up report.
634 
 
635 
    Parameters:
636 
     - providerId
637 
    """
638 
    pass
639 
 
4479 rajveer 640 
  def receiveReturn(self, orderId, receiveCondition):
2591 chandransh 641 
    """
4452 rajveer 642 
    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 643 
    If the order status is RTO_IN_TRANSIT, marks the order status as RTO_RECEIVED_PRESTINE and returns true.
2591 chandransh 644 
    If the order is in any other state, it returns false.
645 
    Throws an exception if the order with the given id couldn't be found.
3431 rajveer 646 
 
2591 chandransh 647 
    Parameters:
648 
     - orderId
4479 rajveer 649 
     - receiveCondition
2591 chandransh 650 
    """
651 
    pass
2536 chandransh 652 
 
2591 chandransh 653 
  def validateDoa(self, orderId, isValid):
654 
    """
4452 rajveer 655 
    Used to validate the DOA certificate for an order in the DOA_RECEIVED_PRESTINE state. If the certificate is valid,
2616 chandransh 656 
    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 657 
    If the order is in any other state, it returns false.
658 
    Throws an exception if the order with the given id couldn't be found.
3431 rajveer 659 
 
2591 chandransh 660 
    Parameters:
661 
     - orderId
662 
     - isValid
663 
    """
664 
    pass
665 
 
4495 rajveer 666 
  def validateReturnProduct(self, orderId, isUsable):
667 
    """
668 
    Parameters:
669 
     - orderId
670 
     - isUsable
671 
    """
672 
    pass
673 
 
2616 chandransh 674 
  def reshipOrder(self, orderId):
675 
    """
4484 rajveer 676 
    If the order is in RTO_RECEIVED_PRESTINE or DOA_CERT_INVALID state, it does the following:
2616 chandransh 677 
    	1. Creates a new order for processing in the BILLED state. All billing information is saved.
4484 rajveer 678 
    	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 679 
 
680 
    If the order is in DOA_CERT_VALID state, it does the following:
681 
    	1. Creates a new order for processing in the SUBMITTED_FOR_PROCESSING state.
682 
    	2. Creates a return order for the warehouse executive to return the DOA material.
4452 rajveer 683 
    	3. Marks the current order as the final DOA_VALID_RESHIPPED state.
3431 rajveer 684 
 
2616 chandransh 685 
    Returns the id of the newly created order.
3431 rajveer 686 
 
2616 chandransh 687 
    Throws an exception if the order with the given id couldn't be found.
3431 rajveer 688 
 
2616 chandransh 689 
    Parameters:
690 
     - orderId
691 
    """
692 
    pass
2591 chandransh 693 
 
3226 chandransh 694 
  def refundOrder(self, orderId, refundedBy, reason):
2616 chandransh 695 
    """
4484 rajveer 696 
    If the order is in RTO_RECEIVED_PRESTINE, DOA_CERT_VALID or DOA_CERT_INVALID state, it does the following:
2616 chandransh 697 
    	1. Creates a refund request for batch processing.
698 
    	2. Creates a return order for the warehouse executive to return the shipped material.
4484 rajveer 699 
    	3. Marks the current order as RTO_REFUNDED, DOA_VALID_REFUNDED or DOA_INVALID_REFUNDED final states.
3431 rajveer 700 
 
2616 chandransh 701 
    If the order is in SUBMITTED_FOR_PROCESSING or INVENTORY_LOW state, it does the following:
702 
    	1. Creates a refund request for batch processing.
3226 chandransh 703 
    	2. Cancels the reservation of the item in the warehouse.
704 
    	3. Marks the current order as the REFUNDED final state.
3431 rajveer 705 
 
3226 chandransh 706 
    For all COD orders, if the order is in INIT, SUBMITTED_FOR_PROCESSING or INVENTORY_LOW state, it does the following:
707 
    	1. Cancels the reservation of the item in the warehouse.
708 
    	2. Marks the current order as CANCELED.
709 
 
710 
    In all cases, it updates the reason for cancellation or refund and the person who performed the action.
711 
 
2616 chandransh 712 
    Returns True if it is successful, False otherwise.
3431 rajveer 713 
 
2616 chandransh 714 
    Throws an exception if the order with the given id couldn't be found.
3431 rajveer 715 
 
2616 chandransh 716 
    Parameters:
717 
     - orderId
3226 chandransh 718 
     - refundedBy
719 
     - reason
2616 chandransh 720 
    """
721 
    pass
722 
 
2690 chandransh 723 
  def getReturnOrders(self, warehouseId, fromDate, toDate):
724 
    """
725 
    Get all return orders created between the from and to dates for the given warehouse.
726 
    Ignores the warehouse if it is passed as -1.
3431 rajveer 727 
 
2690 chandransh 728 
    Parameters:
729 
     - warehouseId
730 
     - fromDate
731 
     - toDate
732 
    """
733 
    pass
2616 chandransh 734 
 
5481 phani.kuma 735 
  def getAllReturnOrders(self, onlyNotProcessed, fromDate, toDate):
736 
    """
737 
    Get all return orders created between the from and to dates.
738 
 
739 
    Parameters:
740 
     - onlyNotProcessed
741 
     - fromDate
742 
     - toDate
743 
    """
744 
    pass
745 
 
2700 chandransh 746 
  def getReturnOrder(self, id):
747 
    """
748 
    Returns the ReturnOrder corresponding to the given id.
749 
    Throws an exception if the return order with the given id couldn't be found.
3431 rajveer 750 
 
2700 chandransh 751 
    Parameters:
752 
     - id
753 
    """
754 
    pass
755 
 
2690 chandransh 756 
  def processReturn(self, returnOrderId):
757 
    """
758 
    Marks the return order with the given id as processed. Raises an exception if no such return order exists.
3431 rajveer 759 
 
2690 chandransh 760 
    Parameters:
761 
     - returnOrderId
762 
    """
763 
    pass
764 
 
3451 chandransh 765 
  def updateWeight(self, orderId, weight):
766 
    """
767 
    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 768 
 
3451 chandransh 769 
    Parameters:
770 
     - orderId
771 
     - weight
772 
    """
773 
    pass
774 
 
3469 chandransh 775 
  def changeItem(self, orderId, itemId):
776 
    """
777 
    Change the item to be shipped for this order. Also adjusts the reservation in the inventory accordingly.
778 
    Currently, it also ensures that only a different color of the given item is shipped.
3451 chandransh 779 
 
3469 chandransh 780 
    Parameters:
781 
     - orderId
782 
     - itemId
783 
    """
784 
    pass
785 
 
786 
  def shiftToWarehouse(self, orderId, warehouseId):
787 
    """
788 
    Moves the given order to the given warehouse. Also adjusts the inventory reservations accordingly.
789 
 
790 
    Parameters:
791 
     - orderId
792 
     - warehouseId
793 
    """
794 
    pass
795 
 
4647 rajveer 796 
  def addDelayReason(self, orderId, delayReason, furtherDelay, delayReasonText):
3553 chandransh 797 
    """
798 
    Adds the given delay reason to the given order.
3986 chandransh 799 
    Increases the expected delivery time of the given order by the given no. of days.
3553 chandransh 800 
    Raises an exception if no order with the given id can be found.
3469 chandransh 801 
 
3553 chandransh 802 
    Parameters:
803 
     - orderId
804 
     - delayReason
3986 chandransh 805 
     - furtherDelay
4647 rajveer 806 
     - delayReasonText
3553 chandransh 807 
    """
808 
    pass
809 
 
3956 chandransh 810 
  def reconcileCodCollection(self, collectedAmountMap, xferBy, xferTxnId, xferDate):
811 
    """
812 
    Marks the COD orders with given AWB nos. as having been processed.
813 
    Updates the captured amount for the corresponding payment.
3553 chandransh 814 
 
3956 chandransh 815 
    Returns a map of AWBs which were not processed and the associated reason. An AWB is not processed if:
816 
    1. There is no order corresponding to an AWB number.
817 
    2. The captured amount for a payment exceeds the total payment.
818 
    3. The order corresponding to an AWB no. is in a state prior to DELIVERY_SUCCESS.
819 
 
820 
    Parameters:
821 
     - collectedAmountMap
822 
     - xferBy
823 
     - xferTxnId
824 
     - xferDate
825 
    """
826 
    pass
827 
 
4008 mandeep.dh 828 
  def getTransactionsRequiringExtraProcessing(self, category):
829 
    """
4065 mandeep.dh 830 
    Returns the list of transaction ids that require some extra processing and
4008 mandeep.dh 831 
    which belong to a particular category. This is currently used by CRM
4065 mandeep.dh 832 
    application. If no such transaction ids are present, it returns an empty list.
3956 chandransh 833 
 
4008 mandeep.dh 834 
    Parameters:
835 
     - category
836 
    """
837 
    pass
838 
 
839 
  def markTransactionAsProcessed(self, transactionId, category):
840 
    """
841 
    Marks a particular transaction as processed for a particular cateogory.
4065 mandeep.dh 842 
    It essentially deletes the transaction id record for a particular
843 
    processing type category (if present) from DB.
844 
    This is currently used by CRM application.
4008 mandeep.dh 845 
 
846 
    Parameters:
847 
     - transactionId
848 
     - category
849 
    """
850 
    pass
851 
 
4018 chandransh 852 
  def getItemWiseRiskyOrdersCount(self, ):
853 
    """
854 
    Returns a map containing the number of risky orders keyed by item id. A risky order
855 
    is defined as one whose shipping date is about to expire.
856 
    """
857 
    pass
4008 mandeep.dh 858 
 
4295 varun.gupt 859 
  def getOrdersForItemIds(self, itemIds):
860 
    """
861 
    Returns a list of all orders which have items with given id
862 
 
863 
    Parameters:
864 
     - itemIds
865 
    """
866 
    pass
867 
 
4247 rajveer 868 
  def markOrderCancellationRequestReceived(self, orderId):
869 
    """
870 
    Mark order as cancellation request received. If customer sends request of cancellation of
871 
    a particular order, this method will be called. It will just change status of the order
872 
    depending on its current status. It also records the previous status, so that we can move
873 
    back to that status if cancellation request is denied.
4018 chandransh 874 
 
4247 rajveer 875 
    Parameters:
876 
     - orderId
877 
    """
878 
    pass
879 
 
880 
  def markOrderCancellationRequestConfirmed(self, orderId):
881 
    """
882 
    If we decide to to cancel order, CRM will call this method to move the status of order to
883 
    cancellation request confirmed. After this OM will be able to cancel the order.
884 
 
885 
    Parameters:
886 
     - orderId
887 
    """
888 
    pass
889 
 
890 
  def markOrderCancellationRequestDenied(self, orderId):
891 
    """
892 
    If we decide to not to cancel order, we will move the order ro previous status.
893 
 
894 
    Parameters:
895 
     - orderId
896 
    """
897 
    pass
898 
 
4258 rajveer 899 
  def markTransactionAsPaymentFlagRemoved(self, transactionId):
4247 rajveer 900 
    """
4258 rajveer 901 
    If we and/or payment gateway has decided to accept the payment, this method needs to be called.
902 
    Changed transaction and all orders status to payment accepted.
4247 rajveer 903 
 
904 
    Parameters:
4258 rajveer 905 
     - transactionId
4247 rajveer 906 
    """
907 
    pass
908 
 
4259 anupam.sin 909 
  def refundTransaction(self, transactionId, refundedBy, reason):
910 
    """
911 
    This method is called when a flagged payment is deemed unserviceable and the corresponding orders
912 
    need to be cancelled
4247 rajveer 913 
 
4259 anupam.sin 914 
    Parameters:
915 
     - transactionId
916 
     - refundedBy
917 
     - reason
918 
    """
919 
    pass
920 
 
4324 mandeep.dh 921 
  def updateShipmentAddress(self, orderId, addressId):
922 
    """
923 
    Updates shipment address of an order. Delivery and shipping date estimates
924 
    etc. are also updated here.
925 
 
926 
    Throws TransactionServiceException in case address change is not
927 
    possible due to certain reasons such as new pincode in address is
928 
    not serviceable etc.
929 
 
930 
    Parameters:
931 
     - orderId
932 
     - addressId
933 
    """
934 
    pass
935 
 
4285 rajveer 936 
  def acceptOrdersForItemId(self, itemId, inventory):
937 
    """
938 
    Marks the orders as ACCEPTED for the given itemId and inventory. It also updates the accepted timestamp. If the
939 
    given order is not a COD order, it also captures the payment if the same has not been captured.
4259 anupam.sin 940 
 
4285 rajveer 941 
    Parameters:
942 
     - itemId
943 
     - inventory
944 
    """
945 
    pass
946 
 
4369 rajveer 947 
  def markOrdersAsPORaised(self, vendorId, itemId, quantity, estimate, isReminder):
4303 rajveer 948 
    """
949 
    Parameters:
950 
     - vendorId
951 
     - itemId
952 
     - quantity
953 
     - estimate
4369 rajveer 954 
     - isReminder
4303 rajveer 955 
    """
956 
    pass
4285 rajveer 957 
 
4369 rajveer 958 
  def markOrdersAsReversalInitiated(self, vendorId, itemId, quantity, estimate, isReminder):
4303 rajveer 959 
    """
960 
    Parameters:
961 
     - vendorId
962 
     - itemId
963 
     - quantity
964 
     - estimate
4369 rajveer 965 
     - isReminder
4303 rajveer 966 
    """
967 
    pass
968 
 
4369 rajveer 969 
  def markOrdersAsNotAvailabke(self, vendorId, itemId, quantity, estimate, isReminder):
4303 rajveer 970 
    """
971 
    Parameters:
972 
     - vendorId
973 
     - itemId
974 
     - quantity
975 
     - estimate
4369 rajveer 976 
     - isReminder
4303 rajveer 977 
    """
978 
    pass
979 
 
4369 rajveer 980 
  def markOrdersAsTimeout(self, vendorId):
981 
    """
982 
    Parameters:
983 
     - vendorId
984 
    """
985 
    pass
4303 rajveer 986 
 
4662 rajveer 987 
  def markOrderAsLostInTransit(self, orderId):
988 
    """
989 
    Mark order as LOST_IN_TRANSIT
990 
 
991 
    Parameters:
992 
     - orderId
993 
    """
994 
    pass
995 
 
4386 anupam.sin 996 
  def getOrderForAwb(self, awb):
997 
    """
998 
    Returns the order corresponding to an AWB number
4369 rajveer 999 
 
4386 anupam.sin 1000 
    Parameters:
1001 
     - awb
1002 
    """
1003 
    pass
1004 
 
4910 phani.kuma 1005 
  def getOrdersForProviderForStatus(self, logistics_provider_id, order_status_list):
4506 phani.kuma 1006 
    """
4910 phani.kuma 1007 
    Returns the order corresponding to a logistics provider id for a given list of order status
4386 anupam.sin 1008 
 
4506 phani.kuma 1009 
    Parameters:
1010 
     - logistics_provider_id
4910 phani.kuma 1011 
     - order_status_list
4506 phani.kuma 1012 
    """
1013 
    pass
1014 
 
4600 varun.gupt 1015 
  def getBilledOrdersForVendor(self, vendorId, billingDateFrom, billingDateTo):
1016 
    """
1017 
    Returns list of orders fullfiled from a certain vendor and billed in a given date range
4506 phani.kuma 1018 
 
4600 varun.gupt 1019 
    Parameters:
1020 
     - vendorId
1021 
     - billingDateFrom
1022 
     - billingDateTo
1023 
    """
1024 
    pass
1025 
 
4607 rajveer 1026 
  def getSlippedSippingDateOrders(self, ):
1027 
    pass
1028 
 
4709 rajveer 1029 
  def getCancelledOrders(self, cancelDateFrom, cancelDateTo):
1030 
    """
1031 
    Parameters:
1032 
     - cancelDateFrom
1033 
     - cancelDateTo
1034 
    """
1035 
    pass
1036 
 
4600 varun.gupt 1037 
  def saveBluedartSettlements(self, mapAWBAndAmount):
1038 
    """
1039 
    Parameters:
1040 
     - mapAWBAndAmount
1041 
    """
1042 
    pass
1043 
 
4905 varun.gupt 1044 
  def savePaymentSettlements(self, settlementDate, paymentGatewayId, referenceId, serviceTax, otherCharges, netCollection):
4600 varun.gupt 1045 
    """
1046 
    Parameters:
1047 
     - settlementDate
1048 
     - paymentGatewayId
4905 varun.gupt 1049 
     - referenceId
4600 varun.gupt 1050 
     - serviceTax
1051 
     - otherCharges
1052 
     - netCollection
1053 
    """
1054 
    pass
1055 
 
1056 
  def saveEBSSettlementSummary(self, settlementId, settlementDate, transactionDateFrom, transactionDateTo, amount):
1057 
    """
1058 
    Parameters:
1059 
     - settlementId
1060 
     - settlementDate
1061 
     - transactionDateFrom
1062 
     - transactionDateTo
1063 
     - amount
1064 
    """
1065 
    pass
1066 
 
5386 phani.kuma 1067 
  def getSettlementForPrepaid(self, referenceId, isRefund):
4600 varun.gupt 1068 
    """
1069 
    Parameters:
5189 varun.gupt 1070 
     - referenceId
1071 
     - isRefund
4600 varun.gupt 1072 
    """
1073 
    pass
1074 
 
5386 phani.kuma 1075 
  def getSettlementForCod(self, orderId, isRefund):
1076 
    """
1077 
    Parameters:
1078 
     - orderId
1079 
     - isRefund
1080 
    """
1081 
    pass
1082 
 
4600 varun.gupt 1083 
  def getEBSSettlementSummaries(self, ):
1084 
    pass
1085 
 
1086 
  def markEBSSettlementUploaded(self, settlementId):
1087 
    """
1088 
    Parameters:
1089 
     - settlementId
1090 
    """
1091 
    pass
1092 
 
1093 
  def getEBSSettlementDate(self, settlementId):
1094 
    """
1095 
    Parameters:
1096 
     - settlementId
1097 
    """
1098 
    pass
1099 
 
4715 varun.gupt 1100 
  def getSettlementsByDate(self, settlementDateFrom, settlementDateTo, isRefund):
1101 
    """
1102 
    Parameters:
1103 
     - settlementDateFrom
1104 
     - settlementDateTo
1105 
     - isRefund
1106 
    """
1107 
    pass
4600 varun.gupt 1108 
 
4715 varun.gupt 1109 
  def getReshippedOrderIds(self, orderIds):
1110 
    """
1111 
    Returns list of Order Ids, which belong to reshiped orders, shortlisted from a given list of Order Ids
1112 
 
1113 
    Parameters:
1114 
     - orderIds
1115 
    """
1116 
    pass
1117 
 
5481 phani.kuma 1118 
  def getBilledOrders(self, vendorId, onlyVendorNotPaid, billingDateFrom, billingDateTo):
4875 varun.gupt 1119 
    """
1120 
    Parameters:
1121 
     - vendorId
5481 phani.kuma 1122 
     - onlyVendorNotPaid
1123 
     - billingDateFrom
1124 
     - billingDateTo
4875 varun.gupt 1125 
    """
1126 
    pass
4757 mandeep.dh 1127 
 
5031 varun.gupt 1128 
  def getStatusDistributionOfOrders(self, startDate, endDate):
1129 
    """
1130 
    Parameters:
1131 
     - startDate
1132 
     - endDate
1133 
    """
1134 
    pass
4875 varun.gupt 1135 
 
5067 varun.gupt 1136 
  def getOrderIdsForStatus(self, status, startDatetime, endDatetime):
1137 
    """
1138 
    Parameters:
1139 
     - status
1140 
     - startDatetime
1141 
     - endDatetime
1142 
    """
1143 
    pass
5031 varun.gupt 1144 
 
5348 anupam.sin 1145 
  def updateCODAgent(self, agent, orderId):
1146 
    """
1147 
    Updates the agent who handled the COD verification call
1148 
 
1149 
    Parameters:
1150 
     - agent
1151 
     - orderId
1152 
    """
1153 
    pass
1154 
 
5099 varun.gupt 1155 
  def updateOrderAsPaidToVendor(self, orderId):
1156 
    """
1157 
    Parameters:
1158 
     - orderId
1159 
    """
1160 
    pass
5067 varun.gupt 1161 
 
5386 phani.kuma 1162 
  def updateOrderOnlyAsPaidToVendor(self, orderId):
1163 
    """
1164 
    Parameters:
1165 
     - orderId
1166 
    """
1167 
    pass
1168 
 
5208 varun.gupt 1169 
  def getRefundedOrdersMarkedPaid(self, ):
1170 
    pass
5099 varun.gupt 1171 
 
5447 anupam.sin 1172 
  def getAllVerificationAgents(self, minOrderId, maxOrderId):
1173 
    """
1174 
    gets all COD Verification Agents for all orderIds from a minId to maxId
5208 varun.gupt 1175 
 
5447 anupam.sin 1176 
 
1177 
    Parameters:
1178 
     - minOrderId
1179 
     - maxOrderId
1180 
    """
1181 
    pass
1182 
 
5527 anupam.sin 1183 
  def getAllAttributesForOrderId(self, orderId):
1184 
    """
1185 
    gets all attributes for a given orderId
5447 anupam.sin 1186 
 
5527 anupam.sin 1187 
    Parameters:
1188 
     - orderId
1189 
    """
1190 
    pass
1191 
 
1192 
  def setOrderAttributeForTransaction(self, transactionId, attribute):
1193 
    """
1194 
    sets attributes for all orders in a transaction
1195 
 
1196 
    Parameters:
1197 
     - transactionId
1198 
     - attribute
1199 
    """
1200 
    pass
1201 
 
1202 
 
3376 rajveer 1203 
class Client(shop2020.thriftpy.generic.GenericService.Client, Iface):
94 ashish 1204 
  def __init__(self, iprot, oprot=None):
3376 rajveer 1205 
    shop2020.thriftpy.generic.GenericService.Client.__init__(self, iprot, oprot)
94 ashish 1206 
 
1207 
  def createTransaction(self, transaction):
1208 
    """
1209 
    Parameters:
1210 
     - transaction
1211 
    """
1212 
    self.send_createTransaction(transaction)
132 ashish 1213 
    return self.recv_createTransaction()
94 ashish 1214 
 
1215 
  def send_createTransaction(self, transaction):
1216 
    self._oprot.writeMessageBegin('createTransaction', TMessageType.CALL, self._seqid)
1217 
    args = createTransaction_args()
1218 
    args.transaction = transaction
1219 
    args.write(self._oprot)
1220 
    self._oprot.writeMessageEnd()
1221 
    self._oprot.trans.flush()
1222 
 
1223 
  def recv_createTransaction(self, ):
1224 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1225 
    if mtype == TMessageType.EXCEPTION:
1226 
      x = TApplicationException()
1227 
      x.read(self._iprot)
1228 
      self._iprot.readMessageEnd()
1229 
      raise x
1230 
    result = createTransaction_result()
1231 
    result.read(self._iprot)
1232 
    self._iprot.readMessageEnd()
3431 rajveer 1233 
    if result.success is not None:
132 ashish 1234 
      return result.success
3431 rajveer 1235 
    if result.ex is not None:
94 ashish 1236 
      raise result.ex
132 ashish 1237 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "createTransaction failed: unknown result");
94 ashish 1238 
 
1239 
  def getTransaction(self, id):
1240 
    """
1241 
    Parameters:
1242 
     - id
1243 
    """
1244 
    self.send_getTransaction(id)
1245 
    return self.recv_getTransaction()
1246 
 
1247 
  def send_getTransaction(self, id):
1248 
    self._oprot.writeMessageBegin('getTransaction', TMessageType.CALL, self._seqid)
1249 
    args = getTransaction_args()
1250 
    args.id = id
1251 
    args.write(self._oprot)
1252 
    self._oprot.writeMessageEnd()
1253 
    self._oprot.trans.flush()
1254 
 
1255 
  def recv_getTransaction(self, ):
1256 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1257 
    if mtype == TMessageType.EXCEPTION:
1258 
      x = TApplicationException()
1259 
      x.read(self._iprot)
1260 
      self._iprot.readMessageEnd()
1261 
      raise x
1262 
    result = getTransaction_result()
1263 
    result.read(self._iprot)
1264 
    self._iprot.readMessageEnd()
3431 rajveer 1265 
    if result.success is not None:
94 ashish 1266 
      return result.success
3431 rajveer 1267 
    if result.ex is not None:
94 ashish 1268 
      raise result.ex
1269 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getTransaction failed: unknown result");
1270 
 
1271 
  def getTransactionsForCustomer(self, customerId, from_date, to_date, status):
1272 
    """
1273 
    Parameters:
1274 
     - customerId
1275 
     - from_date
1276 
     - to_date
1277 
     - status
1278 
    """
1279 
    self.send_getTransactionsForCustomer(customerId, from_date, to_date, status)
1280 
    return self.recv_getTransactionsForCustomer()
1281 
 
1282 
  def send_getTransactionsForCustomer(self, customerId, from_date, to_date, status):
1283 
    self._oprot.writeMessageBegin('getTransactionsForCustomer', TMessageType.CALL, self._seqid)
1284 
    args = getTransactionsForCustomer_args()
1285 
    args.customerId = customerId
1286 
    args.from_date = from_date
1287 
    args.to_date = to_date
1288 
    args.status = status
1289 
    args.write(self._oprot)
1290 
    self._oprot.writeMessageEnd()
1291 
    self._oprot.trans.flush()
1292 
 
1293 
  def recv_getTransactionsForCustomer(self, ):
1294 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1295 
    if mtype == TMessageType.EXCEPTION:
1296 
      x = TApplicationException()
1297 
      x.read(self._iprot)
1298 
      self._iprot.readMessageEnd()
1299 
      raise x
1300 
    result = getTransactionsForCustomer_result()
1301 
    result.read(self._iprot)
1302 
    self._iprot.readMessageEnd()
3431 rajveer 1303 
    if result.success is not None:
94 ashish 1304 
      return result.success
3431 rajveer 1305 
    if result.ex is not None:
94 ashish 1306 
      raise result.ex
1307 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getTransactionsForCustomer failed: unknown result");
1308 
 
132 ashish 1309 
  def getTransactionsForShoppingCartId(self, shoppingCartId):
1310 
    """
1311 
    Parameters:
1312 
     - shoppingCartId
1313 
    """
1314 
    self.send_getTransactionsForShoppingCartId(shoppingCartId)
1315 
    return self.recv_getTransactionsForShoppingCartId()
1316 
 
1317 
  def send_getTransactionsForShoppingCartId(self, shoppingCartId):
1318 
    self._oprot.writeMessageBegin('getTransactionsForShoppingCartId', TMessageType.CALL, self._seqid)
1319 
    args = getTransactionsForShoppingCartId_args()
1320 
    args.shoppingCartId = shoppingCartId
1321 
    args.write(self._oprot)
1322 
    self._oprot.writeMessageEnd()
1323 
    self._oprot.trans.flush()
1324 
 
1325 
  def recv_getTransactionsForShoppingCartId(self, ):
1326 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1327 
    if mtype == TMessageType.EXCEPTION:
1328 
      x = TApplicationException()
1329 
      x.read(self._iprot)
1330 
      self._iprot.readMessageEnd()
1331 
      raise x
1332 
    result = getTransactionsForShoppingCartId_result()
1333 
    result.read(self._iprot)
1334 
    self._iprot.readMessageEnd()
3431 rajveer 1335 
    if result.success is not None:
132 ashish 1336 
      return result.success
3431 rajveer 1337 
    if result.ex is not None:
132 ashish 1338 
      raise result.ex
1339 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getTransactionsForShoppingCartId failed: unknown result");
1340 
 
94 ashish 1341 
  def getTransactionStatus(self, transactionId):
1342 
    """
1343 
    Parameters:
1344 
     - transactionId
1345 
    """
1346 
    self.send_getTransactionStatus(transactionId)
1347 
    return self.recv_getTransactionStatus()
1348 
 
1349 
  def send_getTransactionStatus(self, transactionId):
1350 
    self._oprot.writeMessageBegin('getTransactionStatus', TMessageType.CALL, self._seqid)
1351 
    args = getTransactionStatus_args()
1352 
    args.transactionId = transactionId
1353 
    args.write(self._oprot)
1354 
    self._oprot.writeMessageEnd()
1355 
    self._oprot.trans.flush()
1356 
 
1357 
  def recv_getTransactionStatus(self, ):
1358 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1359 
    if mtype == TMessageType.EXCEPTION:
1360 
      x = TApplicationException()
1361 
      x.read(self._iprot)
1362 
      self._iprot.readMessageEnd()
1363 
      raise x
1364 
    result = getTransactionStatus_result()
1365 
    result.read(self._iprot)
1366 
    self._iprot.readMessageEnd()
3431 rajveer 1367 
    if result.success is not None:
94 ashish 1368 
      return result.success
3431 rajveer 1369 
    if result.ex is not None:
94 ashish 1370 
      raise result.ex
1371 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getTransactionStatus failed: unknown result");
1372 
 
5527 anupam.sin 1373 
  def changeTransactionStatus(self, transactionId, status, description, pickUp, orderType):
94 ashish 1374 
    """
1375 
    Parameters:
1376 
     - transactionId
1377 
     - status
1378 
     - description
5527 anupam.sin 1379 
     - pickUp
1380 
     - orderType
94 ashish 1381 
    """
5527 anupam.sin 1382 
    self.send_changeTransactionStatus(transactionId, status, description, pickUp, orderType)
94 ashish 1383 
    return self.recv_changeTransactionStatus()
1384 
 
5527 anupam.sin 1385 
  def send_changeTransactionStatus(self, transactionId, status, description, pickUp, orderType):
94 ashish 1386 
    self._oprot.writeMessageBegin('changeTransactionStatus', TMessageType.CALL, self._seqid)
1387 
    args = changeTransactionStatus_args()
1388 
    args.transactionId = transactionId
1389 
    args.status = status
1390 
    args.description = description
5527 anupam.sin 1391 
    args.pickUp = pickUp
1392 
    args.orderType = orderType
94 ashish 1393 
    args.write(self._oprot)
1394 
    self._oprot.writeMessageEnd()
1395 
    self._oprot.trans.flush()
1396 
 
1397 
  def recv_changeTransactionStatus(self, ):
1398 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1399 
    if mtype == TMessageType.EXCEPTION:
1400 
      x = TApplicationException()
1401 
      x.read(self._iprot)
1402 
      self._iprot.readMessageEnd()
1403 
      raise x
1404 
    result = changeTransactionStatus_result()
1405 
    result.read(self._iprot)
1406 
    self._iprot.readMessageEnd()
3431 rajveer 1407 
    if result.success is not None:
94 ashish 1408 
      return result.success
3431 rajveer 1409 
    if result.ex is not None:
94 ashish 1410 
      raise result.ex
1411 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "changeTransactionStatus failed: unknown result");
1412 
 
1398 varun.gupt 1413 
  def enqueueTransactionInfoEmail(self, transactionId):
1382 varun.gupt 1414 
    """
1415 
    Parameters:
1416 
     - transactionId
1417 
    """
1398 varun.gupt 1418 
    self.send_enqueueTransactionInfoEmail(transactionId)
1419 
    return self.recv_enqueueTransactionInfoEmail()
1382 varun.gupt 1420 
 
1398 varun.gupt 1421 
  def send_enqueueTransactionInfoEmail(self, transactionId):
1422 
    self._oprot.writeMessageBegin('enqueueTransactionInfoEmail', TMessageType.CALL, self._seqid)
1423 
    args = enqueueTransactionInfoEmail_args()
1382 varun.gupt 1424 
    args.transactionId = transactionId
1425 
    args.write(self._oprot)
1426 
    self._oprot.writeMessageEnd()
1427 
    self._oprot.trans.flush()
1428 
 
1398 varun.gupt 1429 
  def recv_enqueueTransactionInfoEmail(self, ):
1382 varun.gupt 1430 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1431 
    if mtype == TMessageType.EXCEPTION:
1432 
      x = TApplicationException()
1433 
      x.read(self._iprot)
1434 
      self._iprot.readMessageEnd()
1435 
      raise x
1398 varun.gupt 1436 
    result = enqueueTransactionInfoEmail_result()
1382 varun.gupt 1437 
    result.read(self._iprot)
1438 
    self._iprot.readMessageEnd()
3431 rajveer 1439 
    if result.success is not None:
1382 varun.gupt 1440 
      return result.success
3431 rajveer 1441 
    if result.ex is not None:
1382 varun.gupt 1442 
      raise result.ex
1398 varun.gupt 1443 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "enqueueTransactionInfoEmail failed: unknown result");
1382 varun.gupt 1444 
 
4801 anupam.sin 1445 
  def getAllOrders(self, statuses, from_date, to_date, warehouse_id):
94 ashish 1446 
    """
1447 
    Parameters:
4801 anupam.sin 1448 
     - statuses
483 rajveer 1449 
     - from_date
1450 
     - to_date
1451 
     - warehouse_id
94 ashish 1452 
    """
4801 anupam.sin 1453 
    self.send_getAllOrders(statuses, from_date, to_date, warehouse_id)
483 rajveer 1454 
    return self.recv_getAllOrders()
94 ashish 1455 
 
4801 anupam.sin 1456 
  def send_getAllOrders(self, statuses, from_date, to_date, warehouse_id):
483 rajveer 1457 
    self._oprot.writeMessageBegin('getAllOrders', TMessageType.CALL, self._seqid)
1458 
    args = getAllOrders_args()
4801 anupam.sin 1459 
    args.statuses = statuses
483 rajveer 1460 
    args.from_date = from_date
1461 
    args.to_date = to_date
1462 
    args.warehouse_id = warehouse_id
94 ashish 1463 
    args.write(self._oprot)
1464 
    self._oprot.writeMessageEnd()
1465 
    self._oprot.trans.flush()
1466 
 
483 rajveer 1467 
  def recv_getAllOrders(self, ):
94 ashish 1468 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1469 
    if mtype == TMessageType.EXCEPTION:
1470 
      x = TApplicationException()
1471 
      x.read(self._iprot)
1472 
      self._iprot.readMessageEnd()
1473 
      raise x
483 rajveer 1474 
    result = getAllOrders_result()
94 ashish 1475 
    result.read(self._iprot)
1476 
    self._iprot.readMessageEnd()
3431 rajveer 1477 
    if result.success is not None:
94 ashish 1478 
      return result.success
3431 rajveer 1479 
    if result.ex is not None:
94 ashish 1480 
      raise result.ex
483 rajveer 1481 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAllOrders failed: unknown result");
94 ashish 1482 
 
4133 chandransh 1483 
  def getOrdersInBatch(self, statuses, offset, limit, warehouse_id):
1484 
    """
1485 
    Returns at most 'limit' orders with the given statuses for the given warehouse starting from the given offset.
1486 
    Pass the status as null and the limit as 0 to ignore them.
1487 
 
1488 
    Parameters:
1489 
     - statuses
1490 
     - offset
1491 
     - limit
1492 
     - warehouse_id
1493 
    """
1494 
    self.send_getOrdersInBatch(statuses, offset, limit, warehouse_id)
1495 
    return self.recv_getOrdersInBatch()
1496 
 
1497 
  def send_getOrdersInBatch(self, statuses, offset, limit, warehouse_id):
1498 
    self._oprot.writeMessageBegin('getOrdersInBatch', TMessageType.CALL, self._seqid)
1499 
    args = getOrdersInBatch_args()
1500 
    args.statuses = statuses
1501 
    args.offset = offset
1502 
    args.limit = limit
1503 
    args.warehouse_id = warehouse_id
1504 
    args.write(self._oprot)
1505 
    self._oprot.writeMessageEnd()
1506 
    self._oprot.trans.flush()
1507 
 
1508 
  def recv_getOrdersInBatch(self, ):
1509 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1510 
    if mtype == TMessageType.EXCEPTION:
1511 
      x = TApplicationException()
1512 
      x.read(self._iprot)
1513 
      self._iprot.readMessageEnd()
1514 
      raise x
1515 
    result = getOrdersInBatch_result()
1516 
    result.read(self._iprot)
1517 
    self._iprot.readMessageEnd()
1518 
    if result.success is not None:
1519 
      return result.success
1520 
    if result.ex is not None:
1521 
      raise result.ex
1522 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getOrdersInBatch failed: unknown result");
1523 
 
1524 
  def getOrderCount(self, statuses, warehouseId):
1525 
    """
1526 
    Returns the count of orders with the given statuses assigned to the given warehouse.
1527 
 
1528 
    Parameters:
1529 
     - statuses
1530 
     - warehouseId
1531 
    """
1532 
    self.send_getOrderCount(statuses, warehouseId)
1533 
    return self.recv_getOrderCount()
1534 
 
1535 
  def send_getOrderCount(self, statuses, warehouseId):
1536 
    self._oprot.writeMessageBegin('getOrderCount', TMessageType.CALL, self._seqid)
1537 
    args = getOrderCount_args()
1538 
    args.statuses = statuses
1539 
    args.warehouseId = warehouseId
1540 
    args.write(self._oprot)
1541 
    self._oprot.writeMessageEnd()
1542 
    self._oprot.trans.flush()
1543 
 
1544 
  def recv_getOrderCount(self, ):
1545 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1546 
    if mtype == TMessageType.EXCEPTION:
1547 
      x = TApplicationException()
1548 
      x.read(self._iprot)
1549 
      self._iprot.readMessageEnd()
1550 
      raise x
1551 
    result = getOrderCount_result()
1552 
    result.read(self._iprot)
1553 
    self._iprot.readMessageEnd()
1554 
    if result.success is not None:
1555 
      return result.success
1556 
    if result.ex is not None:
1557 
      raise result.ex
1558 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getOrderCount failed: unknown result");
1559 
 
999 varun.gupt 1560 
  def getOrdersByBillingDate(self, status, start_billing_date, end_billing_date, warehouse_id):
1561 
    """
1132 chandransh 1562 
    Returns orders within a range of their billing dates
3431 rajveer 1563 
 
999 varun.gupt 1564 
    Parameters:
1565 
     - status
1566 
     - start_billing_date
1567 
     - end_billing_date
1568 
     - warehouse_id
1569 
    """
1570 
    self.send_getOrdersByBillingDate(status, start_billing_date, end_billing_date, warehouse_id)
1571 
    return self.recv_getOrdersByBillingDate()
1572 
 
1573 
  def send_getOrdersByBillingDate(self, status, start_billing_date, end_billing_date, warehouse_id):
1574 
    self._oprot.writeMessageBegin('getOrdersByBillingDate', TMessageType.CALL, self._seqid)
1575 
    args = getOrdersByBillingDate_args()
1576 
    args.status = status
1577 
    args.start_billing_date = start_billing_date
1578 
    args.end_billing_date = end_billing_date
1579 
    args.warehouse_id = warehouse_id
1580 
    args.write(self._oprot)
1581 
    self._oprot.writeMessageEnd()
1582 
    self._oprot.trans.flush()
1583 
 
1584 
  def recv_getOrdersByBillingDate(self, ):
1585 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1586 
    if mtype == TMessageType.EXCEPTION:
1587 
      x = TApplicationException()
1588 
      x.read(self._iprot)
1589 
      self._iprot.readMessageEnd()
1590 
      raise x
1591 
    result = getOrdersByBillingDate_result()
1592 
    result.read(self._iprot)
1593 
    self._iprot.readMessageEnd()
3431 rajveer 1594 
    if result.success is not None:
999 varun.gupt 1595 
      return result.success
3431 rajveer 1596 
    if result.ex is not None:
999 varun.gupt 1597 
      raise result.ex
1598 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getOrdersByBillingDate failed: unknown result");
1599 
 
3451 chandransh 1600 
  def getOrdersByShippingDate(self, fromShippingDate, toShippingDate, providerId, warehouseId, cod):
3427 chandransh 1601 
    """
1602 
    Returns orders for a particular provider and warehouse which were shipped between the given dates.
3451 chandransh 1603 
    Returned orders comprise of COD orders if cod parameter is true. It comprises of prepaid orders otherwise.
1604 
    Pass providerId and warehouseId as -1 to ignore both these parameters.
3431 rajveer 1605 
 
3427 chandransh 1606 
    Parameters:
1607 
     - fromShippingDate
1608 
     - toShippingDate
1609 
     - providerId
1610 
     - warehouseId
3451 chandransh 1611 
     - cod
3427 chandransh 1612 
    """
3451 chandransh 1613 
    self.send_getOrdersByShippingDate(fromShippingDate, toShippingDate, providerId, warehouseId, cod)
3427 chandransh 1614 
    return self.recv_getOrdersByShippingDate()
1615 
 
3451 chandransh 1616 
  def send_getOrdersByShippingDate(self, fromShippingDate, toShippingDate, providerId, warehouseId, cod):
3427 chandransh 1617 
    self._oprot.writeMessageBegin('getOrdersByShippingDate', TMessageType.CALL, self._seqid)
1618 
    args = getOrdersByShippingDate_args()
1619 
    args.fromShippingDate = fromShippingDate
1620 
    args.toShippingDate = toShippingDate
1621 
    args.providerId = providerId
1622 
    args.warehouseId = warehouseId
3451 chandransh 1623 
    args.cod = cod
3427 chandransh 1624 
    args.write(self._oprot)
1625 
    self._oprot.writeMessageEnd()
1626 
    self._oprot.trans.flush()
1627 
 
1628 
  def recv_getOrdersByShippingDate(self, ):
1629 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1630 
    if mtype == TMessageType.EXCEPTION:
1631 
      x = TApplicationException()
1632 
      x.read(self._iprot)
1633 
      self._iprot.readMessageEnd()
1634 
      raise x
1635 
    result = getOrdersByShippingDate_result()
1636 
    result.read(self._iprot)
1637 
    self._iprot.readMessageEnd()
3431 rajveer 1638 
    if result.success is not None:
3427 chandransh 1639 
      return result.success
3431 rajveer 1640 
    if result.ex is not None:
3427 chandransh 1641 
      raise result.ex
1642 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getOrdersByShippingDate failed: unknown result");
1643 
 
1382 varun.gupt 1644 
  def getReturnableOrdersForCustomer(self, customer_id, limit):
1645 
    """
1646 
    Returns order ids for orders which can be returned
3431 rajveer 1647 
 
1382 varun.gupt 1648 
    Parameters:
1649 
     - customer_id
1650 
     - limit
1651 
    """
1652 
    self.send_getReturnableOrdersForCustomer(customer_id, limit)
1653 
    return self.recv_getReturnableOrdersForCustomer()
1654 
 
1655 
  def send_getReturnableOrdersForCustomer(self, customer_id, limit):
1656 
    self._oprot.writeMessageBegin('getReturnableOrdersForCustomer', TMessageType.CALL, self._seqid)
1657 
    args = getReturnableOrdersForCustomer_args()
1658 
    args.customer_id = customer_id
1659 
    args.limit = limit
1660 
    args.write(self._oprot)
1661 
    self._oprot.writeMessageEnd()
1662 
    self._oprot.trans.flush()
1663 
 
1664 
  def recv_getReturnableOrdersForCustomer(self, ):
1665 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1666 
    if mtype == TMessageType.EXCEPTION:
1667 
      x = TApplicationException()
1668 
      x.read(self._iprot)
1669 
      self._iprot.readMessageEnd()
1670 
      raise x
1671 
    result = getReturnableOrdersForCustomer_result()
1672 
    result.read(self._iprot)
1673 
    self._iprot.readMessageEnd()
3431 rajveer 1674 
    if result.success is not None:
1382 varun.gupt 1675 
      return result.success
3431 rajveer 1676 
    if result.ex is not None:
1382 varun.gupt 1677 
      raise result.ex
1678 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getReturnableOrdersForCustomer failed: unknown result");
1679 
 
1680 
  def getCancellableOrdersForCustomer(self, customer_id, limit):
1681 
    """
1682 
    Returns order ids for orders which can be cancelled
3431 rajveer 1683 
 
1382 varun.gupt 1684 
    Parameters:
1685 
     - customer_id
1686 
     - limit
1687 
    """
1688 
    self.send_getCancellableOrdersForCustomer(customer_id, limit)
1689 
    return self.recv_getCancellableOrdersForCustomer()
1690 
 
1691 
  def send_getCancellableOrdersForCustomer(self, customer_id, limit):
1692 
    self._oprot.writeMessageBegin('getCancellableOrdersForCustomer', TMessageType.CALL, self._seqid)
1693 
    args = getCancellableOrdersForCustomer_args()
1694 
    args.customer_id = customer_id
1695 
    args.limit = limit
1696 
    args.write(self._oprot)
1697 
    self._oprot.writeMessageEnd()
1698 
    self._oprot.trans.flush()
1699 
 
1700 
  def recv_getCancellableOrdersForCustomer(self, ):
1701 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1702 
    if mtype == TMessageType.EXCEPTION:
1703 
      x = TApplicationException()
1704 
      x.read(self._iprot)
1705 
      self._iprot.readMessageEnd()
1706 
      raise x
1707 
    result = getCancellableOrdersForCustomer_result()
1708 
    result.read(self._iprot)
1709 
    self._iprot.readMessageEnd()
3431 rajveer 1710 
    if result.success is not None:
1382 varun.gupt 1711 
      return result.success
3431 rajveer 1712 
    if result.ex is not None:
1382 varun.gupt 1713 
      raise result.ex
1714 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getCancellableOrdersForCustomer failed: unknown result");
1715 
 
483 rajveer 1716 
  def changeOrderStatus(self, orderId, status, description):
94 ashish 1717 
    """
1718 
    Parameters:
483 rajveer 1719 
     - orderId
1720 
     - status
1721 
     - description
94 ashish 1722 
    """
483 rajveer 1723 
    self.send_changeOrderStatus(orderId, status, description)
1724 
    return self.recv_changeOrderStatus()
94 ashish 1725 
 
483 rajveer 1726 
  def send_changeOrderStatus(self, orderId, status, description):
1727 
    self._oprot.writeMessageBegin('changeOrderStatus', TMessageType.CALL, self._seqid)
1728 
    args = changeOrderStatus_args()
1729 
    args.orderId = orderId
1730 
    args.status = status
1731 
    args.description = description
94 ashish 1732 
    args.write(self._oprot)
1733 
    self._oprot.writeMessageEnd()
1734 
    self._oprot.trans.flush()
1735 
 
483 rajveer 1736 
  def recv_changeOrderStatus(self, ):
94 ashish 1737 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1738 
    if mtype == TMessageType.EXCEPTION:
1739 
      x = TApplicationException()
1740 
      x.read(self._iprot)
1741 
      self._iprot.readMessageEnd()
1742 
      raise x
483 rajveer 1743 
    result = changeOrderStatus_result()
94 ashish 1744 
    result.read(self._iprot)
1745 
    self._iprot.readMessageEnd()
3431 rajveer 1746 
    if result.success is not None:
94 ashish 1747 
      return result.success
3431 rajveer 1748 
    if result.ex is not None:
94 ashish 1749 
      raise result.ex
483 rajveer 1750 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "changeOrderStatus failed: unknown result");
94 ashish 1751 
 
1528 ankur.sing 1752 
  def getOrdersForTransaction(self, transactionId, customerId):
94 ashish 1753 
    """
1528 ankur.sing 1754 
    Returns list of orders for given transaction Id. Also filters based on customer Id so that
1755 
    only user who owns the transaction can view its order details.
3431 rajveer 1756 
 
94 ashish 1757 
    Parameters:
1758 
     - transactionId
1528 ankur.sing 1759 
     - customerId
94 ashish 1760 
    """
1528 ankur.sing 1761 
    self.send_getOrdersForTransaction(transactionId, customerId)
483 rajveer 1762 
    return self.recv_getOrdersForTransaction()
94 ashish 1763 
 
1528 ankur.sing 1764 
  def send_getOrdersForTransaction(self, transactionId, customerId):
483 rajveer 1765 
    self._oprot.writeMessageBegin('getOrdersForTransaction', TMessageType.CALL, self._seqid)
1766 
    args = getOrdersForTransaction_args()
94 ashish 1767 
    args.transactionId = transactionId
1528 ankur.sing 1768 
    args.customerId = customerId
94 ashish 1769 
    args.write(self._oprot)
1770 
    self._oprot.writeMessageEnd()
1771 
    self._oprot.trans.flush()
1772 
 
483 rajveer 1773 
  def recv_getOrdersForTransaction(self, ):
94 ashish 1774 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1775 
    if mtype == TMessageType.EXCEPTION:
1776 
      x = TApplicationException()
1777 
      x.read(self._iprot)
1778 
      self._iprot.readMessageEnd()
1779 
      raise x
483 rajveer 1780 
    result = getOrdersForTransaction_result()
94 ashish 1781 
    result.read(self._iprot)
1782 
    self._iprot.readMessageEnd()
3431 rajveer 1783 
    if result.success is not None:
94 ashish 1784 
      return result.success
3431 rajveer 1785 
    if result.ex is not None:
94 ashish 1786 
      raise result.ex
483 rajveer 1787 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getOrdersForTransaction failed: unknown result");
94 ashish 1788 
 
3014 chandransh 1789 
  def getOrdersForCustomer(self, customerId, from_date, to_date, statuses):
94 ashish 1790 
    """
3014 chandransh 1791 
    Returns list of orders for the given customer created between the given dates and having the given statuses.
1792 
    Pass and empty list to ignore filtering on statuses.
3431 rajveer 1793 
 
94 ashish 1794 
    Parameters:
483 rajveer 1795 
     - customerId
1796 
     - from_date
1797 
     - to_date
3014 chandransh 1798 
     - statuses
94 ashish 1799 
    """
3014 chandransh 1800 
    self.send_getOrdersForCustomer(customerId, from_date, to_date, statuses)
483 rajveer 1801 
    return self.recv_getOrdersForCustomer()
94 ashish 1802 
 
3014 chandransh 1803 
  def send_getOrdersForCustomer(self, customerId, from_date, to_date, statuses):
483 rajveer 1804 
    self._oprot.writeMessageBegin('getOrdersForCustomer', TMessageType.CALL, self._seqid)
1805 
    args = getOrdersForCustomer_args()
1806 
    args.customerId = customerId
1807 
    args.from_date = from_date
1808 
    args.to_date = to_date
3014 chandransh 1809 
    args.statuses = statuses
94 ashish 1810 
    args.write(self._oprot)
1811 
    self._oprot.writeMessageEnd()
1812 
    self._oprot.trans.flush()
1813 
 
483 rajveer 1814 
  def recv_getOrdersForCustomer(self, ):
94 ashish 1815 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1816 
    if mtype == TMessageType.EXCEPTION:
1817 
      x = TApplicationException()
1818 
      x.read(self._iprot)
1819 
      self._iprot.readMessageEnd()
1820 
      raise x
483 rajveer 1821 
    result = getOrdersForCustomer_result()
94 ashish 1822 
    result.read(self._iprot)
1823 
    self._iprot.readMessageEnd()
3431 rajveer 1824 
    if result.success is not None:
94 ashish 1825 
      return result.success
3431 rajveer 1826 
    if result.ex is not None:
94 ashish 1827 
      raise result.ex
483 rajveer 1828 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getOrdersForCustomer failed: unknown result");
94 ashish 1829 
 
483 rajveer 1830 
  def createOrder(self, order):
94 ashish 1831 
    """
1832 
    Parameters:
483 rajveer 1833 
     - order
94 ashish 1834 
    """
483 rajveer 1835 
    self.send_createOrder(order)
1836 
    return self.recv_createOrder()
94 ashish 1837 
 
483 rajveer 1838 
  def send_createOrder(self, order):
1839 
    self._oprot.writeMessageBegin('createOrder', TMessageType.CALL, self._seqid)
1840 
    args = createOrder_args()
1841 
    args.order = order
94 ashish 1842 
    args.write(self._oprot)
1843 
    self._oprot.writeMessageEnd()
1844 
    self._oprot.trans.flush()
1845 
 
483 rajveer 1846 
  def recv_createOrder(self, ):
94 ashish 1847 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1848 
    if mtype == TMessageType.EXCEPTION:
1849 
      x = TApplicationException()
1850 
      x.read(self._iprot)
1851 
      self._iprot.readMessageEnd()
1852 
      raise x
483 rajveer 1853 
    result = createOrder_result()
94 ashish 1854 
    result.read(self._iprot)
1855 
    self._iprot.readMessageEnd()
3431 rajveer 1856 
    if result.success is not None:
94 ashish 1857 
      return result.success
3431 rajveer 1858 
    if result.ex is not None:
94 ashish 1859 
      raise result.ex
483 rajveer 1860 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "createOrder failed: unknown result");
94 ashish 1861 
 
483 rajveer 1862 
  def getOrder(self, id):
94 ashish 1863 
    """
1864 
    Parameters:
483 rajveer 1865 
     - id
94 ashish 1866 
    """
483 rajveer 1867 
    self.send_getOrder(id)
1868 
    return self.recv_getOrder()
94 ashish 1869 
 
483 rajveer 1870 
  def send_getOrder(self, id):
1871 
    self._oprot.writeMessageBegin('getOrder', TMessageType.CALL, self._seqid)
1872 
    args = getOrder_args()
1873 
    args.id = id
94 ashish 1874 
    args.write(self._oprot)
1875 
    self._oprot.writeMessageEnd()
1876 
    self._oprot.trans.flush()
1877 
 
483 rajveer 1878 
  def recv_getOrder(self, ):
94 ashish 1879 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1880 
    if mtype == TMessageType.EXCEPTION:
1881 
      x = TApplicationException()
1882 
      x.read(self._iprot)
1883 
      self._iprot.readMessageEnd()
1884 
      raise x
483 rajveer 1885 
    result = getOrder_result()
94 ashish 1886 
    result.read(self._iprot)
1887 
    self._iprot.readMessageEnd()
3431 rajveer 1888 
    if result.success is not None:
94 ashish 1889 
      return result.success
3431 rajveer 1890 
    if result.ex is not None:
94 ashish 1891 
      raise result.ex
483 rajveer 1892 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getOrder failed: unknown result");
94 ashish 1893 
 
483 rajveer 1894 
  def getLineItemsForOrder(self, orderId):
94 ashish 1895 
    """
1896 
    Parameters:
483 rajveer 1897 
     - orderId
94 ashish 1898 
    """
483 rajveer 1899 
    self.send_getLineItemsForOrder(orderId)
1900 
    return self.recv_getLineItemsForOrder()
94 ashish 1901 
 
483 rajveer 1902 
  def send_getLineItemsForOrder(self, orderId):
1903 
    self._oprot.writeMessageBegin('getLineItemsForOrder', TMessageType.CALL, self._seqid)
1904 
    args = getLineItemsForOrder_args()
1905 
    args.orderId = orderId
94 ashish 1906 
    args.write(self._oprot)
1907 
    self._oprot.writeMessageEnd()
1908 
    self._oprot.trans.flush()
1909 
 
483 rajveer 1910 
  def recv_getLineItemsForOrder(self, ):
94 ashish 1911 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1912 
    if mtype == TMessageType.EXCEPTION:
1913 
      x = TApplicationException()
1914 
      x.read(self._iprot)
1915 
      self._iprot.readMessageEnd()
1916 
      raise x
483 rajveer 1917 
    result = getLineItemsForOrder_result()
94 ashish 1918 
    result.read(self._iprot)
1919 
    self._iprot.readMessageEnd()
3431 rajveer 1920 
    if result.success is not None:
94 ashish 1921 
      return result.success
3431 rajveer 1922 
    if result.ex is not None:
94 ashish 1923 
      raise result.ex
483 rajveer 1924 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getLineItemsForOrder failed: unknown result");
94 ashish 1925 
 
4999 phani.kuma 1926 
  def getOrderList(self, order_ids):
1927 
    """
1928 
    Parameters:
1929 
     - order_ids
1930 
    """
1931 
    self.send_getOrderList(order_ids)
1932 
    return self.recv_getOrderList()
1933 
 
1934 
  def send_getOrderList(self, order_ids):
1935 
    self._oprot.writeMessageBegin('getOrderList', TMessageType.CALL, self._seqid)
1936 
    args = getOrderList_args()
1937 
    args.order_ids = order_ids
1938 
    args.write(self._oprot)
1939 
    self._oprot.writeMessageEnd()
1940 
    self._oprot.trans.flush()
1941 
 
1942 
  def recv_getOrderList(self, ):
1943 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1944 
    if mtype == TMessageType.EXCEPTION:
1945 
      x = TApplicationException()
1946 
      x.read(self._iprot)
1947 
      self._iprot.readMessageEnd()
1948 
      raise x
1949 
    result = getOrderList_result()
1950 
    result.read(self._iprot)
1951 
    self._iprot.readMessageEnd()
1952 
    if result.success is not None:
1953 
      return result.success
1954 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getOrderList failed: unknown result");
1955 
 
5386 phani.kuma 1956 
  def getOrderListForVendor(self, order_ids, vendorId):
1957 
    """
1958 
    Parameters:
1959 
     - order_ids
1960 
     - vendorId
1961 
    """
1962 
    self.send_getOrderListForVendor(order_ids, vendorId)
1963 
    return self.recv_getOrderListForVendor()
1964 
 
1965 
  def send_getOrderListForVendor(self, order_ids, vendorId):
1966 
    self._oprot.writeMessageBegin('getOrderListForVendor', TMessageType.CALL, self._seqid)
1967 
    args = getOrderListForVendor_args()
1968 
    args.order_ids = order_ids
1969 
    args.vendorId = vendorId
1970 
    args.write(self._oprot)
1971 
    self._oprot.writeMessageEnd()
1972 
    self._oprot.trans.flush()
1973 
 
1974 
  def recv_getOrderListForVendor(self, ):
1975 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1976 
    if mtype == TMessageType.EXCEPTION:
1977 
      x = TApplicationException()
1978 
      x.read(self._iprot)
1979 
      self._iprot.readMessageEnd()
1980 
      raise x
1981 
    result = getOrderListForVendor_result()
1982 
    result.read(self._iprot)
1983 
    self._iprot.readMessageEnd()
1984 
    if result.success is not None:
1985 
      return result.success
1986 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getOrderListForVendor failed: unknown result");
1987 
 
1528 ankur.sing 1988 
  def getOrderForCustomer(self, orderId, customerId):
1989 
    """
1990 
    Returns an order for the order Id. Also checks if the order belongs to the customer whose Id is passed.
1991 
    Throws exception if either order Id is invalid or order does not below to the customer whose Id is passed.
3431 rajveer 1992 
 
1528 ankur.sing 1993 
    Parameters:
1994 
     - orderId
1995 
     - customerId
1996 
    """
1997 
    self.send_getOrderForCustomer(orderId, customerId)
1998 
    return self.recv_getOrderForCustomer()
1999 
 
2000 
  def send_getOrderForCustomer(self, orderId, customerId):
2001 
    self._oprot.writeMessageBegin('getOrderForCustomer', TMessageType.CALL, self._seqid)
2002 
    args = getOrderForCustomer_args()
2003 
    args.orderId = orderId
2004 
    args.customerId = customerId
2005 
    args.write(self._oprot)
2006 
    self._oprot.writeMessageEnd()
2007 
    self._oprot.trans.flush()
2008 
 
2009 
  def recv_getOrderForCustomer(self, ):
2010 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2011 
    if mtype == TMessageType.EXCEPTION:
2012 
      x = TApplicationException()
2013 
      x.read(self._iprot)
2014 
      self._iprot.readMessageEnd()
2015 
      raise x
2016 
    result = getOrderForCustomer_result()
2017 
    result.read(self._iprot)
2018 
    self._iprot.readMessageEnd()
3431 rajveer 2019 
    if result.success is not None:
1528 ankur.sing 2020 
      return result.success
3431 rajveer 2021 
    if result.ex is not None:
1528 ankur.sing 2022 
      raise result.ex
2023 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getOrderForCustomer failed: unknown result");
2024 
 
4444 rajveer 2025 
  def getAlerts(self, type, warehouseId, status, timestamp):
3064 chandransh 2026 
    """
2027 
    Parameters:
4394 rajveer 2028 
     - type
4444 rajveer 2029 
     - warehouseId
4394 rajveer 2030 
     - status
2031 
     - timestamp
3064 chandransh 2032 
    """
4444 rajveer 2033 
    self.send_getAlerts(type, warehouseId, status, timestamp)
3064 chandransh 2034 
    return self.recv_getAlerts()
2035 
 
4444 rajveer 2036 
  def send_getAlerts(self, type, warehouseId, status, timestamp):
3064 chandransh 2037 
    self._oprot.writeMessageBegin('getAlerts', TMessageType.CALL, self._seqid)
2038 
    args = getAlerts_args()
4394 rajveer 2039 
    args.type = type
4444 rajveer 2040 
    args.warehouseId = warehouseId
4394 rajveer 2041 
    args.status = status
2042 
    args.timestamp = timestamp
3064 chandransh 2043 
    args.write(self._oprot)
2044 
    self._oprot.writeMessageEnd()
2045 
    self._oprot.trans.flush()
2046 
 
2047 
  def recv_getAlerts(self, ):
2048 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2049 
    if mtype == TMessageType.EXCEPTION:
2050 
      x = TApplicationException()
2051 
      x.read(self._iprot)
2052 
      self._iprot.readMessageEnd()
2053 
      raise x
2054 
    result = getAlerts_result()
2055 
    result.read(self._iprot)
2056 
    self._iprot.readMessageEnd()
3431 rajveer 2057 
    if result.success is not None:
3064 chandransh 2058 
      return result.success
2059 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAlerts failed: unknown result");
2060 
 
4444 rajveer 2061 
  def addAlert(self, type, warehouseId, description):
3064 chandransh 2062 
    """
2063 
    Parameters:
2064 
     - type
4444 rajveer 2065 
     - warehouseId
4394 rajveer 2066 
     - description
3064 chandransh 2067 
    """
4444 rajveer 2068 
    self.send_addAlert(type, warehouseId, description)
4394 rajveer 2069 
    self.recv_addAlert()
3064 chandransh 2070 
 
4444 rajveer 2071 
  def send_addAlert(self, type, warehouseId, description):
4394 rajveer 2072 
    self._oprot.writeMessageBegin('addAlert', TMessageType.CALL, self._seqid)
2073 
    args = addAlert_args()
3064 chandransh 2074 
    args.type = type
4444 rajveer 2075 
    args.warehouseId = warehouseId
4394 rajveer 2076 
    args.description = description
3064 chandransh 2077 
    args.write(self._oprot)
2078 
    self._oprot.writeMessageEnd()
2079 
    self._oprot.trans.flush()
2080 
 
4394 rajveer 2081 
  def recv_addAlert(self, ):
3064 chandransh 2082 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2083 
    if mtype == TMessageType.EXCEPTION:
2084 
      x = TApplicationException()
2085 
      x.read(self._iprot)
2086 
      self._iprot.readMessageEnd()
2087 
      raise x
4394 rajveer 2088 
    result = addAlert_result()
3064 chandransh 2089 
    result.read(self._iprot)
2090 
    self._iprot.readMessageEnd()
2091 
    return
2092 
 
4444 rajveer 2093 
  def markAlertsAsSeen(self, warehouseId):
2094 
    """
2095 
    Parameters:
2096 
     - warehouseId
2097 
    """
2098 
    self.send_markAlertsAsSeen(warehouseId)
2099 
    self.recv_markAlertsAsSeen()
2100 
 
2101 
  def send_markAlertsAsSeen(self, warehouseId):
2102 
    self._oprot.writeMessageBegin('markAlertsAsSeen', TMessageType.CALL, self._seqid)
2103 
    args = markAlertsAsSeen_args()
2104 
    args.warehouseId = warehouseId
2105 
    args.write(self._oprot)
2106 
    self._oprot.writeMessageEnd()
2107 
    self._oprot.trans.flush()
2108 
 
2109 
  def recv_markAlertsAsSeen(self, ):
2110 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2111 
    if mtype == TMessageType.EXCEPTION:
2112 
      x = TApplicationException()
2113 
      x.read(self._iprot)
2114 
      self._iprot.readMessageEnd()
2115 
      raise x
2116 
    result = markAlertsAsSeen_result()
2117 
    result.read(self._iprot)
2118 
    self._iprot.readMessageEnd()
2119 
    return
2120 
 
3064 chandransh 2121 
  def getValidOrderCount(self, ):
2122 
    """
2123 
    Return the number of valid orders. (OrderStatus >= OrderStatus.SUBMITTED_FOR_PROCESSING)
2124 
    """
2125 
    self.send_getValidOrderCount()
2126 
    return self.recv_getValidOrderCount()
2127 
 
2128 
  def send_getValidOrderCount(self, ):
2129 
    self._oprot.writeMessageBegin('getValidOrderCount', TMessageType.CALL, self._seqid)
2130 
    args = getValidOrderCount_args()
2131 
    args.write(self._oprot)
2132 
    self._oprot.writeMessageEnd()
2133 
    self._oprot.trans.flush()
2134 
 
2135 
  def recv_getValidOrderCount(self, ):
2136 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2137 
    if mtype == TMessageType.EXCEPTION:
2138 
      x = TApplicationException()
2139 
      x.read(self._iprot)
2140 
      self._iprot.readMessageEnd()
2141 
      raise x
2142 
    result = getValidOrderCount_result()
2143 
    result.read(self._iprot)
2144 
    self._iprot.readMessageEnd()
3431 rajveer 2145 
    if result.success is not None:
3064 chandransh 2146 
      return result.success
2147 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getValidOrderCount failed: unknown result");
2148 
 
2149 
  def getNoOfCustomersWithSuccessfulTransaction(self, ):
2150 
    """
2151 
    Returns the number of distinct customers who have done successful transactions
2152 
    """
2153 
    self.send_getNoOfCustomersWithSuccessfulTransaction()
2154 
    return self.recv_getNoOfCustomersWithSuccessfulTransaction()
2155 
 
2156 
  def send_getNoOfCustomersWithSuccessfulTransaction(self, ):
2157 
    self._oprot.writeMessageBegin('getNoOfCustomersWithSuccessfulTransaction', TMessageType.CALL, self._seqid)
2158 
    args = getNoOfCustomersWithSuccessfulTransaction_args()
2159 
    args.write(self._oprot)
2160 
    self._oprot.writeMessageEnd()
2161 
    self._oprot.trans.flush()
2162 
 
2163 
  def recv_getNoOfCustomersWithSuccessfulTransaction(self, ):
2164 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2165 
    if mtype == TMessageType.EXCEPTION:
2166 
      x = TApplicationException()
2167 
      x.read(self._iprot)
2168 
      self._iprot.readMessageEnd()
2169 
      raise x
2170 
    result = getNoOfCustomersWithSuccessfulTransaction_result()
2171 
    result.read(self._iprot)
2172 
    self._iprot.readMessageEnd()
3431 rajveer 2173 
    if result.success is not None:
3064 chandransh 2174 
      return result.success
2175 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getNoOfCustomersWithSuccessfulTransaction failed: unknown result");
2176 
 
2177 
  def getValidOrdersAmountRange(self, ):
2178 
    """
2179 
    Returns the minimum and maximum amounts of a valid order. (OrderStatus >= OrderStatus.SUBMITTED_FOR_PROCESSING)
2180 
    List contains two values, first minimum amount and second maximum amount.
2181 
    """
2182 
    self.send_getValidOrdersAmountRange()
2183 
    return self.recv_getValidOrdersAmountRange()
2184 
 
2185 
  def send_getValidOrdersAmountRange(self, ):
2186 
    self._oprot.writeMessageBegin('getValidOrdersAmountRange', TMessageType.CALL, self._seqid)
2187 
    args = getValidOrdersAmountRange_args()
2188 
    args.write(self._oprot)
2189 
    self._oprot.writeMessageEnd()
2190 
    self._oprot.trans.flush()
2191 
 
2192 
  def recv_getValidOrdersAmountRange(self, ):
2193 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2194 
    if mtype == TMessageType.EXCEPTION:
2195 
      x = TApplicationException()
2196 
      x.read(self._iprot)
2197 
      self._iprot.readMessageEnd()
2198 
      raise x
2199 
    result = getValidOrdersAmountRange_result()
2200 
    result.read(self._iprot)
2201 
    self._iprot.readMessageEnd()
3431 rajveer 2202 
    if result.success is not None:
3064 chandransh 2203 
      return result.success
2204 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getValidOrdersAmountRange failed: unknown result");
2205 
 
2206 
  def getValidOrders(self, limit):
2207 
    """
2208 
    Returns list of Orders in descending order by Order creation date. List is restricted to limit Orders.
2209 
    If limit is passed as 0, then all valid Orders are returned.
3431 rajveer 2210 
 
3064 chandransh 2211 
    Parameters:
2212 
     - limit
2213 
    """
2214 
    self.send_getValidOrders(limit)
2215 
    return self.recv_getValidOrders()
2216 
 
2217 
  def send_getValidOrders(self, limit):
2218 
    self._oprot.writeMessageBegin('getValidOrders', TMessageType.CALL, self._seqid)
2219 
    args = getValidOrders_args()
2220 
    args.limit = limit
2221 
    args.write(self._oprot)
2222 
    self._oprot.writeMessageEnd()
2223 
    self._oprot.trans.flush()
2224 
 
2225 
  def recv_getValidOrders(self, ):
2226 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2227 
    if mtype == TMessageType.EXCEPTION:
2228 
      x = TApplicationException()
2229 
      x.read(self._iprot)
2230 
      self._iprot.readMessageEnd()
2231 
      raise x
2232 
    result = getValidOrders_result()
2233 
    result.read(self._iprot)
2234 
    self._iprot.readMessageEnd()
3431 rajveer 2235 
    if result.success is not None:
3064 chandransh 2236 
      return result.success
2237 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getValidOrders failed: unknown result");
2238 
 
1220 chandransh 2239 
  def batchOrders(self, warehouseId):
2240 
    """
2241 
    Create a batch of all the pending orders for the given warehouse.
2242 
    The returned list is orderd by created_timestamp.
2243 
    If there are no pending orders, an empty list is returned.
3431 rajveer 2244 
 
1220 chandransh 2245 
    Parameters:
2246 
     - warehouseId
2247 
    """
2248 
    self.send_batchOrders(warehouseId)
2249 
    return self.recv_batchOrders()
2250 
 
2251 
  def send_batchOrders(self, warehouseId):
2252 
    self._oprot.writeMessageBegin('batchOrders', TMessageType.CALL, self._seqid)
2253 
    args = batchOrders_args()
2254 
    args.warehouseId = warehouseId
2255 
    args.write(self._oprot)
2256 
    self._oprot.writeMessageEnd()
2257 
    self._oprot.trans.flush()
2258 
 
2259 
  def recv_batchOrders(self, ):
2260 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2261 
    if mtype == TMessageType.EXCEPTION:
2262 
      x = TApplicationException()
2263 
      x.read(self._iprot)
2264 
      self._iprot.readMessageEnd()
2265 
      raise x
2266 
    result = batchOrders_result()
2267 
    result.read(self._iprot)
2268 
    self._iprot.readMessageEnd()
3431 rajveer 2269 
    if result.success is not None:
1220 chandransh 2270 
      return result.success
3431 rajveer 2271 
    if result.ex is not None:
1220 chandransh 2272 
      raise result.ex
2273 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "batchOrders failed: unknown result");
2274 
 
1208 chandransh 2275 
  def markOrderAsOutOfStock(self, orderId):
2276 
    """
2277 
    Mark the given order as out of stock. Throws an exception if the order with the given Id couldn't be found.
3431 rajveer 2278 
 
1208 chandransh 2279 
    Parameters:
2280 
     - orderId
2281 
    """
2282 
    self.send_markOrderAsOutOfStock(orderId)
2283 
    return self.recv_markOrderAsOutOfStock()
2284 
 
2285 
  def send_markOrderAsOutOfStock(self, orderId):
2286 
    self._oprot.writeMessageBegin('markOrderAsOutOfStock', TMessageType.CALL, self._seqid)
2287 
    args = markOrderAsOutOfStock_args()
2288 
    args.orderId = orderId
2289 
    args.write(self._oprot)
2290 
    self._oprot.writeMessageEnd()
2291 
    self._oprot.trans.flush()
2292 
 
2293 
  def recv_markOrderAsOutOfStock(self, ):
2294 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2295 
    if mtype == TMessageType.EXCEPTION:
2296 
      x = TApplicationException()
2297 
      x.read(self._iprot)
2298 
      self._iprot.readMessageEnd()
2299 
      raise x
2300 
    result = markOrderAsOutOfStock_result()
2301 
    result.read(self._iprot)
2302 
    self._iprot.readMessageEnd()
3431 rajveer 2303 
    if result.success is not None:
1208 chandransh 2304 
      return result.success
3431 rajveer 2305 
    if result.ex is not None:
1208 chandransh 2306 
      raise result.ex
2307 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "markOrderAsOutOfStock failed: unknown result");
2308 
 
3064 chandransh 2309 
  def verifyOrder(self, orderId):
759 chandransh 2310 
    """
3064 chandransh 2311 
    Marks the given order as SUBMITTED_FOR_PROCESSING and updates the verified
2312 
    timestamp. It is intended to be used for COD orders but can be harmlessly
2313 
    used for all other orders as well.
2314 
    Throws an exception if no such order exists.
3431 rajveer 2315 
 
759 chandransh 2316 
    Parameters:
3064 chandransh 2317 
     - orderId
759 chandransh 2318 
    """
3064 chandransh 2319 
    self.send_verifyOrder(orderId)
2320 
    return self.recv_verifyOrder()
759 chandransh 2321 
 
3064 chandransh 2322 
  def send_verifyOrder(self, orderId):
2323 
    self._oprot.writeMessageBegin('verifyOrder', TMessageType.CALL, self._seqid)
2324 
    args = verifyOrder_args()
2325 
    args.orderId = orderId
759 chandransh 2326 
    args.write(self._oprot)
2327 
    self._oprot.writeMessageEnd()
2328 
    self._oprot.trans.flush()
2329 
 
3064 chandransh 2330 
  def recv_verifyOrder(self, ):
759 chandransh 2331 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2332 
    if mtype == TMessageType.EXCEPTION:
2333 
      x = TApplicationException()
2334 
      x.read(self._iprot)
2335 
      self._iprot.readMessageEnd()
2336 
      raise x
3064 chandransh 2337 
    result = verifyOrder_result()
759 chandransh 2338 
    result.read(self._iprot)
2339 
    self._iprot.readMessageEnd()
3431 rajveer 2340 
    if result.success is not None:
759 chandransh 2341 
      return result.success
3431 rajveer 2342 
    if result.ex is not None:
759 chandransh 2343 
      raise result.ex
3064 chandransh 2344 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "verifyOrder failed: unknown result");
759 chandransh 2345 
 
3064 chandransh 2346 
  def acceptOrder(self, orderId):
1113 chandransh 2347 
    """
3064 chandransh 2348 
    Marks the given order as ACCEPTED and updates the accepted timestamp. If the
2349 
    given order is not a COD order, it also captures the payment if the same has
2350 
    not been captured.
2351 
    Throws an exception if no such order exists.
3431 rajveer 2352 
 
1113 chandransh 2353 
    Parameters:
3064 chandransh 2354 
     - orderId
1113 chandransh 2355 
    """
3064 chandransh 2356 
    self.send_acceptOrder(orderId)
2357 
    return self.recv_acceptOrder()
1113 chandransh 2358 
 
3064 chandransh 2359 
  def send_acceptOrder(self, orderId):
2360 
    self._oprot.writeMessageBegin('acceptOrder', TMessageType.CALL, self._seqid)
2361 
    args = acceptOrder_args()
2362 
    args.orderId = orderId
1113 chandransh 2363 
    args.write(self._oprot)
2364 
    self._oprot.writeMessageEnd()
2365 
    self._oprot.trans.flush()
2366 
 
3064 chandransh 2367 
  def recv_acceptOrder(self, ):
1113 chandransh 2368 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2369 
    if mtype == TMessageType.EXCEPTION:
2370 
      x = TApplicationException()
2371 
      x.read(self._iprot)
2372 
      self._iprot.readMessageEnd()
2373 
      raise x
3064 chandransh 2374 
    result = acceptOrder_result()
1113 chandransh 2375 
    result.read(self._iprot)
2376 
    self._iprot.readMessageEnd()
3431 rajveer 2377 
    if result.success is not None:
1113 chandransh 2378 
      return result.success
3431 rajveer 2379 
    if result.ex is not None:
1113 chandransh 2380 
      raise result.ex
3064 chandransh 2381 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "acceptOrder failed: unknown result");
1113 chandransh 2382 
 
5110 mandeep.dh 2383 
  def addBillingDetails(self, orderId, invoice_number, serialNumber, itemNumber, billed_by, jacketNumber, billingType, fulfilmentWarehouseId, authorize):
1132 chandransh 2384 
    """
3064 chandransh 2385 
    Add billing details such as the bill number and the biller to the Order.
4658 mandeep.dh 2386 
    Adds jacket number, item number and Serial no. to the order. Doesn't update
4283 anupam.sin 2387 
    the IMEI no. if a -1 is supplied.
2388 
    Also, it generates an invoice number for the order, marks the order as
2389 
    BILLED and sets the billing timestamp.
2390 
    Returns false if it doesn't find the order with the given ID.
3431 rajveer 2391 
 
1135 chandransh 2392 
    Parameters:
3064 chandransh 2393 
     - orderId
2394 
     - invoice_number
4658 mandeep.dh 2395 
     - serialNumber
4283 anupam.sin 2396 
     - itemNumber
3064 chandransh 2397 
     - billed_by
4264 rajveer 2398 
     - jacketNumber
4283 anupam.sin 2399 
     - billingType
5110 mandeep.dh 2400 
     - fulfilmentWarehouseId
4763 rajveer 2401 
     - authorize
1135 chandransh 2402 
    """
5110 mandeep.dh 2403 
    self.send_addBillingDetails(orderId, invoice_number, serialNumber, itemNumber, billed_by, jacketNumber, billingType, fulfilmentWarehouseId, authorize)
3064 chandransh 2404 
    return self.recv_addBillingDetails()
1135 chandransh 2405 
 
5110 mandeep.dh 2406 
  def send_addBillingDetails(self, orderId, invoice_number, serialNumber, itemNumber, billed_by, jacketNumber, billingType, fulfilmentWarehouseId, authorize):
3064 chandransh 2407 
    self._oprot.writeMessageBegin('addBillingDetails', TMessageType.CALL, self._seqid)
2408 
    args = addBillingDetails_args()
2409 
    args.orderId = orderId
2410 
    args.invoice_number = invoice_number
4658 mandeep.dh 2411 
    args.serialNumber = serialNumber
4283 anupam.sin 2412 
    args.itemNumber = itemNumber
3064 chandransh 2413 
    args.billed_by = billed_by
4264 rajveer 2414 
    args.jacketNumber = jacketNumber
4283 anupam.sin 2415 
    args.billingType = billingType
5110 mandeep.dh 2416 
    args.fulfilmentWarehouseId = fulfilmentWarehouseId
4763 rajveer 2417 
    args.authorize = authorize
1135 chandransh 2418 
    args.write(self._oprot)
2419 
    self._oprot.writeMessageEnd()
2420 
    self._oprot.trans.flush()
2421 
 
3064 chandransh 2422 
  def recv_addBillingDetails(self, ):
1135 chandransh 2423 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2424 
    if mtype == TMessageType.EXCEPTION:
2425 
      x = TApplicationException()
2426 
      x.read(self._iprot)
2427 
      self._iprot.readMessageEnd()
2428 
      raise x
3064 chandransh 2429 
    result = addBillingDetails_result()
1135 chandransh 2430 
    result.read(self._iprot)
2431 
    self._iprot.readMessageEnd()
3431 rajveer 2432 
    if result.success is not None:
3064 chandransh 2433 
      return result.success
3431 rajveer 2434 
    if result.ex is not None:
1135 chandransh 2435 
      raise result.ex
3064 chandransh 2436 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "addBillingDetails failed: unknown result");
1135 chandransh 2437 
 
4763 rajveer 2438 
  def addInvoiceNumber(self, orderId, invoiceNumber, color):
4579 rajveer 2439 
    """
2440 
    Add the invoice number to the order.
2441 
 
2442 
    Parameters:
2443 
     - orderId
2444 
     - invoiceNumber
4763 rajveer 2445 
     - color
4579 rajveer 2446 
    """
4763 rajveer 2447 
    self.send_addInvoiceNumber(orderId, invoiceNumber, color)
4579 rajveer 2448 
    self.recv_addInvoiceNumber()
2449 
 
4763 rajveer 2450 
  def send_addInvoiceNumber(self, orderId, invoiceNumber, color):
4579 rajveer 2451 
    self._oprot.writeMessageBegin('addInvoiceNumber', TMessageType.CALL, self._seqid)
2452 
    args = addInvoiceNumber_args()
2453 
    args.orderId = orderId
2454 
    args.invoiceNumber = invoiceNumber
4763 rajveer 2455 
    args.color = color
4579 rajveer 2456 
    args.write(self._oprot)
2457 
    self._oprot.writeMessageEnd()
2458 
    self._oprot.trans.flush()
2459 
 
2460 
  def recv_addInvoiceNumber(self, ):
2461 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2462 
    if mtype == TMessageType.EXCEPTION:
2463 
      x = TApplicationException()
2464 
      x.read(self._iprot)
2465 
      self._iprot.readMessageEnd()
2466 
      raise x
2467 
    result = addInvoiceNumber_result()
2468 
    result.read(self._iprot)
2469 
    self._iprot.readMessageEnd()
2470 
    if result.ex is not None:
2471 
      raise result.ex
2472 
    return
2473 
 
4910 phani.kuma 2474 
  def markOrdersAsShippedFromWarehouse(self, warehouseId, providerId, cod, orderIds):
1408 ankur.sing 2475 
    """
3064 chandransh 2476 
    Depending on the third parameter, marks either all prepaid or all cod orders BILLED by the
4910 phani.kuma 2477 
    given warehouse and were picked up by the given provider as SHIPPED_FROM_WH.
3431 rajveer 2478 
 
1408 ankur.sing 2479 
    Parameters:
3064 chandransh 2480 
     - warehouseId
1408 ankur.sing 2481 
     - providerId
3064 chandransh 2482 
     - cod
4910 phani.kuma 2483 
     - orderIds
1408 ankur.sing 2484 
    """
4910 phani.kuma 2485 
    self.send_markOrdersAsShippedFromWarehouse(warehouseId, providerId, cod, orderIds)
2486 
    return self.recv_markOrdersAsShippedFromWarehouse()
1408 ankur.sing 2487 
 
4910 phani.kuma 2488 
  def send_markOrdersAsShippedFromWarehouse(self, warehouseId, providerId, cod, orderIds):
2489 
    self._oprot.writeMessageBegin('markOrdersAsShippedFromWarehouse', TMessageType.CALL, self._seqid)
2490 
    args = markOrdersAsShippedFromWarehouse_args()
3064 chandransh 2491 
    args.warehouseId = warehouseId
1408 ankur.sing 2492 
    args.providerId = providerId
3064 chandransh 2493 
    args.cod = cod
4910 phani.kuma 2494 
    args.orderIds = orderIds
1408 ankur.sing 2495 
    args.write(self._oprot)
2496 
    self._oprot.writeMessageEnd()
2497 
    self._oprot.trans.flush()
2498 
 
4910 phani.kuma 2499 
  def recv_markOrdersAsShippedFromWarehouse(self, ):
1408 ankur.sing 2500 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2501 
    if mtype == TMessageType.EXCEPTION:
2502 
      x = TApplicationException()
2503 
      x.read(self._iprot)
2504 
      self._iprot.readMessageEnd()
2505 
      raise x
4910 phani.kuma 2506 
    result = markOrdersAsShippedFromWarehouse_result()
1408 ankur.sing 2507 
    result.read(self._iprot)
2508 
    self._iprot.readMessageEnd()
3431 rajveer 2509 
    if result.success is not None:
1408 ankur.sing 2510 
      return result.success
3431 rajveer 2511 
    if result.ex is not None:
3064 chandransh 2512 
      raise result.ex
4910 phani.kuma 2513 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "markOrdersAsShippedFromWarehouse failed: unknown result");
1408 ankur.sing 2514 
 
4910 phani.kuma 2515 
  def markOrdersAsPickedUp(self, providerId, pickupDetails):
4410 rajveer 2516 
    """
4910 phani.kuma 2517 
    Marks all SHIPPED_FROM_WH orders of the previous day for a provider as SHIPPED_TO_LOGISTICS.
2518 
    Raises an exception if we encounter report for an AWB number that we did not ship.
4410 rajveer 2519 
 
2520 
    Parameters:
2521 
     - providerId
4910 phani.kuma 2522 
     - pickupDetails
4410 rajveer 2523 
    """
4910 phani.kuma 2524 
    self.send_markOrdersAsPickedUp(providerId, pickupDetails)
2525 
    self.recv_markOrdersAsPickedUp()
4410 rajveer 2526 
 
4910 phani.kuma 2527 
  def send_markOrdersAsPickedUp(self, providerId, pickupDetails):
2528 
    self._oprot.writeMessageBegin('markOrdersAsPickedUp', TMessageType.CALL, self._seqid)
2529 
    args = markOrdersAsPickedUp_args()
4410 rajveer 2530 
    args.providerId = providerId
4910 phani.kuma 2531 
    args.pickupDetails = pickupDetails
4410 rajveer 2532 
    args.write(self._oprot)
2533 
    self._oprot.writeMessageEnd()
2534 
    self._oprot.trans.flush()
2535 
 
4910 phani.kuma 2536 
  def recv_markOrdersAsPickedUp(self, ):
4410 rajveer 2537 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2538 
    if mtype == TMessageType.EXCEPTION:
2539 
      x = TApplicationException()
2540 
      x.read(self._iprot)
2541 
      self._iprot.readMessageEnd()
2542 
      raise x
4910 phani.kuma 2543 
    result = markOrdersAsPickedUp_result()
4410 rajveer 2544 
    result.read(self._iprot)
2545 
    self._iprot.readMessageEnd()
2546 
    if result.ex is not None:
2547 
      raise result.ex
4910 phani.kuma 2548 
    return
4410 rajveer 2549 
 
4910 phani.kuma 2550 
  def getOrdersNotPickedUp(self, providerId):
94 ashish 2551 
    """
3064 chandransh 2552 
    Returns a list of orders that were shipped from warehouse but did not appear in the pick-up report.
3431 rajveer 2553 
 
94 ashish 2554 
    Parameters:
3064 chandransh 2555 
     - providerId
304 ashish 2556 
    """
4910 phani.kuma 2557 
    self.send_getOrdersNotPickedUp(providerId)
2558 
    return self.recv_getOrdersNotPickedUp()
94 ashish 2559 
 
4910 phani.kuma 2560 
  def send_getOrdersNotPickedUp(self, providerId):
2561 
    self._oprot.writeMessageBegin('getOrdersNotPickedUp', TMessageType.CALL, self._seqid)
2562 
    args = getOrdersNotPickedUp_args()
3064 chandransh 2563 
    args.providerId = providerId
304 ashish 2564 
    args.write(self._oprot)
2565 
    self._oprot.writeMessageEnd()
2566 
    self._oprot.trans.flush()
2567 
 
4910 phani.kuma 2568 
  def recv_getOrdersNotPickedUp(self, ):
304 ashish 2569 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2570 
    if mtype == TMessageType.EXCEPTION:
2571 
      x = TApplicationException()
2572 
      x.read(self._iprot)
2573 
      self._iprot.readMessageEnd()
2574 
      raise x
4910 phani.kuma 2575 
    result = getOrdersNotPickedUp_result()
304 ashish 2576 
    result.read(self._iprot)
2577 
    self._iprot.readMessageEnd()
3431 rajveer 2578 
    if result.success is not None:
304 ashish 2579 
      return result.success
4910 phani.kuma 2580 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getOrdersNotPickedUp failed: unknown result");
304 ashish 2581 
 
3064 chandransh 2582 
  def markOrdersAsDelivered(self, providerId, deliveredOrders):
304 ashish 2583 
    """
3064 chandransh 2584 
    Marks all orders with AWBs in the given map as delivered. Also sets the delivery timestamp and
2585 
    the name of the receiver.
2586 
    Raises an exception if we encounter report for an AWB number that we did not ship.
3431 rajveer 2587 
 
304 ashish 2588 
    Parameters:
3064 chandransh 2589 
     - providerId
2590 
     - deliveredOrders
304 ashish 2591 
    """
3064 chandransh 2592 
    self.send_markOrdersAsDelivered(providerId, deliveredOrders)
2593 
    self.recv_markOrdersAsDelivered()
304 ashish 2594 
 
3064 chandransh 2595 
  def send_markOrdersAsDelivered(self, providerId, deliveredOrders):
2596 
    self._oprot.writeMessageBegin('markOrdersAsDelivered', TMessageType.CALL, self._seqid)
2597 
    args = markOrdersAsDelivered_args()
2598 
    args.providerId = providerId
2599 
    args.deliveredOrders = deliveredOrders
304 ashish 2600 
    args.write(self._oprot)
2601 
    self._oprot.writeMessageEnd()
2602 
    self._oprot.trans.flush()
2603 
 
3064 chandransh 2604 
  def recv_markOrdersAsDelivered(self, ):
304 ashish 2605 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2606 
    if mtype == TMessageType.EXCEPTION:
2607 
      x = TApplicationException()
2608 
      x.read(self._iprot)
2609 
      self._iprot.readMessageEnd()
2610 
      raise x
3064 chandransh 2611 
    result = markOrdersAsDelivered_result()
304 ashish 2612 
    result.read(self._iprot)
2613 
    self._iprot.readMessageEnd()
3431 rajveer 2614 
    if result.ex is not None:
3064 chandransh 2615 
      raise result.ex
304 ashish 2616 
    return
2617 
 
4910 phani.kuma 2618 
  def markAsRTOrders(self, providerId, returnedOrders):
1596 ankur.sing 2619 
    """
4910 phani.kuma 2620 
    Mark all orders with AWBs in the given map as RTO. Also sets the delivery timestamp.
3064 chandransh 2621 
    Raises an exception if we encounter report for an AWB number that we did not ship.
3431 rajveer 2622 
 
3064 chandransh 2623 
    Parameters:
2624 
     - providerId
2625 
     - returnedOrders
1596 ankur.sing 2626 
    """
4910 phani.kuma 2627 
    self.send_markAsRTOrders(providerId, returnedOrders)
2628 
    self.recv_markAsRTOrders()
304 ashish 2629 
 
4910 phani.kuma 2630 
  def send_markAsRTOrders(self, providerId, returnedOrders):
2631 
    self._oprot.writeMessageBegin('markAsRTOrders', TMessageType.CALL, self._seqid)
2632 
    args = markAsRTOrders_args()
3064 chandransh 2633 
    args.providerId = providerId
2634 
    args.returnedOrders = returnedOrders
1596 ankur.sing 2635 
    args.write(self._oprot)
2636 
    self._oprot.writeMessageEnd()
2637 
    self._oprot.trans.flush()
2638 
 
4910 phani.kuma 2639 
  def recv_markAsRTOrders(self, ):
1596 ankur.sing 2640 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2641 
    if mtype == TMessageType.EXCEPTION:
2642 
      x = TApplicationException()
2643 
      x.read(self._iprot)
2644 
      self._iprot.readMessageEnd()
2645 
      raise x
4910 phani.kuma 2646 
    result = markAsRTOrders_result()
1596 ankur.sing 2647 
    result.read(self._iprot)
2648 
    self._iprot.readMessageEnd()
3431 rajveer 2649 
    if result.ex is not None:
3064 chandransh 2650 
      raise result.ex
2651 
    return
1596 ankur.sing 2652 
 
4910 phani.kuma 2653 
  def getRTOrders(self, providerId):
2654 
    """
2655 
    Returns a list of orders that were returned by courier.
2656 
 
2657 
    Parameters:
2658 
     - providerId
2659 
    """
2660 
    self.send_getRTOrders(providerId)
2661 
    return self.recv_getRTOrders()
2662 
 
2663 
  def send_getRTOrders(self, providerId):
2664 
    self._oprot.writeMessageBegin('getRTOrders', TMessageType.CALL, self._seqid)
2665 
    args = getRTOrders_args()
2666 
    args.providerId = providerId
2667 
    args.write(self._oprot)
2668 
    self._oprot.writeMessageEnd()
2669 
    self._oprot.trans.flush()
2670 
 
2671 
  def recv_getRTOrders(self, ):
2672 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2673 
    if mtype == TMessageType.EXCEPTION:
2674 
      x = TApplicationException()
2675 
      x.read(self._iprot)
2676 
      self._iprot.readMessageEnd()
2677 
      raise x
2678 
    result = getRTOrders_result()
2679 
    result.read(self._iprot)
2680 
    self._iprot.readMessageEnd()
2681 
    if result.success is not None:
2682 
      return result.success
2683 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getRTOrders failed: unknown result");
2684 
 
3064 chandransh 2685 
  def updateNonDeliveryReason(self, providerId, undeliveredOrders):
1627 ankur.sing 2686 
    """
3064 chandransh 2687 
    Update the status description of orders whose AWB numbers are keys of the Map.
3431 rajveer 2688 
 
3064 chandransh 2689 
    Parameters:
2690 
     - providerId
2691 
     - undeliveredOrders
1627 ankur.sing 2692 
    """
3064 chandransh 2693 
    self.send_updateNonDeliveryReason(providerId, undeliveredOrders)
4910 phani.kuma 2694 
    self.recv_updateNonDeliveryReason()
1596 ankur.sing 2695 
 
3064 chandransh 2696 
  def send_updateNonDeliveryReason(self, providerId, undeliveredOrders):
2697 
    self._oprot.writeMessageBegin('updateNonDeliveryReason', TMessageType.CALL, self._seqid)
2698 
    args = updateNonDeliveryReason_args()
2699 
    args.providerId = providerId
2700 
    args.undeliveredOrders = undeliveredOrders
1627 ankur.sing 2701 
    args.write(self._oprot)
2702 
    self._oprot.writeMessageEnd()
2703 
    self._oprot.trans.flush()
2704 
 
3064 chandransh 2705 
  def recv_updateNonDeliveryReason(self, ):
1627 ankur.sing 2706 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2707 
    if mtype == TMessageType.EXCEPTION:
2708 
      x = TApplicationException()
2709 
      x.read(self._iprot)
2710 
      self._iprot.readMessageEnd()
2711 
      raise x
3064 chandransh 2712 
    result = updateNonDeliveryReason_result()
1627 ankur.sing 2713 
    result.read(self._iprot)
2714 
    self._iprot.readMessageEnd()
4910 phani.kuma 2715 
    if result.ex is not None:
2716 
      raise result.ex
2717 
    return
2718 
 
2719 
  def getNonDeliveredOrdersbyCourier(self, providerId):
2720 
    """
2721 
    Returns a list of orders that were picked up or shipped four days ago but did not get delivered.
2722 
 
2723 
    Parameters:
2724 
     - providerId
2725 
    """
2726 
    self.send_getNonDeliveredOrdersbyCourier(providerId)
2727 
    return self.recv_getNonDeliveredOrdersbyCourier()
2728 
 
2729 
  def send_getNonDeliveredOrdersbyCourier(self, providerId):
2730 
    self._oprot.writeMessageBegin('getNonDeliveredOrdersbyCourier', TMessageType.CALL, self._seqid)
2731 
    args = getNonDeliveredOrdersbyCourier_args()
2732 
    args.providerId = providerId
2733 
    args.write(self._oprot)
2734 
    self._oprot.writeMessageEnd()
2735 
    self._oprot.trans.flush()
2736 
 
2737 
  def recv_getNonDeliveredOrdersbyCourier(self, ):
2738 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2739 
    if mtype == TMessageType.EXCEPTION:
2740 
      x = TApplicationException()
2741 
      x.read(self._iprot)
2742 
      self._iprot.readMessageEnd()
2743 
      raise x
2744 
    result = getNonDeliveredOrdersbyCourier_result()
2745 
    result.read(self._iprot)
2746 
    self._iprot.readMessageEnd()
4581 phani.kuma 2747 
    if result.success is not None:
2748 
      return result.success
4910 phani.kuma 2749 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getNonDeliveredOrdersbyCourier failed: unknown result");
2750 
 
2751 
  def markOrdersAsLocalConnected(self, providerId, local_connected_orders):
2752 
    """
2753 
    Mark all orders with AWBs in the given map as local connected. Also sets the local connected timestamp.
2754 
 
2755 
    Parameters:
2756 
     - providerId
2757 
     - local_connected_orders
2758 
    """
2759 
    self.send_markOrdersAsLocalConnected(providerId, local_connected_orders)
2760 
    self.recv_markOrdersAsLocalConnected()
2761 
 
2762 
  def send_markOrdersAsLocalConnected(self, providerId, local_connected_orders):
2763 
    self._oprot.writeMessageBegin('markOrdersAsLocalConnected', TMessageType.CALL, self._seqid)
2764 
    args = markOrdersAsLocalConnected_args()
2765 
    args.providerId = providerId
2766 
    args.local_connected_orders = local_connected_orders
2767 
    args.write(self._oprot)
2768 
    self._oprot.writeMessageEnd()
2769 
    self._oprot.trans.flush()
2770 
 
2771 
  def recv_markOrdersAsLocalConnected(self, ):
2772 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2773 
    if mtype == TMessageType.EXCEPTION:
2774 
      x = TApplicationException()
2775 
      x.read(self._iprot)
2776 
      self._iprot.readMessageEnd()
2777 
      raise x
2778 
    result = markOrdersAsLocalConnected_result()
2779 
    result.read(self._iprot)
2780 
    self._iprot.readMessageEnd()
3431 rajveer 2781 
    if result.ex is not None:
3064 chandransh 2782 
      raise result.ex
4910 phani.kuma 2783 
    return
1627 ankur.sing 2784 
 
4910 phani.kuma 2785 
  def getOrdersNotLocalConnected(self, providerId):
2786 
    """
2787 
    Returns a list of orders that were picked up or shipped but pending local connection.
2788 
 
2789 
    Parameters:
2790 
     - providerId
2791 
    """
2792 
    self.send_getOrdersNotLocalConnected(providerId)
2793 
    return self.recv_getOrdersNotLocalConnected()
2794 
 
2795 
  def send_getOrdersNotLocalConnected(self, providerId):
2796 
    self._oprot.writeMessageBegin('getOrdersNotLocalConnected', TMessageType.CALL, self._seqid)
2797 
    args = getOrdersNotLocalConnected_args()
2798 
    args.providerId = providerId
2799 
    args.write(self._oprot)
2800 
    self._oprot.writeMessageEnd()
2801 
    self._oprot.trans.flush()
2802 
 
2803 
  def recv_getOrdersNotLocalConnected(self, ):
2804 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2805 
    if mtype == TMessageType.EXCEPTION:
2806 
      x = TApplicationException()
2807 
      x.read(self._iprot)
2808 
      self._iprot.readMessageEnd()
2809 
      raise x
2810 
    result = getOrdersNotLocalConnected_result()
2811 
    result.read(self._iprot)
2812 
    self._iprot.readMessageEnd()
2813 
    if result.success is not None:
2814 
      return result.success
2815 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getOrdersNotLocalConnected failed: unknown result");
2816 
 
2817 
  def markOrdersAsDestinationCityReached(self, providerId, destination_city_reached_orders):
2818 
    """
2819 
    Mark all orders with AWBs in the given map as reached destination city. Also sets the reached destination timestamp.
2820 
 
2821 
    Parameters:
2822 
     - providerId
2823 
     - destination_city_reached_orders
2824 
    """
2825 
    self.send_markOrdersAsDestinationCityReached(providerId, destination_city_reached_orders)
2826 
    self.recv_markOrdersAsDestinationCityReached()
2827 
 
2828 
  def send_markOrdersAsDestinationCityReached(self, providerId, destination_city_reached_orders):
2829 
    self._oprot.writeMessageBegin('markOrdersAsDestinationCityReached', TMessageType.CALL, self._seqid)
2830 
    args = markOrdersAsDestinationCityReached_args()
2831 
    args.providerId = providerId
2832 
    args.destination_city_reached_orders = destination_city_reached_orders
2833 
    args.write(self._oprot)
2834 
    self._oprot.writeMessageEnd()
2835 
    self._oprot.trans.flush()
2836 
 
2837 
  def recv_markOrdersAsDestinationCityReached(self, ):
2838 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2839 
    if mtype == TMessageType.EXCEPTION:
2840 
      x = TApplicationException()
2841 
      x.read(self._iprot)
2842 
      self._iprot.readMessageEnd()
2843 
      raise x
2844 
    result = markOrdersAsDestinationCityReached_result()
2845 
    result.read(self._iprot)
2846 
    self._iprot.readMessageEnd()
2847 
    if result.ex is not None:
2848 
      raise result.ex
2849 
    return
2850 
 
2851 
  def markOrdersAsFirstDeliveryAttempted(self, providerId, first_atdl_orders):
2852 
    """
2853 
    Mark all orders with AWBs in the given map as first delivery attempt made. Also sets the first delivery attempted timestamp.
2854 
 
2855 
    Parameters:
2856 
     - providerId
2857 
     - first_atdl_orders
2858 
    """
2859 
    self.send_markOrdersAsFirstDeliveryAttempted(providerId, first_atdl_orders)
2860 
    self.recv_markOrdersAsFirstDeliveryAttempted()
2861 
 
2862 
  def send_markOrdersAsFirstDeliveryAttempted(self, providerId, first_atdl_orders):
2863 
    self._oprot.writeMessageBegin('markOrdersAsFirstDeliveryAttempted', TMessageType.CALL, self._seqid)
2864 
    args = markOrdersAsFirstDeliveryAttempted_args()
2865 
    args.providerId = providerId
2866 
    args.first_atdl_orders = first_atdl_orders
2867 
    args.write(self._oprot)
2868 
    self._oprot.writeMessageEnd()
2869 
    self._oprot.trans.flush()
2870 
 
2871 
  def recv_markOrdersAsFirstDeliveryAttempted(self, ):
2872 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2873 
    if mtype == TMessageType.EXCEPTION:
2874 
      x = TApplicationException()
2875 
      x.read(self._iprot)
2876 
      self._iprot.readMessageEnd()
2877 
      raise x
2878 
    result = markOrdersAsFirstDeliveryAttempted_result()
2879 
    result.read(self._iprot)
2880 
    self._iprot.readMessageEnd()
2881 
    if result.ex is not None:
2882 
      raise result.ex
2883 
    return
2884 
 
3064 chandransh 2885 
  def getUndeliveredOrders(self, providerId, warehouseId):
1627 ankur.sing 2886 
    """
3064 chandransh 2887 
    Returns the list of orders whose delivery time has passed but have not been
2888 
    delivered yet for the given provider and warehouse. To get a complete list of
2889 
    undelivered orders, pass them as -1.
2890 
    Returns an empty list if no such orders exist.
3431 rajveer 2891 
 
1886 ankur.sing 2892 
    Parameters:
3064 chandransh 2893 
     - providerId
2894 
     - warehouseId
1886 ankur.sing 2895 
    """
3064 chandransh 2896 
    self.send_getUndeliveredOrders(providerId, warehouseId)
2897 
    return self.recv_getUndeliveredOrders()
1627 ankur.sing 2898 
 
3064 chandransh 2899 
  def send_getUndeliveredOrders(self, providerId, warehouseId):
2900 
    self._oprot.writeMessageBegin('getUndeliveredOrders', TMessageType.CALL, self._seqid)
2901 
    args = getUndeliveredOrders_args()
2902 
    args.providerId = providerId
2903 
    args.warehouseId = warehouseId
1886 ankur.sing 2904 
    args.write(self._oprot)
2905 
    self._oprot.writeMessageEnd()
2906 
    self._oprot.trans.flush()
2907 
 
3064 chandransh 2908 
  def recv_getUndeliveredOrders(self, ):
1886 ankur.sing 2909 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2910 
    if mtype == TMessageType.EXCEPTION:
2911 
      x = TApplicationException()
2912 
      x.read(self._iprot)
2913 
      self._iprot.readMessageEnd()
2914 
      raise x
3064 chandransh 2915 
    result = getUndeliveredOrders_result()
1886 ankur.sing 2916 
    result.read(self._iprot)
2917 
    self._iprot.readMessageEnd()
3431 rajveer 2918 
    if result.success is not None:
1886 ankur.sing 2919 
      return result.success
3064 chandransh 2920 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getUndeliveredOrders failed: unknown result");
1886 ankur.sing 2921 
 
4783 phani.kuma 2922 
  def getUndeliveredOrdersExpectedDeliveryDateNotMet(self, ):
2923 
    """
2924 
    Returns the list of orders whose expected delivery date has passed but have not been
2925 
    delivered yet.
2926 
    Returns an empty list if no such orders exist.
2927 
    """
2928 
    self.send_getUndeliveredOrdersExpectedDeliveryDateNotMet()
2929 
    return self.recv_getUndeliveredOrdersExpectedDeliveryDateNotMet()
2930 
 
2931 
  def send_getUndeliveredOrdersExpectedDeliveryDateNotMet(self, ):
2932 
    self._oprot.writeMessageBegin('getUndeliveredOrdersExpectedDeliveryDateNotMet', TMessageType.CALL, self._seqid)
2933 
    args = getUndeliveredOrdersExpectedDeliveryDateNotMet_args()
2934 
    args.write(self._oprot)
2935 
    self._oprot.writeMessageEnd()
2936 
    self._oprot.trans.flush()
2937 
 
2938 
  def recv_getUndeliveredOrdersExpectedDeliveryDateNotMet(self, ):
2939 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2940 
    if mtype == TMessageType.EXCEPTION:
2941 
      x = TApplicationException()
2942 
      x.read(self._iprot)
2943 
      self._iprot.readMessageEnd()
2944 
      raise x
2945 
    result = getUndeliveredOrdersExpectedDeliveryDateNotMet_result()
2946 
    result.read(self._iprot)
2947 
    self._iprot.readMessageEnd()
2948 
    if result.success is not None:
2949 
      return result.success
2950 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getUndeliveredOrdersExpectedDeliveryDateNotMet failed: unknown result");
2951 
 
2536 chandransh 2952 
  def toggleDOAFlag(self, orderId):
2953 
    """
2954 
    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.
2955 
    Returns the final flag status.
2956 
    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 2957 
 
2536 chandransh 2958 
    Parameters:
2959 
     - orderId
2960 
    """
2961 
    self.send_toggleDOAFlag(orderId)
2962 
    return self.recv_toggleDOAFlag()
1886 ankur.sing 2963 
 
2536 chandransh 2964 
  def send_toggleDOAFlag(self, orderId):
2965 
    self._oprot.writeMessageBegin('toggleDOAFlag', TMessageType.CALL, self._seqid)
2966 
    args = toggleDOAFlag_args()
2967 
    args.orderId = orderId
2968 
    args.write(self._oprot)
2969 
    self._oprot.writeMessageEnd()
2970 
    self._oprot.trans.flush()
2971 
 
2972 
  def recv_toggleDOAFlag(self, ):
2973 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2974 
    if mtype == TMessageType.EXCEPTION:
2975 
      x = TApplicationException()
2976 
      x.read(self._iprot)
2977 
      self._iprot.readMessageEnd()
2978 
      raise x
2979 
    result = toggleDOAFlag_result()
2980 
    result.read(self._iprot)
2981 
    self._iprot.readMessageEnd()
3431 rajveer 2982 
    if result.success is not None:
2536 chandransh 2983 
      return result.success
3431 rajveer 2984 
    if result.ex is not None:
2536 chandransh 2985 
      raise result.ex
2986 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "toggleDOAFlag failed: unknown result");
2987 
 
4712 rajveer 2988 
  def markOrderAsDelivered(self, orderId, deliveryTimestamp, receiver):
2989 
    """
2990 
    Parameters:
2991 
     - orderId
2992 
     - deliveryTimestamp
2993 
     - receiver
2994 
    """
2995 
    self.send_markOrderAsDelivered(orderId, deliveryTimestamp, receiver)
2996 
    self.recv_markOrderAsDelivered()
2997 
 
2998 
  def send_markOrderAsDelivered(self, orderId, deliveryTimestamp, receiver):
2999 
    self._oprot.writeMessageBegin('markOrderAsDelivered', TMessageType.CALL, self._seqid)
3000 
    args = markOrderAsDelivered_args()
3001 
    args.orderId = orderId
3002 
    args.deliveryTimestamp = deliveryTimestamp
3003 
    args.receiver = receiver
3004 
    args.write(self._oprot)
3005 
    self._oprot.writeMessageEnd()
3006 
    self._oprot.trans.flush()
3007 
 
3008 
  def recv_markOrderAsDelivered(self, ):
3009 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3010 
    if mtype == TMessageType.EXCEPTION:
3011 
      x = TApplicationException()
3012 
      x.read(self._iprot)
3013 
      self._iprot.readMessageEnd()
3014 
      raise x
3015 
    result = markOrderAsDelivered_result()
3016 
    result.read(self._iprot)
3017 
    self._iprot.readMessageEnd()
3018 
    if result.ex is not None:
3019 
      raise result.ex
3020 
    return
3021 
 
4454 rajveer 3022 
  def markOrderDoaRequestReceived(self, orderId):
3023 
    """
3024 
    Once user raise the request for a DOA, order status will be changed from DELVIERY_SUCCESS to DOA_REQUEST_RECEIVED
3025 
 
3026 
    Parameters:
3027 
     - orderId
3028 
    """
3029 
    self.send_markOrderDoaRequestReceived(orderId)
3030 
    return self.recv_markOrderDoaRequestReceived()
3031 
 
3032 
  def send_markOrderDoaRequestReceived(self, orderId):
3033 
    self._oprot.writeMessageBegin('markOrderDoaRequestReceived', TMessageType.CALL, self._seqid)
3034 
    args = markOrderDoaRequestReceived_args()
3035 
    args.orderId = orderId
3036 
    args.write(self._oprot)
3037 
    self._oprot.writeMessageEnd()
3038 
    self._oprot.trans.flush()
3039 
 
3040 
  def recv_markOrderDoaRequestReceived(self, ):
3041 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3042 
    if mtype == TMessageType.EXCEPTION:
3043 
      x = TApplicationException()
3044 
      x.read(self._iprot)
3045 
      self._iprot.readMessageEnd()
3046 
      raise x
3047 
    result = markOrderDoaRequestReceived_result()
3048 
    result.read(self._iprot)
3049 
    self._iprot.readMessageEnd()
3050 
    if result.success is not None:
3051 
      return result.success
3052 
    if result.ex is not None:
3053 
      raise result.ex
3054 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "markOrderDoaRequestReceived failed: unknown result");
3055 
 
3056 
  def markOrderDoaRequestAuthorized(self, orderId, isAuthorized):
3057 
    """
3058 
    CRM person can authorize or deny the request reised by customer. If he authorizes order will change from DOA_REQUEST_RECEIVED
3059 
    to DOA_REQUEST_AUTHORIZED. If he denies, status will be changed back to DELVIERY_SUCCESS.
3060 
 
3061 
    Parameters:
3062 
     - orderId
3063 
     - isAuthorized
3064 
    """
3065 
    self.send_markOrderDoaRequestAuthorized(orderId, isAuthorized)
3066 
    return self.recv_markOrderDoaRequestAuthorized()
3067 
 
3068 
  def send_markOrderDoaRequestAuthorized(self, orderId, isAuthorized):
3069 
    self._oprot.writeMessageBegin('markOrderDoaRequestAuthorized', TMessageType.CALL, self._seqid)
3070 
    args = markOrderDoaRequestAuthorized_args()
3071 
    args.orderId = orderId
3072 
    args.isAuthorized = isAuthorized
3073 
    args.write(self._oprot)
3074 
    self._oprot.writeMessageEnd()
3075 
    self._oprot.trans.flush()
3076 
 
3077 
  def recv_markOrderDoaRequestAuthorized(self, ):
3078 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3079 
    if mtype == TMessageType.EXCEPTION:
3080 
      x = TApplicationException()
3081 
      x.read(self._iprot)
3082 
      self._iprot.readMessageEnd()
3083 
      raise x
3084 
    result = markOrderDoaRequestAuthorized_result()
3085 
    result.read(self._iprot)
3086 
    self._iprot.readMessageEnd()
3087 
    if result.success is not None:
3088 
      return result.success
3089 
    if result.ex is not None:
3090 
      raise result.ex
3091 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "markOrderDoaRequestAuthorized failed: unknown result");
3092 
 
4488 rajveer 3093 
  def markOrderReturnRequestReceived(self, orderId):
3094 
    """
3095 
    Once user raise the request for a RET, order status will be changed from DELVIERY_SUCCESS to RET_REQUEST_RECEIVED
3096 
 
3097 
    Parameters:
3098 
     - orderId
3099 
    """
3100 
    self.send_markOrderReturnRequestReceived(orderId)
3101 
    return self.recv_markOrderReturnRequestReceived()
3102 
 
3103 
  def send_markOrderReturnRequestReceived(self, orderId):
3104 
    self._oprot.writeMessageBegin('markOrderReturnRequestReceived', TMessageType.CALL, self._seqid)
3105 
    args = markOrderReturnRequestReceived_args()
3106 
    args.orderId = orderId
3107 
    args.write(self._oprot)
3108 
    self._oprot.writeMessageEnd()
3109 
    self._oprot.trans.flush()
3110 
 
3111 
  def recv_markOrderReturnRequestReceived(self, ):
3112 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3113 
    if mtype == TMessageType.EXCEPTION:
3114 
      x = TApplicationException()
3115 
      x.read(self._iprot)
3116 
      self._iprot.readMessageEnd()
3117 
      raise x
3118 
    result = markOrderReturnRequestReceived_result()
3119 
    result.read(self._iprot)
3120 
    self._iprot.readMessageEnd()
3121 
    if result.success is not None:
3122 
      return result.success
3123 
    if result.ex is not None:
3124 
      raise result.ex
3125 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "markOrderReturnRequestReceived failed: unknown result");
3126 
 
3127 
  def markOrderReturnRequestAuthorized(self, orderId, isAuthorized):
3128 
    """
3129 
    CRM person can authorize or deny the request reised by customer. If he authorizes order will change from RET_REQUEST_RECEIVED
3130 
    to RET_REQUEST_AUTHORIZED. If he denies, status will be changed back to DELVIERY_SUCCESS.
3131 
 
3132 
    Parameters:
3133 
     - orderId
3134 
     - isAuthorized
3135 
    """
3136 
    self.send_markOrderReturnRequestAuthorized(orderId, isAuthorized)
3137 
    return self.recv_markOrderReturnRequestAuthorized()
3138 
 
3139 
  def send_markOrderReturnRequestAuthorized(self, orderId, isAuthorized):
3140 
    self._oprot.writeMessageBegin('markOrderReturnRequestAuthorized', TMessageType.CALL, self._seqid)
3141 
    args = markOrderReturnRequestAuthorized_args()
3142 
    args.orderId = orderId
3143 
    args.isAuthorized = isAuthorized
3144 
    args.write(self._oprot)
3145 
    self._oprot.writeMessageEnd()
3146 
    self._oprot.trans.flush()
3147 
 
3148 
  def recv_markOrderReturnRequestAuthorized(self, ):
3149 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3150 
    if mtype == TMessageType.EXCEPTION:
3151 
      x = TApplicationException()
3152 
      x.read(self._iprot)
3153 
      self._iprot.readMessageEnd()
3154 
      raise x
3155 
    result = markOrderReturnRequestAuthorized_result()
3156 
    result.read(self._iprot)
3157 
    self._iprot.readMessageEnd()
3158 
    if result.success is not None:
3159 
      return result.success
3160 
    if result.ex is not None:
3161 
      raise result.ex
3162 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "markOrderReturnRequestAuthorized failed: unknown result");
3163 
 
4579 rajveer 3164 
  def requestPickupNumber(self, orderId, providerId):
2536 chandransh 3165 
    """
3166 
    Sends out an email to the account manager of the original courier provider used to ship the order.
4452 rajveer 3167 
    If the order status was DELIVERY_SUCCESS, it is changed to be DOA_PICKUP_REQUEST_RAISED.
3168 
    If the order status was DOA_PICKUP_REQUEST_RAISED, it is left unchanged.
2536 chandransh 3169 
    For any other status, it returns false.
3170 
    Throws an exception if the order with the given id couldn't be found.
3431 rajveer 3171 
 
2536 chandransh 3172 
    Parameters:
3173 
     - orderId
4579 rajveer 3174 
     - providerId
2536 chandransh 3175 
    """
4579 rajveer 3176 
    self.send_requestPickupNumber(orderId, providerId)
2536 chandransh 3177 
    return self.recv_requestPickupNumber()
3178 
 
4579 rajveer 3179 
  def send_requestPickupNumber(self, orderId, providerId):
2536 chandransh 3180 
    self._oprot.writeMessageBegin('requestPickupNumber', TMessageType.CALL, self._seqid)
3181 
    args = requestPickupNumber_args()
3182 
    args.orderId = orderId
4579 rajveer 3183 
    args.providerId = providerId
2536 chandransh 3184 
    args.write(self._oprot)
3185 
    self._oprot.writeMessageEnd()
3186 
    self._oprot.trans.flush()
3187 
 
3188 
  def recv_requestPickupNumber(self, ):
3189 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3190 
    if mtype == TMessageType.EXCEPTION:
3191 
      x = TApplicationException()
3192 
      x.read(self._iprot)
3193 
      self._iprot.readMessageEnd()
3194 
      raise x
3195 
    result = requestPickupNumber_result()
3196 
    result.read(self._iprot)
3197 
    self._iprot.readMessageEnd()
3431 rajveer 3198 
    if result.success is not None:
2536 chandransh 3199 
      return result.success
3431 rajveer 3200 
    if result.ex is not None:
2536 chandransh 3201 
      raise result.ex
3202 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "requestPickupNumber failed: unknown result");
3203 
 
4602 rajveer 3204 
  def authorizePickup(self, orderId, pickupNumber, providerId):
2536 chandransh 3205 
    """
4452 rajveer 3206 
    If the order status is DOA_PICKUP_REQUEST_RAISED, it does the following
2536 chandransh 3207 
    	1. Sends out an email to the customer with the dispatch advice that he has to print as an attachment.
3208 
    	2. Changes order status to be DOA_PICKUP_AUTHORIZED.
3209 
    	3. Returns true
2591 chandransh 3210 
    If the order is in any other status, it returns false.
2536 chandransh 3211 
    Throws an exception if the order with the given id couldn't be found.
3431 rajveer 3212 
 
2536 chandransh 3213 
    Parameters:
3214 
     - orderId
3215 
     - pickupNumber
4602 rajveer 3216 
     - providerId
2536 chandransh 3217 
    """
4602 rajveer 3218 
    self.send_authorizePickup(orderId, pickupNumber, providerId)
2536 chandransh 3219 
    return self.recv_authorizePickup()
3220 
 
4602 rajveer 3221 
  def send_authorizePickup(self, orderId, pickupNumber, providerId):
2536 chandransh 3222 
    self._oprot.writeMessageBegin('authorizePickup', TMessageType.CALL, self._seqid)
3223 
    args = authorizePickup_args()
3224 
    args.orderId = orderId
3225 
    args.pickupNumber = pickupNumber
4602 rajveer 3226 
    args.providerId = providerId
2536 chandransh 3227 
    args.write(self._oprot)
3228 
    self._oprot.writeMessageEnd()
3229 
    self._oprot.trans.flush()
3230 
 
3231 
  def recv_authorizePickup(self, ):
3232 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3233 
    if mtype == TMessageType.EXCEPTION:
3234 
      x = TApplicationException()
3235 
      x.read(self._iprot)
3236 
      self._iprot.readMessageEnd()
3237 
      raise x
3238 
    result = authorizePickup_result()
3239 
    result.read(self._iprot)
3240 
    self._iprot.readMessageEnd()
3431 rajveer 3241 
    if result.success is not None:
2536 chandransh 3242 
      return result.success
3431 rajveer 3243 
    if result.ex is not None:
2536 chandransh 3244 
      raise result.ex
3245 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "authorizePickup failed: unknown result");
3246 
 
2764 chandransh 3247 
  def markDoasAsPickedUp(self, providerId, pickupDetails):
3248 
    """
3249 
    Marks all DOA_PICKUP_AUTHORIZED orders of the previous day for a provider as DOA_RETURN_IN_TRANSIT.
3431 rajveer 3250 
 
2764 chandransh 3251 
    Parameters:
3252 
     - providerId
3253 
     - pickupDetails
3254 
    """
3255 
    self.send_markDoasAsPickedUp(providerId, pickupDetails)
4910 phani.kuma 3256 
    self.recv_markDoasAsPickedUp()
2764 chandransh 3257 
 
3258 
  def send_markDoasAsPickedUp(self, providerId, pickupDetails):
3259 
    self._oprot.writeMessageBegin('markDoasAsPickedUp', TMessageType.CALL, self._seqid)
3260 
    args = markDoasAsPickedUp_args()
3261 
    args.providerId = providerId
3262 
    args.pickupDetails = pickupDetails
3263 
    args.write(self._oprot)
3264 
    self._oprot.writeMessageEnd()
3265 
    self._oprot.trans.flush()
3266 
 
3267 
  def recv_markDoasAsPickedUp(self, ):
3268 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3269 
    if mtype == TMessageType.EXCEPTION:
3270 
      x = TApplicationException()
3271 
      x.read(self._iprot)
3272 
      self._iprot.readMessageEnd()
3273 
      raise x
3274 
    result = markDoasAsPickedUp_result()
3275 
    result.read(self._iprot)
3276 
    self._iprot.readMessageEnd()
4910 phani.kuma 3277 
    return
3278 
 
3279 
  def getDoasNotPickedUp(self, providerId):
3280 
    """
3281 
    Returns a list of orders that were authorized for pickup but did not appear in the pick-up report.
3282 
 
3283 
    Parameters:
3284 
     - providerId
3285 
    """
3286 
    self.send_getDoasNotPickedUp(providerId)
3287 
    return self.recv_getDoasNotPickedUp()
3288 
 
3289 
  def send_getDoasNotPickedUp(self, providerId):
3290 
    self._oprot.writeMessageBegin('getDoasNotPickedUp', TMessageType.CALL, self._seqid)
3291 
    args = getDoasNotPickedUp_args()
3292 
    args.providerId = providerId
3293 
    args.write(self._oprot)
3294 
    self._oprot.writeMessageEnd()
3295 
    self._oprot.trans.flush()
3296 
 
3297 
  def recv_getDoasNotPickedUp(self, ):
3298 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3299 
    if mtype == TMessageType.EXCEPTION:
3300 
      x = TApplicationException()
3301 
      x.read(self._iprot)
3302 
      self._iprot.readMessageEnd()
3303 
      raise x
3304 
    result = getDoasNotPickedUp_result()
3305 
    result.read(self._iprot)
3306 
    self._iprot.readMessageEnd()
3431 rajveer 3307 
    if result.success is not None:
2764 chandransh 3308 
      return result.success
4910 phani.kuma 3309 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getDoasNotPickedUp failed: unknown result");
2764 chandransh 3310 
 
4741 phani.kuma 3311 
  def markReturnOrdersAsPickedUp(self, providerId, pickupDetails):
3312 
    """
3313 
    Marks all RET_PICKUP_CONFIRMED orders of the previous day for a provider as RET_RETURN_IN_TRANSIT.
3314 
 
3315 
    Parameters:
3316 
     - providerId
3317 
     - pickupDetails
3318 
    """
3319 
    self.send_markReturnOrdersAsPickedUp(providerId, pickupDetails)
4910 phani.kuma 3320 
    self.recv_markReturnOrdersAsPickedUp()
4741 phani.kuma 3321 
 
3322 
  def send_markReturnOrdersAsPickedUp(self, providerId, pickupDetails):
3323 
    self._oprot.writeMessageBegin('markReturnOrdersAsPickedUp', TMessageType.CALL, self._seqid)
3324 
    args = markReturnOrdersAsPickedUp_args()
3325 
    args.providerId = providerId
3326 
    args.pickupDetails = pickupDetails
3327 
    args.write(self._oprot)
3328 
    self._oprot.writeMessageEnd()
3329 
    self._oprot.trans.flush()
3330 
 
3331 
  def recv_markReturnOrdersAsPickedUp(self, ):
3332 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3333 
    if mtype == TMessageType.EXCEPTION:
3334 
      x = TApplicationException()
3335 
      x.read(self._iprot)
3336 
      self._iprot.readMessageEnd()
3337 
      raise x
3338 
    result = markReturnOrdersAsPickedUp_result()
3339 
    result.read(self._iprot)
3340 
    self._iprot.readMessageEnd()
4910 phani.kuma 3341 
    return
3342 
 
3343 
  def getReturnOrdersNotPickedUp(self, providerId):
3344 
    """
3345 
    Returns a list of orders that were authorized for pickup but did not appear in the pick-up report.
3346 
 
3347 
    Parameters:
3348 
     - providerId
3349 
    """
3350 
    self.send_getReturnOrdersNotPickedUp(providerId)
3351 
    return self.recv_getReturnOrdersNotPickedUp()
3352 
 
3353 
  def send_getReturnOrdersNotPickedUp(self, providerId):
3354 
    self._oprot.writeMessageBegin('getReturnOrdersNotPickedUp', TMessageType.CALL, self._seqid)
3355 
    args = getReturnOrdersNotPickedUp_args()
3356 
    args.providerId = providerId
3357 
    args.write(self._oprot)
3358 
    self._oprot.writeMessageEnd()
3359 
    self._oprot.trans.flush()
3360 
 
3361 
  def recv_getReturnOrdersNotPickedUp(self, ):
3362 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3363 
    if mtype == TMessageType.EXCEPTION:
3364 
      x = TApplicationException()
3365 
      x.read(self._iprot)
3366 
      self._iprot.readMessageEnd()
3367 
      raise x
3368 
    result = getReturnOrdersNotPickedUp_result()
3369 
    result.read(self._iprot)
3370 
    self._iprot.readMessageEnd()
4741 phani.kuma 3371 
    if result.success is not None:
3372 
      return result.success
4910 phani.kuma 3373 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getReturnOrdersNotPickedUp failed: unknown result");
4741 phani.kuma 3374 
 
4479 rajveer 3375 
  def receiveReturn(self, orderId, receiveCondition):
2591 chandransh 3376 
    """
4452 rajveer 3377 
    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 3378 
    If the order status is RTO_IN_TRANSIT, marks the order status as RTO_RECEIVED_PRESTINE and returns true.
2591 chandransh 3379 
    If the order is in any other state, it returns false.
3380 
    Throws an exception if the order with the given id couldn't be found.
3431 rajveer 3381 
 
2591 chandransh 3382 
    Parameters:
3383 
     - orderId
4479 rajveer 3384 
     - receiveCondition
2591 chandransh 3385 
    """
4479 rajveer 3386 
    self.send_receiveReturn(orderId, receiveCondition)
2616 chandransh 3387 
    return self.recv_receiveReturn()
2536 chandransh 3388 
 
4479 rajveer 3389 
  def send_receiveReturn(self, orderId, receiveCondition):
2616 chandransh 3390 
    self._oprot.writeMessageBegin('receiveReturn', TMessageType.CALL, self._seqid)
3391 
    args = receiveReturn_args()
2591 chandransh 3392 
    args.orderId = orderId
4479 rajveer 3393 
    args.receiveCondition = receiveCondition
2591 chandransh 3394 
    args.write(self._oprot)
3395 
    self._oprot.writeMessageEnd()
3396 
    self._oprot.trans.flush()
3397 
 
2616 chandransh 3398 
  def recv_receiveReturn(self, ):
2591 chandransh 3399 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3400 
    if mtype == TMessageType.EXCEPTION:
3401 
      x = TApplicationException()
3402 
      x.read(self._iprot)
3403 
      self._iprot.readMessageEnd()
3404 
      raise x
2616 chandransh 3405 
    result = receiveReturn_result()
2591 chandransh 3406 
    result.read(self._iprot)
3407 
    self._iprot.readMessageEnd()
3431 rajveer 3408 
    if result.success is not None:
2591 chandransh 3409 
      return result.success
3431 rajveer 3410 
    if result.ex is not None:
2591 chandransh 3411 
      raise result.ex
2616 chandransh 3412 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "receiveReturn failed: unknown result");
2591 chandransh 3413 
 
3414 
  def validateDoa(self, orderId, isValid):
3415 
    """
4452 rajveer 3416 
    Used to validate the DOA certificate for an order in the DOA_RECEIVED_PRESTINE state. If the certificate is valid,
2616 chandransh 3417 
    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 3418 
    If the order is in any other state, it returns false.
3419 
    Throws an exception if the order with the given id couldn't be found.
3431 rajveer 3420 
 
2591 chandransh 3421 
    Parameters:
3422 
     - orderId
3423 
     - isValid
3424 
    """
3425 
    self.send_validateDoa(orderId, isValid)
3426 
    return self.recv_validateDoa()
3427 
 
3428 
  def send_validateDoa(self, orderId, isValid):
3429 
    self._oprot.writeMessageBegin('validateDoa', TMessageType.CALL, self._seqid)
3430 
    args = validateDoa_args()
3431 
    args.orderId = orderId
3432 
    args.isValid = isValid
3433 
    args.write(self._oprot)
3434 
    self._oprot.writeMessageEnd()
3435 
    self._oprot.trans.flush()
3436 
 
3437 
  def recv_validateDoa(self, ):
3438 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3439 
    if mtype == TMessageType.EXCEPTION:
3440 
      x = TApplicationException()
3441 
      x.read(self._iprot)
3442 
      self._iprot.readMessageEnd()
3443 
      raise x
3444 
    result = validateDoa_result()
3445 
    result.read(self._iprot)
3446 
    self._iprot.readMessageEnd()
3431 rajveer 3447 
    if result.success is not None:
2591 chandransh 3448 
      return result.success
3431 rajveer 3449 
    if result.ex is not None:
2591 chandransh 3450 
      raise result.ex
3451 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "validateDoa failed: unknown result");
3452 
 
4495 rajveer 3453 
  def validateReturnProduct(self, orderId, isUsable):
3454 
    """
3455 
    Parameters:
3456 
     - orderId
3457 
     - isUsable
3458 
    """
3459 
    self.send_validateReturnProduct(orderId, isUsable)
3460 
    return self.recv_validateReturnProduct()
3461 
 
3462 
  def send_validateReturnProduct(self, orderId, isUsable):
3463 
    self._oprot.writeMessageBegin('validateReturnProduct', TMessageType.CALL, self._seqid)
3464 
    args = validateReturnProduct_args()
3465 
    args.orderId = orderId
3466 
    args.isUsable = isUsable
3467 
    args.write(self._oprot)
3468 
    self._oprot.writeMessageEnd()
3469 
    self._oprot.trans.flush()
3470 
 
3471 
  def recv_validateReturnProduct(self, ):
3472 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3473 
    if mtype == TMessageType.EXCEPTION:
3474 
      x = TApplicationException()
3475 
      x.read(self._iprot)
3476 
      self._iprot.readMessageEnd()
3477 
      raise x
3478 
    result = validateReturnProduct_result()
3479 
    result.read(self._iprot)
3480 
    self._iprot.readMessageEnd()
3481 
    if result.success is not None:
3482 
      return result.success
3483 
    if result.ex is not None:
3484 
      raise result.ex
3485 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "validateReturnProduct failed: unknown result");
3486 
 
2616 chandransh 3487 
  def reshipOrder(self, orderId):
3488 
    """
4484 rajveer 3489 
    If the order is in RTO_RECEIVED_PRESTINE or DOA_CERT_INVALID state, it does the following:
2616 chandransh 3490 
    	1. Creates a new order for processing in the BILLED state. All billing information is saved.
4484 rajveer 3491 
    	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 3492 
 
3493 
    If the order is in DOA_CERT_VALID state, it does the following:
3494 
    	1. Creates a new order for processing in the SUBMITTED_FOR_PROCESSING state.
3495 
    	2. Creates a return order for the warehouse executive to return the DOA material.
4452 rajveer 3496 
    	3. Marks the current order as the final DOA_VALID_RESHIPPED state.
3431 rajveer 3497 
 
2616 chandransh 3498 
    Returns the id of the newly created order.
3431 rajveer 3499 
 
2616 chandransh 3500 
    Throws an exception if the order with the given id couldn't be found.
3431 rajveer 3501 
 
2616 chandransh 3502 
    Parameters:
3503 
     - orderId
3504 
    """
3505 
    self.send_reshipOrder(orderId)
3506 
    return self.recv_reshipOrder()
2591 chandransh 3507 
 
2616 chandransh 3508 
  def send_reshipOrder(self, orderId):
3509 
    self._oprot.writeMessageBegin('reshipOrder', TMessageType.CALL, self._seqid)
3510 
    args = reshipOrder_args()
3511 
    args.orderId = orderId
3512 
    args.write(self._oprot)
3513 
    self._oprot.writeMessageEnd()
3514 
    self._oprot.trans.flush()
3515 
 
3516 
  def recv_reshipOrder(self, ):
3517 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3518 
    if mtype == TMessageType.EXCEPTION:
3519 
      x = TApplicationException()
3520 
      x.read(self._iprot)
3521 
      self._iprot.readMessageEnd()
3522 
      raise x
3523 
    result = reshipOrder_result()
3524 
    result.read(self._iprot)
3525 
    self._iprot.readMessageEnd()
3431 rajveer 3526 
    if result.success is not None:
2616 chandransh 3527 
      return result.success
3431 rajveer 3528 
    if result.ex is not None:
2616 chandransh 3529 
      raise result.ex
3530 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "reshipOrder failed: unknown result");
3531 
 
3226 chandransh 3532 
  def refundOrder(self, orderId, refundedBy, reason):
2616 chandransh 3533 
    """
4484 rajveer 3534 
    If the order is in RTO_RECEIVED_PRESTINE, DOA_CERT_VALID or DOA_CERT_INVALID state, it does the following:
2616 chandransh 3535 
    	1. Creates a refund request for batch processing.
3536 
    	2. Creates a return order for the warehouse executive to return the shipped material.
4484 rajveer 3537 
    	3. Marks the current order as RTO_REFUNDED, DOA_VALID_REFUNDED or DOA_INVALID_REFUNDED final states.
3431 rajveer 3538 
 
2616 chandransh 3539 
    If the order is in SUBMITTED_FOR_PROCESSING or INVENTORY_LOW state, it does the following:
3540 
    	1. Creates a refund request for batch processing.
3226 chandransh 3541 
    	2. Cancels the reservation of the item in the warehouse.
3542 
    	3. Marks the current order as the REFUNDED final state.
3431 rajveer 3543 
 
3226 chandransh 3544 
    For all COD orders, if the order is in INIT, SUBMITTED_FOR_PROCESSING or INVENTORY_LOW state, it does the following:
3545 
    	1. Cancels the reservation of the item in the warehouse.
3546 
    	2. Marks the current order as CANCELED.
3547 
 
3548 
    In all cases, it updates the reason for cancellation or refund and the person who performed the action.
3549 
 
2616 chandransh 3550 
    Returns True if it is successful, False otherwise.
3431 rajveer 3551 
 
2616 chandransh 3552 
    Throws an exception if the order with the given id couldn't be found.
3431 rajveer 3553 
 
2616 chandransh 3554 
    Parameters:
3555 
     - orderId
3226 chandransh 3556 
     - refundedBy
3557 
     - reason
2616 chandransh 3558 
    """
3226 chandransh 3559 
    self.send_refundOrder(orderId, refundedBy, reason)
2616 chandransh 3560 
    return self.recv_refundOrder()
3561 
 
3226 chandransh 3562 
  def send_refundOrder(self, orderId, refundedBy, reason):
2616 chandransh 3563 
    self._oprot.writeMessageBegin('refundOrder', TMessageType.CALL, self._seqid)
3564 
    args = refundOrder_args()
3565 
    args.orderId = orderId
3226 chandransh 3566 
    args.refundedBy = refundedBy
3567 
    args.reason = reason
2616 chandransh 3568 
    args.write(self._oprot)
3569 
    self._oprot.writeMessageEnd()
3570 
    self._oprot.trans.flush()
3571 
 
3572 
  def recv_refundOrder(self, ):
3573 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3574 
    if mtype == TMessageType.EXCEPTION:
3575 
      x = TApplicationException()
3576 
      x.read(self._iprot)
3577 
      self._iprot.readMessageEnd()
3578 
      raise x
3579 
    result = refundOrder_result()
3580 
    result.read(self._iprot)
3581 
    self._iprot.readMessageEnd()
3431 rajveer 3582 
    if result.success is not None:
2616 chandransh 3583 
      return result.success
3431 rajveer 3584 
    if result.ex is not None:
2616 chandransh 3585 
      raise result.ex
3586 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "refundOrder failed: unknown result");
3587 
 
2690 chandransh 3588 
  def getReturnOrders(self, warehouseId, fromDate, toDate):
3589 
    """
3590 
    Get all return orders created between the from and to dates for the given warehouse.
3591 
    Ignores the warehouse if it is passed as -1.
3431 rajveer 3592 
 
2690 chandransh 3593 
    Parameters:
3594 
     - warehouseId
3595 
     - fromDate
3596 
     - toDate
3597 
    """
3598 
    self.send_getReturnOrders(warehouseId, fromDate, toDate)
3599 
    return self.recv_getReturnOrders()
2616 chandransh 3600 
 
2690 chandransh 3601 
  def send_getReturnOrders(self, warehouseId, fromDate, toDate):
3602 
    self._oprot.writeMessageBegin('getReturnOrders', TMessageType.CALL, self._seqid)
3603 
    args = getReturnOrders_args()
3604 
    args.warehouseId = warehouseId
3605 
    args.fromDate = fromDate
3606 
    args.toDate = toDate
3607 
    args.write(self._oprot)
3608 
    self._oprot.writeMessageEnd()
3609 
    self._oprot.trans.flush()
3610 
 
3611 
  def recv_getReturnOrders(self, ):
3612 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3613 
    if mtype == TMessageType.EXCEPTION:
3614 
      x = TApplicationException()
3615 
      x.read(self._iprot)
3616 
      self._iprot.readMessageEnd()
3617 
      raise x
3618 
    result = getReturnOrders_result()
3619 
    result.read(self._iprot)
3620 
    self._iprot.readMessageEnd()
3431 rajveer 3621 
    if result.success is not None:
2690 chandransh 3622 
      return result.success
3623 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getReturnOrders failed: unknown result");
3624 
 
5481 phani.kuma 3625 
  def getAllReturnOrders(self, onlyNotProcessed, fromDate, toDate):
3626 
    """
3627 
    Get all return orders created between the from and to dates.
3628 
 
3629 
    Parameters:
3630 
     - onlyNotProcessed
3631 
     - fromDate
3632 
     - toDate
3633 
    """
3634 
    self.send_getAllReturnOrders(onlyNotProcessed, fromDate, toDate)
3635 
    return self.recv_getAllReturnOrders()
3636 
 
3637 
  def send_getAllReturnOrders(self, onlyNotProcessed, fromDate, toDate):
3638 
    self._oprot.writeMessageBegin('getAllReturnOrders', TMessageType.CALL, self._seqid)
3639 
    args = getAllReturnOrders_args()
3640 
    args.onlyNotProcessed = onlyNotProcessed
3641 
    args.fromDate = fromDate
3642 
    args.toDate = toDate
3643 
    args.write(self._oprot)
3644 
    self._oprot.writeMessageEnd()
3645 
    self._oprot.trans.flush()
3646 
 
3647 
  def recv_getAllReturnOrders(self, ):
3648 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3649 
    if mtype == TMessageType.EXCEPTION:
3650 
      x = TApplicationException()
3651 
      x.read(self._iprot)
3652 
      self._iprot.readMessageEnd()
3653 
      raise x
3654 
    result = getAllReturnOrders_result()
3655 
    result.read(self._iprot)
3656 
    self._iprot.readMessageEnd()
3657 
    if result.success is not None:
3658 
      return result.success
3659 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAllReturnOrders failed: unknown result");
3660 
 
2700 chandransh 3661 
  def getReturnOrder(self, id):
3662 
    """
3663 
    Returns the ReturnOrder corresponding to the given id.
3664 
    Throws an exception if the return order with the given id couldn't be found.
3431 rajveer 3665 
 
2700 chandransh 3666 
    Parameters:
3667 
     - id
3668 
    """
3669 
    self.send_getReturnOrder(id)
3670 
    return self.recv_getReturnOrder()
3671 
 
3672 
  def send_getReturnOrder(self, id):
3673 
    self._oprot.writeMessageBegin('getReturnOrder', TMessageType.CALL, self._seqid)
3674 
    args = getReturnOrder_args()
3675 
    args.id = id
3676 
    args.write(self._oprot)
3677 
    self._oprot.writeMessageEnd()
3678 
    self._oprot.trans.flush()
3679 
 
3680 
  def recv_getReturnOrder(self, ):
3681 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3682 
    if mtype == TMessageType.EXCEPTION:
3683 
      x = TApplicationException()
3684 
      x.read(self._iprot)
3685 
      self._iprot.readMessageEnd()
3686 
      raise x
3687 
    result = getReturnOrder_result()
3688 
    result.read(self._iprot)
3689 
    self._iprot.readMessageEnd()
3431 rajveer 3690 
    if result.success is not None:
2700 chandransh 3691 
      return result.success
3431 rajveer 3692 
    if result.ex is not None:
2700 chandransh 3693 
      raise result.ex
3694 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getReturnOrder failed: unknown result");
3695 
 
2690 chandransh 3696 
  def processReturn(self, returnOrderId):
3697 
    """
3698 
    Marks the return order with the given id as processed. Raises an exception if no such return order exists.
3431 rajveer 3699 
 
2690 chandransh 3700 
    Parameters:
3701 
     - returnOrderId
3702 
    """
3703 
    self.send_processReturn(returnOrderId)
3704 
    self.recv_processReturn()
3705 
 
3706 
  def send_processReturn(self, returnOrderId):
3707 
    self._oprot.writeMessageBegin('processReturn', TMessageType.CALL, self._seqid)
3708 
    args = processReturn_args()
3709 
    args.returnOrderId = returnOrderId
3710 
    args.write(self._oprot)
3711 
    self._oprot.writeMessageEnd()
3712 
    self._oprot.trans.flush()
3713 
 
3714 
  def recv_processReturn(self, ):
3715 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3716 
    if mtype == TMessageType.EXCEPTION:
3717 
      x = TApplicationException()
3718 
      x.read(self._iprot)
3719 
      self._iprot.readMessageEnd()
3720 
      raise x
3721 
    result = processReturn_result()
3722 
    result.read(self._iprot)
3723 
    self._iprot.readMessageEnd()
3431 rajveer 3724 
    if result.ex is not None:
2690 chandransh 3725 
      raise result.ex
3726 
    return
3727 
 
3451 chandransh 3728 
  def updateWeight(self, orderId, weight):
3729 
    """
3730 
    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 3731 
 
3451 chandransh 3732 
    Parameters:
3733 
     - orderId
3734 
     - weight
3735 
    """
3736 
    self.send_updateWeight(orderId, weight)
3737 
    return self.recv_updateWeight()
3738 
 
3739 
  def send_updateWeight(self, orderId, weight):
3740 
    self._oprot.writeMessageBegin('updateWeight', TMessageType.CALL, self._seqid)
3741 
    args = updateWeight_args()
3742 
    args.orderId = orderId
3743 
    args.weight = weight
3744 
    args.write(self._oprot)
3745 
    self._oprot.writeMessageEnd()
3746 
    self._oprot.trans.flush()
3747 
 
3748 
  def recv_updateWeight(self, ):
3749 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3750 
    if mtype == TMessageType.EXCEPTION:
3751 
      x = TApplicationException()
3752 
      x.read(self._iprot)
3753 
      self._iprot.readMessageEnd()
3754 
      raise x
3755 
    result = updateWeight_result()
3756 
    result.read(self._iprot)
3757 
    self._iprot.readMessageEnd()
3758 
    if result.success is not None:
3759 
      return result.success
3760 
    if result.ex is not None:
3761 
      raise result.ex
3762 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "updateWeight failed: unknown result");
3763 
 
3469 chandransh 3764 
  def changeItem(self, orderId, itemId):
3765 
    """
3766 
    Change the item to be shipped for this order. Also adjusts the reservation in the inventory accordingly.
3767 
    Currently, it also ensures that only a different color of the given item is shipped.
3451 chandransh 3768 
 
3469 chandransh 3769 
    Parameters:
3770 
     - orderId
3771 
     - itemId
3772 
    """
3773 
    self.send_changeItem(orderId, itemId)
3774 
    return self.recv_changeItem()
3775 
 
3776 
  def send_changeItem(self, orderId, itemId):
3777 
    self._oprot.writeMessageBegin('changeItem', TMessageType.CALL, self._seqid)
3778 
    args = changeItem_args()
3779 
    args.orderId = orderId
3780 
    args.itemId = itemId
3781 
    args.write(self._oprot)
3782 
    self._oprot.writeMessageEnd()
3783 
    self._oprot.trans.flush()
3784 
 
3785 
  def recv_changeItem(self, ):
3786 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3787 
    if mtype == TMessageType.EXCEPTION:
3788 
      x = TApplicationException()
3789 
      x.read(self._iprot)
3790 
      self._iprot.readMessageEnd()
3791 
      raise x
3792 
    result = changeItem_result()
3793 
    result.read(self._iprot)
3794 
    self._iprot.readMessageEnd()
3795 
    if result.success is not None:
3796 
      return result.success
3797 
    if result.ex is not None:
3798 
      raise result.ex
3799 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "changeItem failed: unknown result");
3800 
 
3801 
  def shiftToWarehouse(self, orderId, warehouseId):
3802 
    """
3803 
    Moves the given order to the given warehouse. Also adjusts the inventory reservations accordingly.
3804 
 
3805 
    Parameters:
3806 
     - orderId
3807 
     - warehouseId
3808 
    """
3809 
    self.send_shiftToWarehouse(orderId, warehouseId)
3810 
    return self.recv_shiftToWarehouse()
3811 
 
3812 
  def send_shiftToWarehouse(self, orderId, warehouseId):
3813 
    self._oprot.writeMessageBegin('shiftToWarehouse', TMessageType.CALL, self._seqid)
3814 
    args = shiftToWarehouse_args()
3815 
    args.orderId = orderId
3816 
    args.warehouseId = warehouseId
3817 
    args.write(self._oprot)
3818 
    self._oprot.writeMessageEnd()
3819 
    self._oprot.trans.flush()
3820 
 
3821 
  def recv_shiftToWarehouse(self, ):
3822 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3823 
    if mtype == TMessageType.EXCEPTION:
3824 
      x = TApplicationException()
3825 
      x.read(self._iprot)
3826 
      self._iprot.readMessageEnd()
3827 
      raise x
3828 
    result = shiftToWarehouse_result()
3829 
    result.read(self._iprot)
3830 
    self._iprot.readMessageEnd()
3831 
    if result.success is not None:
3832 
      return result.success
3833 
    if result.ex is not None:
3834 
      raise result.ex
3835 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "shiftToWarehouse failed: unknown result");
3836 
 
4647 rajveer 3837 
  def addDelayReason(self, orderId, delayReason, furtherDelay, delayReasonText):
3553 chandransh 3838 
    """
3839 
    Adds the given delay reason to the given order.
3986 chandransh 3840 
    Increases the expected delivery time of the given order by the given no. of days.
3553 chandransh 3841 
    Raises an exception if no order with the given id can be found.
3469 chandransh 3842 
 
3553 chandransh 3843 
    Parameters:
3844 
     - orderId
3845 
     - delayReason
3986 chandransh 3846 
     - furtherDelay
4647 rajveer 3847 
     - delayReasonText
3553 chandransh 3848 
    """
4647 rajveer 3849 
    self.send_addDelayReason(orderId, delayReason, furtherDelay, delayReasonText)
3553 chandransh 3850 
    return self.recv_addDelayReason()
3851 
 
4647 rajveer 3852 
  def send_addDelayReason(self, orderId, delayReason, furtherDelay, delayReasonText):
3553 chandransh 3853 
    self._oprot.writeMessageBegin('addDelayReason', TMessageType.CALL, self._seqid)
3854 
    args = addDelayReason_args()
3855 
    args.orderId = orderId
3856 
    args.delayReason = delayReason
3986 chandransh 3857 
    args.furtherDelay = furtherDelay
4647 rajveer 3858 
    args.delayReasonText = delayReasonText
3553 chandransh 3859 
    args.write(self._oprot)
3860 
    self._oprot.writeMessageEnd()
3861 
    self._oprot.trans.flush()
3862 
 
3863 
  def recv_addDelayReason(self, ):
3864 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3865 
    if mtype == TMessageType.EXCEPTION:
3866 
      x = TApplicationException()
3867 
      x.read(self._iprot)
3868 
      self._iprot.readMessageEnd()
3869 
      raise x
3870 
    result = addDelayReason_result()
3871 
    result.read(self._iprot)
3872 
    self._iprot.readMessageEnd()
3873 
    if result.success is not None:
3874 
      return result.success
3875 
    if result.ex is not None:
3876 
      raise result.ex
3877 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "addDelayReason failed: unknown result");
3878 
 
3956 chandransh 3879 
  def reconcileCodCollection(self, collectedAmountMap, xferBy, xferTxnId, xferDate):
3880 
    """
3881 
    Marks the COD orders with given AWB nos. as having been processed.
3882 
    Updates the captured amount for the corresponding payment.
3553 chandransh 3883 
 
3956 chandransh 3884 
    Returns a map of AWBs which were not processed and the associated reason. An AWB is not processed if:
3885 
    1. There is no order corresponding to an AWB number.
3886 
    2. The captured amount for a payment exceeds the total payment.
3887 
    3. The order corresponding to an AWB no. is in a state prior to DELIVERY_SUCCESS.
3888 
 
3889 
    Parameters:
3890 
     - collectedAmountMap
3891 
     - xferBy
3892 
     - xferTxnId
3893 
     - xferDate
3894 
    """
3895 
    self.send_reconcileCodCollection(collectedAmountMap, xferBy, xferTxnId, xferDate)
3896 
    return self.recv_reconcileCodCollection()
3897 
 
3898 
  def send_reconcileCodCollection(self, collectedAmountMap, xferBy, xferTxnId, xferDate):
3899 
    self._oprot.writeMessageBegin('reconcileCodCollection', TMessageType.CALL, self._seqid)
3900 
    args = reconcileCodCollection_args()
3901 
    args.collectedAmountMap = collectedAmountMap
3902 
    args.xferBy = xferBy
3903 
    args.xferTxnId = xferTxnId
3904 
    args.xferDate = xferDate
3905 
    args.write(self._oprot)
3906 
    self._oprot.writeMessageEnd()
3907 
    self._oprot.trans.flush()
3908 
 
3909 
  def recv_reconcileCodCollection(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 = reconcileCodCollection_result()
3917 
    result.read(self._iprot)
3918 
    self._iprot.readMessageEnd()
3919 
    if result.success is not None:
3920 
      return result.success
3921 
    if result.ex is not None:
3922 
      raise result.ex
3923 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "reconcileCodCollection failed: unknown result");
3924 
 
4008 mandeep.dh 3925 
  def getTransactionsRequiringExtraProcessing(self, category):
3926 
    """
4065 mandeep.dh 3927 
    Returns the list of transaction ids that require some extra processing and
4008 mandeep.dh 3928 
    which belong to a particular category. This is currently used by CRM
4065 mandeep.dh 3929 
    application. If no such transaction ids are present, it returns an empty list.
3956 chandransh 3930 
 
4008 mandeep.dh 3931 
    Parameters:
3932 
     - category
3933 
    """
3934 
    self.send_getTransactionsRequiringExtraProcessing(category)
3935 
    return self.recv_getTransactionsRequiringExtraProcessing()
3936 
 
3937 
  def send_getTransactionsRequiringExtraProcessing(self, category):
3938 
    self._oprot.writeMessageBegin('getTransactionsRequiringExtraProcessing', TMessageType.CALL, self._seqid)
3939 
    args = getTransactionsRequiringExtraProcessing_args()
3940 
    args.category = category
3941 
    args.write(self._oprot)
3942 
    self._oprot.writeMessageEnd()
3943 
    self._oprot.trans.flush()
3944 
 
3945 
  def recv_getTransactionsRequiringExtraProcessing(self, ):
3946 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3947 
    if mtype == TMessageType.EXCEPTION:
3948 
      x = TApplicationException()
3949 
      x.read(self._iprot)
3950 
      self._iprot.readMessageEnd()
3951 
      raise x
3952 
    result = getTransactionsRequiringExtraProcessing_result()
3953 
    result.read(self._iprot)
3954 
    self._iprot.readMessageEnd()
3955 
    if result.success is not None:
3956 
      return result.success
3957 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getTransactionsRequiringExtraProcessing failed: unknown result");
3958 
 
3959 
  def markTransactionAsProcessed(self, transactionId, category):
3960 
    """
3961 
    Marks a particular transaction as processed for a particular cateogory.
4065 mandeep.dh 3962 
    It essentially deletes the transaction id record for a particular
3963 
    processing type category (if present) from DB.
3964 
    This is currently used by CRM application.
4008 mandeep.dh 3965 
 
3966 
    Parameters:
3967 
     - transactionId
3968 
     - category
3969 
    """
3970 
    self.send_markTransactionAsProcessed(transactionId, category)
3971 
    self.recv_markTransactionAsProcessed()
3972 
 
3973 
  def send_markTransactionAsProcessed(self, transactionId, category):
3974 
    self._oprot.writeMessageBegin('markTransactionAsProcessed', TMessageType.CALL, self._seqid)
3975 
    args = markTransactionAsProcessed_args()
3976 
    args.transactionId = transactionId
3977 
    args.category = category
3978 
    args.write(self._oprot)
3979 
    self._oprot.writeMessageEnd()
3980 
    self._oprot.trans.flush()
3981 
 
3982 
  def recv_markTransactionAsProcessed(self, ):
3983 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3984 
    if mtype == TMessageType.EXCEPTION:
3985 
      x = TApplicationException()
3986 
      x.read(self._iprot)
3987 
      self._iprot.readMessageEnd()
3988 
      raise x
3989 
    result = markTransactionAsProcessed_result()
3990 
    result.read(self._iprot)
3991 
    self._iprot.readMessageEnd()
3992 
    return
3993 
 
4018 chandransh 3994 
  def getItemWiseRiskyOrdersCount(self, ):
3995 
    """
3996 
    Returns a map containing the number of risky orders keyed by item id. A risky order
3997 
    is defined as one whose shipping date is about to expire.
3998 
    """
3999 
    self.send_getItemWiseRiskyOrdersCount()
4000 
    return self.recv_getItemWiseRiskyOrdersCount()
4008 mandeep.dh 4001 
 
4018 chandransh 4002 
  def send_getItemWiseRiskyOrdersCount(self, ):
4003 
    self._oprot.writeMessageBegin('getItemWiseRiskyOrdersCount', TMessageType.CALL, self._seqid)
4004 
    args = getItemWiseRiskyOrdersCount_args()
4005 
    args.write(self._oprot)
4006 
    self._oprot.writeMessageEnd()
4007 
    self._oprot.trans.flush()
4008 
 
4009 
  def recv_getItemWiseRiskyOrdersCount(self, ):
4010 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4011 
    if mtype == TMessageType.EXCEPTION:
4012 
      x = TApplicationException()
4013 
      x.read(self._iprot)
4014 
      self._iprot.readMessageEnd()
4015 
      raise x
4016 
    result = getItemWiseRiskyOrdersCount_result()
4017 
    result.read(self._iprot)
4018 
    self._iprot.readMessageEnd()
4019 
    if result.success is not None:
4020 
      return result.success
4021 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getItemWiseRiskyOrdersCount failed: unknown result");
4022 
 
4295 varun.gupt 4023 
  def getOrdersForItemIds(self, itemIds):
4024 
    """
4025 
    Returns a list of all orders which have items with given id
4026 
 
4027 
    Parameters:
4028 
     - itemIds
4029 
    """
4030 
    self.send_getOrdersForItemIds(itemIds)
4031 
    return self.recv_getOrdersForItemIds()
4032 
 
4033 
  def send_getOrdersForItemIds(self, itemIds):
4034 
    self._oprot.writeMessageBegin('getOrdersForItemIds', TMessageType.CALL, self._seqid)
4035 
    args = getOrdersForItemIds_args()
4036 
    args.itemIds = itemIds
4037 
    args.write(self._oprot)
4038 
    self._oprot.writeMessageEnd()
4039 
    self._oprot.trans.flush()
4040 
 
4041 
  def recv_getOrdersForItemIds(self, ):
4042 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4043 
    if mtype == TMessageType.EXCEPTION:
4044 
      x = TApplicationException()
4045 
      x.read(self._iprot)
4046 
      self._iprot.readMessageEnd()
4047 
      raise x
4048 
    result = getOrdersForItemIds_result()
4049 
    result.read(self._iprot)
4050 
    self._iprot.readMessageEnd()
4051 
    if result.success is not None:
4052 
      return result.success
4053 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getOrdersForItemIds failed: unknown result");
4054 
 
4247 rajveer 4055 
  def markOrderCancellationRequestReceived(self, orderId):
4056 
    """
4057 
    Mark order as cancellation request received. If customer sends request of cancellation of
4058 
    a particular order, this method will be called. It will just change status of the order
4059 
    depending on its current status. It also records the previous status, so that we can move
4060 
    back to that status if cancellation request is denied.
4018 chandransh 4061 
 
4247 rajveer 4062 
    Parameters:
4063 
     - orderId
4064 
    """
4065 
    self.send_markOrderCancellationRequestReceived(orderId)
4066 
    self.recv_markOrderCancellationRequestReceived()
4067 
 
4068 
  def send_markOrderCancellationRequestReceived(self, orderId):
4069 
    self._oprot.writeMessageBegin('markOrderCancellationRequestReceived', TMessageType.CALL, self._seqid)
4070 
    args = markOrderCancellationRequestReceived_args()
4071 
    args.orderId = orderId
4072 
    args.write(self._oprot)
4073 
    self._oprot.writeMessageEnd()
4074 
    self._oprot.trans.flush()
4075 
 
4076 
  def recv_markOrderCancellationRequestReceived(self, ):
4077 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4078 
    if mtype == TMessageType.EXCEPTION:
4079 
      x = TApplicationException()
4080 
      x.read(self._iprot)
4081 
      self._iprot.readMessageEnd()
4082 
      raise x
4083 
    result = markOrderCancellationRequestReceived_result()
4084 
    result.read(self._iprot)
4085 
    self._iprot.readMessageEnd()
4086 
    if result.ex is not None:
4087 
      raise result.ex
4088 
    return
4089 
 
4090 
  def markOrderCancellationRequestConfirmed(self, orderId):
4091 
    """
4092 
    If we decide to to cancel order, CRM will call this method to move the status of order to
4093 
    cancellation request confirmed. After this OM will be able to cancel the order.
4094 
 
4095 
    Parameters:
4096 
     - orderId
4097 
    """
4098 
    self.send_markOrderCancellationRequestConfirmed(orderId)
4099 
    self.recv_markOrderCancellationRequestConfirmed()
4100 
 
4101 
  def send_markOrderCancellationRequestConfirmed(self, orderId):
4102 
    self._oprot.writeMessageBegin('markOrderCancellationRequestConfirmed', TMessageType.CALL, self._seqid)
4103 
    args = markOrderCancellationRequestConfirmed_args()
4104 
    args.orderId = orderId
4105 
    args.write(self._oprot)
4106 
    self._oprot.writeMessageEnd()
4107 
    self._oprot.trans.flush()
4108 
 
4109 
  def recv_markOrderCancellationRequestConfirmed(self, ):
4110 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4111 
    if mtype == TMessageType.EXCEPTION:
4112 
      x = TApplicationException()
4113 
      x.read(self._iprot)
4114 
      self._iprot.readMessageEnd()
4115 
      raise x
4116 
    result = markOrderCancellationRequestConfirmed_result()
4117 
    result.read(self._iprot)
4118 
    self._iprot.readMessageEnd()
4119 
    if result.ex is not None:
4120 
      raise result.ex
4121 
    return
4122 
 
4123 
  def markOrderCancellationRequestDenied(self, orderId):
4124 
    """
4125 
    If we decide to not to cancel order, we will move the order ro previous status.
4126 
 
4127 
    Parameters:
4128 
     - orderId
4129 
    """
4130 
    self.send_markOrderCancellationRequestDenied(orderId)
4131 
    self.recv_markOrderCancellationRequestDenied()
4132 
 
4133 
  def send_markOrderCancellationRequestDenied(self, orderId):
4134 
    self._oprot.writeMessageBegin('markOrderCancellationRequestDenied', TMessageType.CALL, self._seqid)
4135 
    args = markOrderCancellationRequestDenied_args()
4136 
    args.orderId = orderId
4137 
    args.write(self._oprot)
4138 
    self._oprot.writeMessageEnd()
4139 
    self._oprot.trans.flush()
4140 
 
4141 
  def recv_markOrderCancellationRequestDenied(self, ):
4142 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4143 
    if mtype == TMessageType.EXCEPTION:
4144 
      x = TApplicationException()
4145 
      x.read(self._iprot)
4146 
      self._iprot.readMessageEnd()
4147 
      raise x
4148 
    result = markOrderCancellationRequestDenied_result()
4149 
    result.read(self._iprot)
4150 
    self._iprot.readMessageEnd()
4151 
    if result.ex is not None:
4152 
      raise result.ex
4153 
    return
4154 
 
4258 rajveer 4155 
  def markTransactionAsPaymentFlagRemoved(self, transactionId):
4247 rajveer 4156 
    """
4258 rajveer 4157 
    If we and/or payment gateway has decided to accept the payment, this method needs to be called.
4158 
    Changed transaction and all orders status to payment accepted.
4247 rajveer 4159 
 
4160 
    Parameters:
4258 rajveer 4161 
     - transactionId
4247 rajveer 4162 
    """
4258 rajveer 4163 
    self.send_markTransactionAsPaymentFlagRemoved(transactionId)
4164 
    self.recv_markTransactionAsPaymentFlagRemoved()
4247 rajveer 4165 
 
4258 rajveer 4166 
  def send_markTransactionAsPaymentFlagRemoved(self, transactionId):
4167 
    self._oprot.writeMessageBegin('markTransactionAsPaymentFlagRemoved', TMessageType.CALL, self._seqid)
4168 
    args = markTransactionAsPaymentFlagRemoved_args()
4169 
    args.transactionId = transactionId
4247 rajveer 4170 
    args.write(self._oprot)
4171 
    self._oprot.writeMessageEnd()
4172 
    self._oprot.trans.flush()
4173 
 
4258 rajveer 4174 
  def recv_markTransactionAsPaymentFlagRemoved(self, ):
4247 rajveer 4175 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4176 
    if mtype == TMessageType.EXCEPTION:
4177 
      x = TApplicationException()
4178 
      x.read(self._iprot)
4179 
      self._iprot.readMessageEnd()
4180 
      raise x
4258 rajveer 4181 
    result = markTransactionAsPaymentFlagRemoved_result()
4247 rajveer 4182 
    result.read(self._iprot)
4183 
    self._iprot.readMessageEnd()
4184 
    if result.ex is not None:
4185 
      raise result.ex
4186 
    return
4187 
 
4259 anupam.sin 4188 
  def refundTransaction(self, transactionId, refundedBy, reason):
4189 
    """
4190 
    This method is called when a flagged payment is deemed unserviceable and the corresponding orders
4191 
    need to be cancelled
4247 rajveer 4192 
 
4259 anupam.sin 4193 
    Parameters:
4194 
     - transactionId
4195 
     - refundedBy
4196 
     - reason
4197 
    """
4198 
    self.send_refundTransaction(transactionId, refundedBy, reason)
4199 
    self.recv_refundTransaction()
4200 
 
4201 
  def send_refundTransaction(self, transactionId, refundedBy, reason):
4202 
    self._oprot.writeMessageBegin('refundTransaction', TMessageType.CALL, self._seqid)
4203 
    args = refundTransaction_args()
4204 
    args.transactionId = transactionId
4205 
    args.refundedBy = refundedBy
4206 
    args.reason = reason
4207 
    args.write(self._oprot)
4208 
    self._oprot.writeMessageEnd()
4209 
    self._oprot.trans.flush()
4210 
 
4211 
  def recv_refundTransaction(self, ):
4212 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4213 
    if mtype == TMessageType.EXCEPTION:
4214 
      x = TApplicationException()
4215 
      x.read(self._iprot)
4216 
      self._iprot.readMessageEnd()
4217 
      raise x
4218 
    result = refundTransaction_result()
4219 
    result.read(self._iprot)
4220 
    self._iprot.readMessageEnd()
4221 
    if result.ex is not None:
4222 
      raise result.ex
4223 
    return
4224 
 
4324 mandeep.dh 4225 
  def updateShipmentAddress(self, orderId, addressId):
4226 
    """
4227 
    Updates shipment address of an order. Delivery and shipping date estimates
4228 
    etc. are also updated here.
4229 
 
4230 
    Throws TransactionServiceException in case address change is not
4231 
    possible due to certain reasons such as new pincode in address is
4232 
    not serviceable etc.
4233 
 
4234 
    Parameters:
4235 
     - orderId
4236 
     - addressId
4237 
    """
4238 
    self.send_updateShipmentAddress(orderId, addressId)
4239 
    self.recv_updateShipmentAddress()
4240 
 
4241 
  def send_updateShipmentAddress(self, orderId, addressId):
4242 
    self._oprot.writeMessageBegin('updateShipmentAddress', TMessageType.CALL, self._seqid)
4243 
    args = updateShipmentAddress_args()
4244 
    args.orderId = orderId
4245 
    args.addressId = addressId
4246 
    args.write(self._oprot)
4247 
    self._oprot.writeMessageEnd()
4248 
    self._oprot.trans.flush()
4249 
 
4250 
  def recv_updateShipmentAddress(self, ):
4251 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4252 
    if mtype == TMessageType.EXCEPTION:
4253 
      x = TApplicationException()
4254 
      x.read(self._iprot)
4255 
      self._iprot.readMessageEnd()
4256 
      raise x
4257 
    result = updateShipmentAddress_result()
4258 
    result.read(self._iprot)
4259 
    self._iprot.readMessageEnd()
4260 
    if result.ex is not None:
4261 
      raise result.ex
4262 
    return
4263 
 
4285 rajveer 4264 
  def acceptOrdersForItemId(self, itemId, inventory):
4265 
    """
4266 
    Marks the orders as ACCEPTED for the given itemId and inventory. It also updates the accepted timestamp. If the
4267 
    given order is not a COD order, it also captures the payment if the same has not been captured.
4259 anupam.sin 4268 
 
4285 rajveer 4269 
    Parameters:
4270 
     - itemId
4271 
     - inventory
4272 
    """
4273 
    self.send_acceptOrdersForItemId(itemId, inventory)
4274 
    return self.recv_acceptOrdersForItemId()
4275 
 
4276 
  def send_acceptOrdersForItemId(self, itemId, inventory):
4277 
    self._oprot.writeMessageBegin('acceptOrdersForItemId', TMessageType.CALL, self._seqid)
4278 
    args = acceptOrdersForItemId_args()
4279 
    args.itemId = itemId
4280 
    args.inventory = inventory
4281 
    args.write(self._oprot)
4282 
    self._oprot.writeMessageEnd()
4283 
    self._oprot.trans.flush()
4284 
 
4285 
  def recv_acceptOrdersForItemId(self, ):
4286 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4287 
    if mtype == TMessageType.EXCEPTION:
4288 
      x = TApplicationException()
4289 
      x.read(self._iprot)
4290 
      self._iprot.readMessageEnd()
4291 
      raise x
4292 
    result = acceptOrdersForItemId_result()
4293 
    result.read(self._iprot)
4294 
    self._iprot.readMessageEnd()
4295 
    if result.success is not None:
4296 
      return result.success
4297 
    if result.ex is not None:
4298 
      raise result.ex
4299 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "acceptOrdersForItemId failed: unknown result");
4300 
 
4369 rajveer 4301 
  def markOrdersAsPORaised(self, vendorId, itemId, quantity, estimate, isReminder):
4303 rajveer 4302 
    """
4303 
    Parameters:
4304 
     - vendorId
4305 
     - itemId
4306 
     - quantity
4307 
     - estimate
4369 rajveer 4308 
     - isReminder
4303 rajveer 4309 
    """
4369 rajveer 4310 
    self.send_markOrdersAsPORaised(vendorId, itemId, quantity, estimate, isReminder)
4303 rajveer 4311 
    self.recv_markOrdersAsPORaised()
4285 rajveer 4312 
 
4369 rajveer 4313 
  def send_markOrdersAsPORaised(self, vendorId, itemId, quantity, estimate, isReminder):
4303 rajveer 4314 
    self._oprot.writeMessageBegin('markOrdersAsPORaised', TMessageType.CALL, self._seqid)
4315 
    args = markOrdersAsPORaised_args()
4316 
    args.vendorId = vendorId
4317 
    args.itemId = itemId
4318 
    args.quantity = quantity
4319 
    args.estimate = estimate
4369 rajveer 4320 
    args.isReminder = isReminder
4303 rajveer 4321 
    args.write(self._oprot)
4322 
    self._oprot.writeMessageEnd()
4323 
    self._oprot.trans.flush()
4324 
 
4325 
  def recv_markOrdersAsPORaised(self, ):
4326 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4327 
    if mtype == TMessageType.EXCEPTION:
4328 
      x = TApplicationException()
4329 
      x.read(self._iprot)
4330 
      self._iprot.readMessageEnd()
4331 
      raise x
4332 
    result = markOrdersAsPORaised_result()
4333 
    result.read(self._iprot)
4334 
    self._iprot.readMessageEnd()
4335 
    if result.ex is not None:
4336 
      raise result.ex
4337 
    return
4338 
 
4369 rajveer 4339 
  def markOrdersAsReversalInitiated(self, vendorId, itemId, quantity, estimate, isReminder):
4303 rajveer 4340 
    """
4341 
    Parameters:
4342 
     - vendorId
4343 
     - itemId
4344 
     - quantity
4345 
     - estimate
4369 rajveer 4346 
     - isReminder
4303 rajveer 4347 
    """
4369 rajveer 4348 
    self.send_markOrdersAsReversalInitiated(vendorId, itemId, quantity, estimate, isReminder)
4303 rajveer 4349 
    self.recv_markOrdersAsReversalInitiated()
4350 
 
4369 rajveer 4351 
  def send_markOrdersAsReversalInitiated(self, vendorId, itemId, quantity, estimate, isReminder):
4303 rajveer 4352 
    self._oprot.writeMessageBegin('markOrdersAsReversalInitiated', TMessageType.CALL, self._seqid)
4353 
    args = markOrdersAsReversalInitiated_args()
4354 
    args.vendorId = vendorId
4355 
    args.itemId = itemId
4356 
    args.quantity = quantity
4357 
    args.estimate = estimate
4369 rajveer 4358 
    args.isReminder = isReminder
4303 rajveer 4359 
    args.write(self._oprot)
4360 
    self._oprot.writeMessageEnd()
4361 
    self._oprot.trans.flush()
4362 
 
4363 
  def recv_markOrdersAsReversalInitiated(self, ):
4364 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4365 
    if mtype == TMessageType.EXCEPTION:
4366 
      x = TApplicationException()
4367 
      x.read(self._iprot)
4368 
      self._iprot.readMessageEnd()
4369 
      raise x
4370 
    result = markOrdersAsReversalInitiated_result()
4371 
    result.read(self._iprot)
4372 
    self._iprot.readMessageEnd()
4373 
    if result.ex is not None:
4374 
      raise result.ex
4375 
    return
4376 
 
4369 rajveer 4377 
  def markOrdersAsNotAvailabke(self, vendorId, itemId, quantity, estimate, isReminder):
4303 rajveer 4378 
    """
4379 
    Parameters:
4380 
     - vendorId
4381 
     - itemId
4382 
     - quantity
4383 
     - estimate
4369 rajveer 4384 
     - isReminder
4303 rajveer 4385 
    """
4369 rajveer 4386 
    self.send_markOrdersAsNotAvailabke(vendorId, itemId, quantity, estimate, isReminder)
4303 rajveer 4387 
    self.recv_markOrdersAsNotAvailabke()
4388 
 
4369 rajveer 4389 
  def send_markOrdersAsNotAvailabke(self, vendorId, itemId, quantity, estimate, isReminder):
4303 rajveer 4390 
    self._oprot.writeMessageBegin('markOrdersAsNotAvailabke', TMessageType.CALL, self._seqid)
4391 
    args = markOrdersAsNotAvailabke_args()
4392 
    args.vendorId = vendorId
4393 
    args.itemId = itemId
4394 
    args.quantity = quantity
4395 
    args.estimate = estimate
4369 rajveer 4396 
    args.isReminder = isReminder
4303 rajveer 4397 
    args.write(self._oprot)
4398 
    self._oprot.writeMessageEnd()
4399 
    self._oprot.trans.flush()
4400 
 
4401 
  def recv_markOrdersAsNotAvailabke(self, ):
4402 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4403 
    if mtype == TMessageType.EXCEPTION:
4404 
      x = TApplicationException()
4405 
      x.read(self._iprot)
4406 
      self._iprot.readMessageEnd()
4407 
      raise x
4408 
    result = markOrdersAsNotAvailabke_result()
4409 
    result.read(self._iprot)
4410 
    self._iprot.readMessageEnd()
4411 
    if result.ex is not None:
4412 
      raise result.ex
4413 
    return
4414 
 
4369 rajveer 4415 
  def markOrdersAsTimeout(self, vendorId):
4416 
    """
4417 
    Parameters:
4418 
     - vendorId
4419 
    """
4420 
    self.send_markOrdersAsTimeout(vendorId)
4421 
    return self.recv_markOrdersAsTimeout()
4303 rajveer 4422 
 
4369 rajveer 4423 
  def send_markOrdersAsTimeout(self, vendorId):
4424 
    self._oprot.writeMessageBegin('markOrdersAsTimeout', TMessageType.CALL, self._seqid)
4425 
    args = markOrdersAsTimeout_args()
4426 
    args.vendorId = vendorId
4427 
    args.write(self._oprot)
4428 
    self._oprot.writeMessageEnd()
4429 
    self._oprot.trans.flush()
4430 
 
4431 
  def recv_markOrdersAsTimeout(self, ):
4432 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4433 
    if mtype == TMessageType.EXCEPTION:
4434 
      x = TApplicationException()
4435 
      x.read(self._iprot)
4436 
      self._iprot.readMessageEnd()
4437 
      raise x
4438 
    result = markOrdersAsTimeout_result()
4439 
    result.read(self._iprot)
4440 
    self._iprot.readMessageEnd()
4441 
    if result.success is not None:
4442 
      return result.success
4443 
    if result.ex is not None:
4444 
      raise result.ex
4445 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "markOrdersAsTimeout failed: unknown result");
4446 
 
4662 rajveer 4447 
  def markOrderAsLostInTransit(self, orderId):
4448 
    """
4449 
    Mark order as LOST_IN_TRANSIT
4450 
 
4451 
    Parameters:
4452 
     - orderId
4453 
    """
4454 
    self.send_markOrderAsLostInTransit(orderId)
4455 
    return self.recv_markOrderAsLostInTransit()
4456 
 
4457 
  def send_markOrderAsLostInTransit(self, orderId):
4458 
    self._oprot.writeMessageBegin('markOrderAsLostInTransit', TMessageType.CALL, self._seqid)
4459 
    args = markOrderAsLostInTransit_args()
4460 
    args.orderId = orderId
4461 
    args.write(self._oprot)
4462 
    self._oprot.writeMessageEnd()
4463 
    self._oprot.trans.flush()
4464 
 
4465 
  def recv_markOrderAsLostInTransit(self, ):
4466 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4467 
    if mtype == TMessageType.EXCEPTION:
4468 
      x = TApplicationException()
4469 
      x.read(self._iprot)
4470 
      self._iprot.readMessageEnd()
4471 
      raise x
4472 
    result = markOrderAsLostInTransit_result()
4473 
    result.read(self._iprot)
4474 
    self._iprot.readMessageEnd()
4475 
    if result.success is not None:
4476 
      return result.success
4477 
    if result.ex is not None:
4478 
      raise result.ex
4479 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "markOrderAsLostInTransit failed: unknown result");
4480 
 
4386 anupam.sin 4481 
  def getOrderForAwb(self, awb):
4482 
    """
4483 
    Returns the order corresponding to an AWB number
4369 rajveer 4484 
 
4386 anupam.sin 4485 
    Parameters:
4486 
     - awb
4487 
    """
4488 
    self.send_getOrderForAwb(awb)
4489 
    return self.recv_getOrderForAwb()
4490 
 
4491 
  def send_getOrderForAwb(self, awb):
4492 
    self._oprot.writeMessageBegin('getOrderForAwb', TMessageType.CALL, self._seqid)
4493 
    args = getOrderForAwb_args()
4494 
    args.awb = awb
4495 
    args.write(self._oprot)
4496 
    self._oprot.writeMessageEnd()
4497 
    self._oprot.trans.flush()
4498 
 
4499 
  def recv_getOrderForAwb(self, ):
4500 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4501 
    if mtype == TMessageType.EXCEPTION:
4502 
      x = TApplicationException()
4503 
      x.read(self._iprot)
4504 
      self._iprot.readMessageEnd()
4505 
      raise x
4506 
    result = getOrderForAwb_result()
4507 
    result.read(self._iprot)
4508 
    self._iprot.readMessageEnd()
4509 
    if result.success is not None:
4510 
      return result.success
4511 
    if result.ex is not None:
4512 
      raise result.ex
4513 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getOrderForAwb failed: unknown result");
4514 
 
4910 phani.kuma 4515 
  def getOrdersForProviderForStatus(self, logistics_provider_id, order_status_list):
4506 phani.kuma 4516 
    """
4910 phani.kuma 4517 
    Returns the order corresponding to a logistics provider id for a given list of order status
4386 anupam.sin 4518 
 
4506 phani.kuma 4519 
    Parameters:
4520 
     - logistics_provider_id
4910 phani.kuma 4521 
     - order_status_list
4506 phani.kuma 4522 
    """
4910 phani.kuma 4523 
    self.send_getOrdersForProviderForStatus(logistics_provider_id, order_status_list)
4506 phani.kuma 4524 
    return self.recv_getOrdersForProviderForStatus()
4525 
 
4910 phani.kuma 4526 
  def send_getOrdersForProviderForStatus(self, logistics_provider_id, order_status_list):
4506 phani.kuma 4527 
    self._oprot.writeMessageBegin('getOrdersForProviderForStatus', TMessageType.CALL, self._seqid)
4528 
    args = getOrdersForProviderForStatus_args()
4529 
    args.logistics_provider_id = logistics_provider_id
4910 phani.kuma 4530 
    args.order_status_list = order_status_list
4506 phani.kuma 4531 
    args.write(self._oprot)
4532 
    self._oprot.writeMessageEnd()
4533 
    self._oprot.trans.flush()
4534 
 
4535 
  def recv_getOrdersForProviderForStatus(self, ):
4536 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4537 
    if mtype == TMessageType.EXCEPTION:
4538 
      x = TApplicationException()
4539 
      x.read(self._iprot)
4540 
      self._iprot.readMessageEnd()
4541 
      raise x
4542 
    result = getOrdersForProviderForStatus_result()
4543 
    result.read(self._iprot)
4544 
    self._iprot.readMessageEnd()
4545 
    if result.success is not None:
4546 
      return result.success
4547 
    if result.ex is not None:
4548 
      raise result.ex
4549 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getOrdersForProviderForStatus failed: unknown result");
4550 
 
4600 varun.gupt 4551 
  def getBilledOrdersForVendor(self, vendorId, billingDateFrom, billingDateTo):
4552 
    """
4553 
    Returns list of orders fullfiled from a certain vendor and billed in a given date range
4506 phani.kuma 4554 
 
4600 varun.gupt 4555 
    Parameters:
4556 
     - vendorId
4557 
     - billingDateFrom
4558 
     - billingDateTo
4559 
    """
4560 
    self.send_getBilledOrdersForVendor(vendorId, billingDateFrom, billingDateTo)
4561 
    return self.recv_getBilledOrdersForVendor()
4562 
 
4563 
  def send_getBilledOrdersForVendor(self, vendorId, billingDateFrom, billingDateTo):
4564 
    self._oprot.writeMessageBegin('getBilledOrdersForVendor', TMessageType.CALL, self._seqid)
4565 
    args = getBilledOrdersForVendor_args()
4566 
    args.vendorId = vendorId
4567 
    args.billingDateFrom = billingDateFrom
4568 
    args.billingDateTo = billingDateTo
4569 
    args.write(self._oprot)
4570 
    self._oprot.writeMessageEnd()
4571 
    self._oprot.trans.flush()
4572 
 
4573 
  def recv_getBilledOrdersForVendor(self, ):
4574 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4575 
    if mtype == TMessageType.EXCEPTION:
4576 
      x = TApplicationException()
4577 
      x.read(self._iprot)
4578 
      self._iprot.readMessageEnd()
4579 
      raise x
4580 
    result = getBilledOrdersForVendor_result()
4581 
    result.read(self._iprot)
4582 
    self._iprot.readMessageEnd()
4583 
    if result.success is not None:
4584 
      return result.success
4585 
    if result.ex is not None:
4586 
      raise result.ex
4587 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getBilledOrdersForVendor failed: unknown result");
4588 
 
4607 rajveer 4589 
  def getSlippedSippingDateOrders(self, ):
4590 
    self.send_getSlippedSippingDateOrders()
4591 
    return self.recv_getSlippedSippingDateOrders()
4592 
 
4593 
  def send_getSlippedSippingDateOrders(self, ):
4594 
    self._oprot.writeMessageBegin('getSlippedSippingDateOrders', TMessageType.CALL, self._seqid)
4595 
    args = getSlippedSippingDateOrders_args()
4596 
    args.write(self._oprot)
4597 
    self._oprot.writeMessageEnd()
4598 
    self._oprot.trans.flush()
4599 
 
4600 
  def recv_getSlippedSippingDateOrders(self, ):
4601 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4602 
    if mtype == TMessageType.EXCEPTION:
4603 
      x = TApplicationException()
4604 
      x.read(self._iprot)
4605 
      self._iprot.readMessageEnd()
4606 
      raise x
4607 
    result = getSlippedSippingDateOrders_result()
4608 
    result.read(self._iprot)
4609 
    self._iprot.readMessageEnd()
4610 
    if result.success is not None:
4611 
      return result.success
4612 
    if result.ex is not None:
4613 
      raise result.ex
4614 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getSlippedSippingDateOrders failed: unknown result");
4615 
 
4709 rajveer 4616 
  def getCancelledOrders(self, cancelDateFrom, cancelDateTo):
4617 
    """
4618 
    Parameters:
4619 
     - cancelDateFrom
4620 
     - cancelDateTo
4621 
    """
4622 
    self.send_getCancelledOrders(cancelDateFrom, cancelDateTo)
4623 
    return self.recv_getCancelledOrders()
4624 
 
4625 
  def send_getCancelledOrders(self, cancelDateFrom, cancelDateTo):
4626 
    self._oprot.writeMessageBegin('getCancelledOrders', TMessageType.CALL, self._seqid)
4627 
    args = getCancelledOrders_args()
4628 
    args.cancelDateFrom = cancelDateFrom
4629 
    args.cancelDateTo = cancelDateTo
4630 
    args.write(self._oprot)
4631 
    self._oprot.writeMessageEnd()
4632 
    self._oprot.trans.flush()
4633 
 
4634 
  def recv_getCancelledOrders(self, ):
4635 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4636 
    if mtype == TMessageType.EXCEPTION:
4637 
      x = TApplicationException()
4638 
      x.read(self._iprot)
4639 
      self._iprot.readMessageEnd()
4640 
      raise x
4641 
    result = getCancelledOrders_result()
4642 
    result.read(self._iprot)
4643 
    self._iprot.readMessageEnd()
4644 
    if result.success is not None:
4645 
      return result.success
4646 
    if result.ex is not None:
4647 
      raise result.ex
4648 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getCancelledOrders failed: unknown result");
4649 
 
4600 varun.gupt 4650 
  def saveBluedartSettlements(self, mapAWBAndAmount):
4651 
    """
4652 
    Parameters:
4653 
     - mapAWBAndAmount
4654 
    """
4655 
    self.send_saveBluedartSettlements(mapAWBAndAmount)
4656 
    self.recv_saveBluedartSettlements()
4657 
 
4658 
  def send_saveBluedartSettlements(self, mapAWBAndAmount):
4659 
    self._oprot.writeMessageBegin('saveBluedartSettlements', TMessageType.CALL, self._seqid)
4660 
    args = saveBluedartSettlements_args()
4661 
    args.mapAWBAndAmount = mapAWBAndAmount
4662 
    args.write(self._oprot)
4663 
    self._oprot.writeMessageEnd()
4664 
    self._oprot.trans.flush()
4665 
 
4666 
  def recv_saveBluedartSettlements(self, ):
4667 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4668 
    if mtype == TMessageType.EXCEPTION:
4669 
      x = TApplicationException()
4670 
      x.read(self._iprot)
4671 
      self._iprot.readMessageEnd()
4672 
      raise x
4673 
    result = saveBluedartSettlements_result()
4674 
    result.read(self._iprot)
4675 
    self._iprot.readMessageEnd()
4676 
    if result.ex is not None:
4677 
      raise result.ex
4678 
    return
4679 
 
4905 varun.gupt 4680 
  def savePaymentSettlements(self, settlementDate, paymentGatewayId, referenceId, serviceTax, otherCharges, netCollection):
4600 varun.gupt 4681 
    """
4682 
    Parameters:
4683 
     - settlementDate
4684 
     - paymentGatewayId
4905 varun.gupt 4685 
     - referenceId
4600 varun.gupt 4686 
     - serviceTax
4687 
     - otherCharges
4688 
     - netCollection
4689 
    """
4905 varun.gupt 4690 
    self.send_savePaymentSettlements(settlementDate, paymentGatewayId, referenceId, serviceTax, otherCharges, netCollection)
4600 varun.gupt 4691 
    self.recv_savePaymentSettlements()
4692 
 
4905 varun.gupt 4693 
  def send_savePaymentSettlements(self, settlementDate, paymentGatewayId, referenceId, serviceTax, otherCharges, netCollection):
4600 varun.gupt 4694 
    self._oprot.writeMessageBegin('savePaymentSettlements', TMessageType.CALL, self._seqid)
4695 
    args = savePaymentSettlements_args()
4696 
    args.settlementDate = settlementDate
4697 
    args.paymentGatewayId = paymentGatewayId
4905 varun.gupt 4698 
    args.referenceId = referenceId
4600 varun.gupt 4699 
    args.serviceTax = serviceTax
4700 
    args.otherCharges = otherCharges
4701 
    args.netCollection = netCollection
4702 
    args.write(self._oprot)
4703 
    self._oprot.writeMessageEnd()
4704 
    self._oprot.trans.flush()
4705 
 
4706 
  def recv_savePaymentSettlements(self, ):
4707 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4708 
    if mtype == TMessageType.EXCEPTION:
4709 
      x = TApplicationException()
4710 
      x.read(self._iprot)
4711 
      self._iprot.readMessageEnd()
4712 
      raise x
4713 
    result = savePaymentSettlements_result()
4714 
    result.read(self._iprot)
4715 
    self._iprot.readMessageEnd()
4716 
    if result.ex is not None:
4717 
      raise result.ex
4718 
    return
4719 
 
4720 
  def saveEBSSettlementSummary(self, settlementId, settlementDate, transactionDateFrom, transactionDateTo, amount):
4721 
    """
4722 
    Parameters:
4723 
     - settlementId
4724 
     - settlementDate
4725 
     - transactionDateFrom
4726 
     - transactionDateTo
4727 
     - amount
4728 
    """
4729 
    self.send_saveEBSSettlementSummary(settlementId, settlementDate, transactionDateFrom, transactionDateTo, amount)
4730 
    self.recv_saveEBSSettlementSummary()
4731 
 
4732 
  def send_saveEBSSettlementSummary(self, settlementId, settlementDate, transactionDateFrom, transactionDateTo, amount):
4733 
    self._oprot.writeMessageBegin('saveEBSSettlementSummary', TMessageType.CALL, self._seqid)
4734 
    args = saveEBSSettlementSummary_args()
4735 
    args.settlementId = settlementId
4736 
    args.settlementDate = settlementDate
4737 
    args.transactionDateFrom = transactionDateFrom
4738 
    args.transactionDateTo = transactionDateTo
4739 
    args.amount = amount
4740 
    args.write(self._oprot)
4741 
    self._oprot.writeMessageEnd()
4742 
    self._oprot.trans.flush()
4743 
 
4744 
  def recv_saveEBSSettlementSummary(self, ):
4745 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4746 
    if mtype == TMessageType.EXCEPTION:
4747 
      x = TApplicationException()
4748 
      x.read(self._iprot)
4749 
      self._iprot.readMessageEnd()
4750 
      raise x
4751 
    result = saveEBSSettlementSummary_result()
4752 
    result.read(self._iprot)
4753 
    self._iprot.readMessageEnd()
4754 
    if result.ex is not None:
4755 
      raise result.ex
4756 
    return
4757 
 
5386 phani.kuma 4758 
  def getSettlementForPrepaid(self, referenceId, isRefund):
4600 varun.gupt 4759 
    """
4760 
    Parameters:
5189 varun.gupt 4761 
     - referenceId
4762 
     - isRefund
4600 varun.gupt 4763 
    """
5386 phani.kuma 4764 
    self.send_getSettlementForPrepaid(referenceId, isRefund)
4765 
    return self.recv_getSettlementForPrepaid()
4600 varun.gupt 4766 
 
5386 phani.kuma 4767 
  def send_getSettlementForPrepaid(self, referenceId, isRefund):
4768 
    self._oprot.writeMessageBegin('getSettlementForPrepaid', TMessageType.CALL, self._seqid)
4769 
    args = getSettlementForPrepaid_args()
5189 varun.gupt 4770 
    args.referenceId = referenceId
4771 
    args.isRefund = isRefund
4600 varun.gupt 4772 
    args.write(self._oprot)
4773 
    self._oprot.writeMessageEnd()
4774 
    self._oprot.trans.flush()
4775 
 
5386 phani.kuma 4776 
  def recv_getSettlementForPrepaid(self, ):
4600 varun.gupt 4777 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4778 
    if mtype == TMessageType.EXCEPTION:
4779 
      x = TApplicationException()
4780 
      x.read(self._iprot)
4781 
      self._iprot.readMessageEnd()
4782 
      raise x
5386 phani.kuma 4783 
    result = getSettlementForPrepaid_result()
4600 varun.gupt 4784 
    result.read(self._iprot)
4785 
    self._iprot.readMessageEnd()
4786 
    if result.success is not None:
4787 
      return result.success
4788 
    if result.ex is not None:
4789 
      raise result.ex
5386 phani.kuma 4790 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getSettlementForPrepaid failed: unknown result");
4600 varun.gupt 4791 
 
5386 phani.kuma 4792 
  def getSettlementForCod(self, orderId, isRefund):
4793 
    """
4794 
    Parameters:
4795 
     - orderId
4796 
     - isRefund
4797 
    """
4798 
    self.send_getSettlementForCod(orderId, isRefund)
4799 
    return self.recv_getSettlementForCod()
4800 
 
4801 
  def send_getSettlementForCod(self, orderId, isRefund):
4802 
    self._oprot.writeMessageBegin('getSettlementForCod', TMessageType.CALL, self._seqid)
4803 
    args = getSettlementForCod_args()
4804 
    args.orderId = orderId
4805 
    args.isRefund = isRefund
4806 
    args.write(self._oprot)
4807 
    self._oprot.writeMessageEnd()
4808 
    self._oprot.trans.flush()
4809 
 
4810 
  def recv_getSettlementForCod(self, ):
4811 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4812 
    if mtype == TMessageType.EXCEPTION:
4813 
      x = TApplicationException()
4814 
      x.read(self._iprot)
4815 
      self._iprot.readMessageEnd()
4816 
      raise x
4817 
    result = getSettlementForCod_result()
4818 
    result.read(self._iprot)
4819 
    self._iprot.readMessageEnd()
4820 
    if result.success is not None:
4821 
      return result.success
4822 
    if result.ex is not None:
4823 
      raise result.ex
4824 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getSettlementForCod failed: unknown result");
4825 
 
4600 varun.gupt 4826 
  def getEBSSettlementSummaries(self, ):
4827 
    self.send_getEBSSettlementSummaries()
4828 
    return self.recv_getEBSSettlementSummaries()
4829 
 
4830 
  def send_getEBSSettlementSummaries(self, ):
4831 
    self._oprot.writeMessageBegin('getEBSSettlementSummaries', TMessageType.CALL, self._seqid)
4832 
    args = getEBSSettlementSummaries_args()
4833 
    args.write(self._oprot)
4834 
    self._oprot.writeMessageEnd()
4835 
    self._oprot.trans.flush()
4836 
 
4837 
  def recv_getEBSSettlementSummaries(self, ):
4838 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4839 
    if mtype == TMessageType.EXCEPTION:
4840 
      x = TApplicationException()
4841 
      x.read(self._iprot)
4842 
      self._iprot.readMessageEnd()
4843 
      raise x
4844 
    result = getEBSSettlementSummaries_result()
4845 
    result.read(self._iprot)
4846 
    self._iprot.readMessageEnd()
4847 
    if result.success is not None:
4848 
      return result.success
4849 
    if result.ex is not None:
4850 
      raise result.ex
4851 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getEBSSettlementSummaries failed: unknown result");
4852 
 
4853 
  def markEBSSettlementUploaded(self, settlementId):
4854 
    """
4855 
    Parameters:
4856 
     - settlementId
4857 
    """
4858 
    self.send_markEBSSettlementUploaded(settlementId)
4859 
    self.recv_markEBSSettlementUploaded()
4860 
 
4861 
  def send_markEBSSettlementUploaded(self, settlementId):
4862 
    self._oprot.writeMessageBegin('markEBSSettlementUploaded', TMessageType.CALL, self._seqid)
4863 
    args = markEBSSettlementUploaded_args()
4864 
    args.settlementId = settlementId
4865 
    args.write(self._oprot)
4866 
    self._oprot.writeMessageEnd()
4867 
    self._oprot.trans.flush()
4868 
 
4869 
  def recv_markEBSSettlementUploaded(self, ):
4870 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4871 
    if mtype == TMessageType.EXCEPTION:
4872 
      x = TApplicationException()
4873 
      x.read(self._iprot)
4874 
      self._iprot.readMessageEnd()
4875 
      raise x
4876 
    result = markEBSSettlementUploaded_result()
4877 
    result.read(self._iprot)
4878 
    self._iprot.readMessageEnd()
4879 
    if result.ex is not None:
4880 
      raise result.ex
4881 
    return
4882 
 
4883 
  def getEBSSettlementDate(self, settlementId):
4884 
    """
4885 
    Parameters:
4886 
     - settlementId
4887 
    """
4888 
    self.send_getEBSSettlementDate(settlementId)
4889 
    return self.recv_getEBSSettlementDate()
4890 
 
4891 
  def send_getEBSSettlementDate(self, settlementId):
4892 
    self._oprot.writeMessageBegin('getEBSSettlementDate', TMessageType.CALL, self._seqid)
4893 
    args = getEBSSettlementDate_args()
4894 
    args.settlementId = settlementId
4895 
    args.write(self._oprot)
4896 
    self._oprot.writeMessageEnd()
4897 
    self._oprot.trans.flush()
4898 
 
4899 
  def recv_getEBSSettlementDate(self, ):
4900 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4901 
    if mtype == TMessageType.EXCEPTION:
4902 
      x = TApplicationException()
4903 
      x.read(self._iprot)
4904 
      self._iprot.readMessageEnd()
4905 
      raise x
4906 
    result = getEBSSettlementDate_result()
4907 
    result.read(self._iprot)
4908 
    self._iprot.readMessageEnd()
4909 
    if result.success is not None:
4910 
      return result.success
4911 
    if result.ex is not None:
4912 
      raise result.ex
4913 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getEBSSettlementDate failed: unknown result");
4914 
 
4715 varun.gupt 4915 
  def getSettlementsByDate(self, settlementDateFrom, settlementDateTo, isRefund):
4916 
    """
4917 
    Parameters:
4918 
     - settlementDateFrom
4919 
     - settlementDateTo
4920 
     - isRefund
4921 
    """
4922 
    self.send_getSettlementsByDate(settlementDateFrom, settlementDateTo, isRefund)
4923 
    return self.recv_getSettlementsByDate()
4600 varun.gupt 4924 
 
4715 varun.gupt 4925 
  def send_getSettlementsByDate(self, settlementDateFrom, settlementDateTo, isRefund):
4926 
    self._oprot.writeMessageBegin('getSettlementsByDate', TMessageType.CALL, self._seqid)
4927 
    args = getSettlementsByDate_args()
4928 
    args.settlementDateFrom = settlementDateFrom
4929 
    args.settlementDateTo = settlementDateTo
4930 
    args.isRefund = isRefund
4931 
    args.write(self._oprot)
4932 
    self._oprot.writeMessageEnd()
4933 
    self._oprot.trans.flush()
4934 
 
4935 
  def recv_getSettlementsByDate(self, ):
4936 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4937 
    if mtype == TMessageType.EXCEPTION:
4938 
      x = TApplicationException()
4939 
      x.read(self._iprot)
4940 
      self._iprot.readMessageEnd()
4941 
      raise x
4942 
    result = getSettlementsByDate_result()
4943 
    result.read(self._iprot)
4944 
    self._iprot.readMessageEnd()
4945 
    if result.success is not None:
4946 
      return result.success
4947 
    if result.ex is not None:
4948 
      raise result.ex
4949 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getSettlementsByDate failed: unknown result");
4950 
 
4951 
  def getReshippedOrderIds(self, orderIds):
4952 
    """
4953 
    Returns list of Order Ids, which belong to reshiped orders, shortlisted from a given list of Order Ids
4954 
 
4955 
    Parameters:
4956 
     - orderIds
4957 
    """
4958 
    self.send_getReshippedOrderIds(orderIds)
4959 
    return self.recv_getReshippedOrderIds()
4960 
 
4961 
  def send_getReshippedOrderIds(self, orderIds):
4962 
    self._oprot.writeMessageBegin('getReshippedOrderIds', TMessageType.CALL, self._seqid)
4963 
    args = getReshippedOrderIds_args()
4964 
    args.orderIds = orderIds
4965 
    args.write(self._oprot)
4966 
    self._oprot.writeMessageEnd()
4967 
    self._oprot.trans.flush()
4968 
 
4969 
  def recv_getReshippedOrderIds(self, ):
4970 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4971 
    if mtype == TMessageType.EXCEPTION:
4972 
      x = TApplicationException()
4973 
      x.read(self._iprot)
4974 
      self._iprot.readMessageEnd()
4975 
      raise x
4976 
    result = getReshippedOrderIds_result()
4977 
    result.read(self._iprot)
4978 
    self._iprot.readMessageEnd()
4979 
    if result.success is not None:
4980 
      return result.success
4981 
    if result.ex is not None:
4982 
      raise result.ex
4983 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getReshippedOrderIds failed: unknown result");
4984 
 
5481 phani.kuma 4985 
  def getBilledOrders(self, vendorId, onlyVendorNotPaid, billingDateFrom, billingDateTo):
4875 varun.gupt 4986 
    """
4987 
    Parameters:
4988 
     - vendorId
5481 phani.kuma 4989 
     - onlyVendorNotPaid
4990 
     - billingDateFrom
4991 
     - billingDateTo
4875 varun.gupt 4992 
    """
5481 phani.kuma 4993 
    self.send_getBilledOrders(vendorId, onlyVendorNotPaid, billingDateFrom, billingDateTo)
4994 
    return self.recv_getBilledOrders()
4757 mandeep.dh 4995 
 
5481 phani.kuma 4996 
  def send_getBilledOrders(self, vendorId, onlyVendorNotPaid, billingDateFrom, billingDateTo):
4997 
    self._oprot.writeMessageBegin('getBilledOrders', TMessageType.CALL, self._seqid)
4998 
    args = getBilledOrders_args()
4875 varun.gupt 4999 
    args.vendorId = vendorId
5481 phani.kuma 5000 
    args.onlyVendorNotPaid = onlyVendorNotPaid
5001 
    args.billingDateFrom = billingDateFrom
5002 
    args.billingDateTo = billingDateTo
4875 varun.gupt 5003 
    args.write(self._oprot)
5004 
    self._oprot.writeMessageEnd()
5005 
    self._oprot.trans.flush()
5006 
 
5481 phani.kuma 5007 
  def recv_getBilledOrders(self, ):
4875 varun.gupt 5008 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
5009 
    if mtype == TMessageType.EXCEPTION:
5010 
      x = TApplicationException()
5011 
      x.read(self._iprot)
5012 
      self._iprot.readMessageEnd()
5013 
      raise x
5481 phani.kuma 5014 
    result = getBilledOrders_result()
4875 varun.gupt 5015 
    result.read(self._iprot)
5016 
    self._iprot.readMessageEnd()
5017 
    if result.success is not None:
5018 
      return result.success
5019 
    if result.ex is not None:
5020 
      raise result.ex
5481 phani.kuma 5021 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getBilledOrders failed: unknown result");
4875 varun.gupt 5022 
 
5031 varun.gupt 5023 
  def getStatusDistributionOfOrders(self, startDate, endDate):
5024 
    """
5025 
    Parameters:
5026 
     - startDate
5027 
     - endDate
5028 
    """
5029 
    self.send_getStatusDistributionOfOrders(startDate, endDate)
5030 
    return self.recv_getStatusDistributionOfOrders()
4875 varun.gupt 5031 
 
5031 varun.gupt 5032 
  def send_getStatusDistributionOfOrders(self, startDate, endDate):
5033 
    self._oprot.writeMessageBegin('getStatusDistributionOfOrders', TMessageType.CALL, self._seqid)
5034 
    args = getStatusDistributionOfOrders_args()
5035 
    args.startDate = startDate
5036 
    args.endDate = endDate
5037 
    args.write(self._oprot)
5038 
    self._oprot.writeMessageEnd()
5039 
    self._oprot.trans.flush()
5040 
 
5041 
  def recv_getStatusDistributionOfOrders(self, ):
5042 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
5043 
    if mtype == TMessageType.EXCEPTION:
5044 
      x = TApplicationException()
5045 
      x.read(self._iprot)
5046 
      self._iprot.readMessageEnd()
5047 
      raise x
5048 
    result = getStatusDistributionOfOrders_result()
5049 
    result.read(self._iprot)
5050 
    self._iprot.readMessageEnd()
5051 
    if result.success is not None:
5052 
      return result.success
5053 
    if result.ex is not None:
5054 
      raise result.ex
5055 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getStatusDistributionOfOrders failed: unknown result");
5056 
 
5067 varun.gupt 5057 
  def getOrderIdsForStatus(self, status, startDatetime, endDatetime):
5058 
    """
5059 
    Parameters:
5060 
     - status
5061 
     - startDatetime
5062 
     - endDatetime
5063 
    """
5064 
    self.send_getOrderIdsForStatus(status, startDatetime, endDatetime)
5065 
    return self.recv_getOrderIdsForStatus()
5031 varun.gupt 5066 
 
5067 varun.gupt 5067 
  def send_getOrderIdsForStatus(self, status, startDatetime, endDatetime):
5068 
    self._oprot.writeMessageBegin('getOrderIdsForStatus', TMessageType.CALL, self._seqid)
5069 
    args = getOrderIdsForStatus_args()
5070 
    args.status = status
5071 
    args.startDatetime = startDatetime
5072 
    args.endDatetime = endDatetime
5073 
    args.write(self._oprot)
5074 
    self._oprot.writeMessageEnd()
5075 
    self._oprot.trans.flush()
5076 
 
5077 
  def recv_getOrderIdsForStatus(self, ):
5078 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
5079 
    if mtype == TMessageType.EXCEPTION:
5080 
      x = TApplicationException()
5081 
      x.read(self._iprot)
5082 
      self._iprot.readMessageEnd()
5083 
      raise x
5084 
    result = getOrderIdsForStatus_result()
5085 
    result.read(self._iprot)
5086 
    self._iprot.readMessageEnd()
5087 
    if result.success is not None:
5088 
      return result.success
5089 
    if result.ex is not None:
5090 
      raise result.ex
5091 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getOrderIdsForStatus failed: unknown result");
5092 
 
5348 anupam.sin 5093 
  def updateCODAgent(self, agent, orderId):
5094 
    """
5095 
    Updates the agent who handled the COD verification call
5096 
 
5097 
    Parameters:
5098 
     - agent
5099 
     - orderId
5100 
    """
5101 
    self.send_updateCODAgent(agent, orderId)
5102 
    self.recv_updateCODAgent()
5103 
 
5104 
  def send_updateCODAgent(self, agent, orderId):
5105 
    self._oprot.writeMessageBegin('updateCODAgent', TMessageType.CALL, self._seqid)
5106 
    args = updateCODAgent_args()
5107 
    args.agent = agent
5108 
    args.orderId = orderId
5109 
    args.write(self._oprot)
5110 
    self._oprot.writeMessageEnd()
5111 
    self._oprot.trans.flush()
5112 
 
5113 
  def recv_updateCODAgent(self, ):
5114 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
5115 
    if mtype == TMessageType.EXCEPTION:
5116 
      x = TApplicationException()
5117 
      x.read(self._iprot)
5118 
      self._iprot.readMessageEnd()
5119 
      raise x
5120 
    result = updateCODAgent_result()
5121 
    result.read(self._iprot)
5122 
    self._iprot.readMessageEnd()
5123 
    if result.ex is not None:
5124 
      raise result.ex
5125 
    return
5126 
 
5099 varun.gupt 5127 
  def updateOrderAsPaidToVendor(self, orderId):
5128 
    """
5129 
    Parameters:
5130 
     - orderId
5131 
    """
5132 
    self.send_updateOrderAsPaidToVendor(orderId)
5133 
    self.recv_updateOrderAsPaidToVendor()
5067 varun.gupt 5134 
 
5099 varun.gupt 5135 
  def send_updateOrderAsPaidToVendor(self, orderId):
5136 
    self._oprot.writeMessageBegin('updateOrderAsPaidToVendor', TMessageType.CALL, self._seqid)
5137 
    args = updateOrderAsPaidToVendor_args()
5138 
    args.orderId = orderId
5139 
    args.write(self._oprot)
5140 
    self._oprot.writeMessageEnd()
5141 
    self._oprot.trans.flush()
5142 
 
5143 
  def recv_updateOrderAsPaidToVendor(self, ):
5144 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
5145 
    if mtype == TMessageType.EXCEPTION:
5146 
      x = TApplicationException()
5147 
      x.read(self._iprot)
5148 
      self._iprot.readMessageEnd()
5149 
      raise x
5150 
    result = updateOrderAsPaidToVendor_result()
5151 
    result.read(self._iprot)
5152 
    self._iprot.readMessageEnd()
5153 
    if result.ex is not None:
5154 
      raise result.ex
5155 
    return
5156 
 
5386 phani.kuma 5157 
  def updateOrderOnlyAsPaidToVendor(self, orderId):
5158 
    """
5159 
    Parameters:
5160 
     - orderId
5161 
    """
5162 
    self.send_updateOrderOnlyAsPaidToVendor(orderId)
5163 
    self.recv_updateOrderOnlyAsPaidToVendor()
5164 
 
5165 
  def send_updateOrderOnlyAsPaidToVendor(self, orderId):
5166 
    self._oprot.writeMessageBegin('updateOrderOnlyAsPaidToVendor', TMessageType.CALL, self._seqid)
5167 
    args = updateOrderOnlyAsPaidToVendor_args()
5168 
    args.orderId = orderId
5169 
    args.write(self._oprot)
5170 
    self._oprot.writeMessageEnd()
5171 
    self._oprot.trans.flush()
5172 
 
5173 
  def recv_updateOrderOnlyAsPaidToVendor(self, ):
5174 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
5175 
    if mtype == TMessageType.EXCEPTION:
5176 
      x = TApplicationException()
5177 
      x.read(self._iprot)
5178 
      self._iprot.readMessageEnd()
5179 
      raise x
5180 
    result = updateOrderOnlyAsPaidToVendor_result()
5181 
    result.read(self._iprot)
5182 
    self._iprot.readMessageEnd()
5183 
    if result.ex is not None:
5184 
      raise result.ex
5185 
    return
5186 
 
5208 varun.gupt 5187 
  def getRefundedOrdersMarkedPaid(self, ):
5188 
    self.send_getRefundedOrdersMarkedPaid()
5189 
    return self.recv_getRefundedOrdersMarkedPaid()
5099 varun.gupt 5190 
 
5208 varun.gupt 5191 
  def send_getRefundedOrdersMarkedPaid(self, ):
5192 
    self._oprot.writeMessageBegin('getRefundedOrdersMarkedPaid', TMessageType.CALL, self._seqid)
5193 
    args = getRefundedOrdersMarkedPaid_args()
5194 
    args.write(self._oprot)
5195 
    self._oprot.writeMessageEnd()
5196 
    self._oprot.trans.flush()
5197 
 
5198 
  def recv_getRefundedOrdersMarkedPaid(self, ):
5199 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
5200 
    if mtype == TMessageType.EXCEPTION:
5201 
      x = TApplicationException()
5202 
      x.read(self._iprot)
5203 
      self._iprot.readMessageEnd()
5204 
      raise x
5205 
    result = getRefundedOrdersMarkedPaid_result()
5206 
    result.read(self._iprot)
5207 
    self._iprot.readMessageEnd()
5208 
    if result.success is not None:
5209 
      return result.success
5210 
    if result.ex is not None:
5211 
      raise result.ex
5212 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getRefundedOrdersMarkedPaid failed: unknown result");
5213 
 
5447 anupam.sin 5214 
  def getAllVerificationAgents(self, minOrderId, maxOrderId):
5215 
    """
5216 
    gets all COD Verification Agents for all orderIds from a minId to maxId
5208 varun.gupt 5217 
 
5447 anupam.sin 5218 
 
5219 
    Parameters:
5220 
     - minOrderId
5221 
     - maxOrderId
5222 
    """
5223 
    self.send_getAllVerificationAgents(minOrderId, maxOrderId)
5224 
    return self.recv_getAllVerificationAgents()
5225 
 
5226 
  def send_getAllVerificationAgents(self, minOrderId, maxOrderId):
5227 
    self._oprot.writeMessageBegin('getAllVerificationAgents', TMessageType.CALL, self._seqid)
5228 
    args = getAllVerificationAgents_args()
5229 
    args.minOrderId = minOrderId
5230 
    args.maxOrderId = maxOrderId
5231 
    args.write(self._oprot)
5232 
    self._oprot.writeMessageEnd()
5233 
    self._oprot.trans.flush()
5234 
 
5235 
  def recv_getAllVerificationAgents(self, ):
5236 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
5237 
    if mtype == TMessageType.EXCEPTION:
5238 
      x = TApplicationException()
5239 
      x.read(self._iprot)
5240 
      self._iprot.readMessageEnd()
5241 
      raise x
5242 
    result = getAllVerificationAgents_result()
5243 
    result.read(self._iprot)
5244 
    self._iprot.readMessageEnd()
5245 
    if result.success is not None:
5246 
      return result.success
5247 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAllVerificationAgents failed: unknown result");
5248 
 
5527 anupam.sin 5249 
  def getAllAttributesForOrderId(self, orderId):
5250 
    """
5251 
    gets all attributes for a given orderId
5447 anupam.sin 5252 
 
5527 anupam.sin 5253 
    Parameters:
5254 
     - orderId
5255 
    """
5256 
    self.send_getAllAttributesForOrderId(orderId)
5257 
    return self.recv_getAllAttributesForOrderId()
5258 
 
5259 
  def send_getAllAttributesForOrderId(self, orderId):
5260 
    self._oprot.writeMessageBegin('getAllAttributesForOrderId', TMessageType.CALL, self._seqid)
5261 
    args = getAllAttributesForOrderId_args()
5262 
    args.orderId = orderId
5263 
    args.write(self._oprot)
5264 
    self._oprot.writeMessageEnd()
5265 
    self._oprot.trans.flush()
5266 
 
5267 
  def recv_getAllAttributesForOrderId(self, ):
5268 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
5269 
    if mtype == TMessageType.EXCEPTION:
5270 
      x = TApplicationException()
5271 
      x.read(self._iprot)
5272 
      self._iprot.readMessageEnd()
5273 
      raise x
5274 
    result = getAllAttributesForOrderId_result()
5275 
    result.read(self._iprot)
5276 
    self._iprot.readMessageEnd()
5277 
    if result.success is not None:
5278 
      return result.success
5279 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAllAttributesForOrderId failed: unknown result");
5280 
 
5281 
  def setOrderAttributeForTransaction(self, transactionId, attribute):
5282 
    """
5283 
    sets attributes for all orders in a transaction
5284 
 
5285 
    Parameters:
5286 
     - transactionId
5287 
     - attribute
5288 
    """
5289 
    self.send_setOrderAttributeForTransaction(transactionId, attribute)
5290 
    self.recv_setOrderAttributeForTransaction()
5291 
 
5292 
  def send_setOrderAttributeForTransaction(self, transactionId, attribute):
5293 
    self._oprot.writeMessageBegin('setOrderAttributeForTransaction', TMessageType.CALL, self._seqid)
5294 
    args = setOrderAttributeForTransaction_args()
5295 
    args.transactionId = transactionId
5296 
    args.attribute = attribute
5297 
    args.write(self._oprot)
5298 
    self._oprot.writeMessageEnd()
5299 
    self._oprot.trans.flush()
5300 
 
5301 
  def recv_setOrderAttributeForTransaction(self, ):
5302 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
5303 
    if mtype == TMessageType.EXCEPTION:
5304 
      x = TApplicationException()
5305 
      x.read(self._iprot)
5306 
      self._iprot.readMessageEnd()
5307 
      raise x
5308 
    result = setOrderAttributeForTransaction_result()
5309 
    result.read(self._iprot)
5310 
    self._iprot.readMessageEnd()
5311 
    return
5312 
 
5313 
 
3376 rajveer 5314 
class Processor(shop2020.thriftpy.generic.GenericService.Processor, Iface, TProcessor):
94 ashish 5315 
  def __init__(self, handler):
3376 rajveer 5316 
    shop2020.thriftpy.generic.GenericService.Processor.__init__(self, handler)
94 ashish 5317 
    self._processMap["createTransaction"] = Processor.process_createTransaction
5318 
    self._processMap["getTransaction"] = Processor.process_getTransaction
5319 
    self._processMap["getTransactionsForCustomer"] = Processor.process_getTransactionsForCustomer
132 ashish 5320 
    self._processMap["getTransactionsForShoppingCartId"] = Processor.process_getTransactionsForShoppingCartId
94 ashish 5321 
    self._processMap["getTransactionStatus"] = Processor.process_getTransactionStatus
5322 
    self._processMap["changeTransactionStatus"] = Processor.process_changeTransactionStatus
1398 varun.gupt 5323 
    self._processMap["enqueueTransactionInfoEmail"] = Processor.process_enqueueTransactionInfoEmail
483 rajveer 5324 
    self._processMap["getAllOrders"] = Processor.process_getAllOrders
4133 chandransh 5325 
    self._processMap["getOrdersInBatch"] = Processor.process_getOrdersInBatch
5326 
    self._processMap["getOrderCount"] = Processor.process_getOrderCount
999 varun.gupt 5327 
    self._processMap["getOrdersByBillingDate"] = Processor.process_getOrdersByBillingDate
3427 chandransh 5328 
    self._processMap["getOrdersByShippingDate"] = Processor.process_getOrdersByShippingDate
1382 varun.gupt 5329 
    self._processMap["getReturnableOrdersForCustomer"] = Processor.process_getReturnableOrdersForCustomer
5330 
    self._processMap["getCancellableOrdersForCustomer"] = Processor.process_getCancellableOrdersForCustomer
483 rajveer 5331 
    self._processMap["changeOrderStatus"] = Processor.process_changeOrderStatus
5332 
    self._processMap["getOrdersForTransaction"] = Processor.process_getOrdersForTransaction
5333 
    self._processMap["getOrdersForCustomer"] = Processor.process_getOrdersForCustomer
5334 
    self._processMap["createOrder"] = Processor.process_createOrder
5335 
    self._processMap["getOrder"] = Processor.process_getOrder
5336 
    self._processMap["getLineItemsForOrder"] = Processor.process_getLineItemsForOrder
4999 phani.kuma 5337 
    self._processMap["getOrderList"] = Processor.process_getOrderList
5386 phani.kuma 5338 
    self._processMap["getOrderListForVendor"] = Processor.process_getOrderListForVendor
1528 ankur.sing 5339 
    self._processMap["getOrderForCustomer"] = Processor.process_getOrderForCustomer
3064 chandransh 5340 
    self._processMap["getAlerts"] = Processor.process_getAlerts
4394 rajveer 5341 
    self._processMap["addAlert"] = Processor.process_addAlert
4444 rajveer 5342 
    self._processMap["markAlertsAsSeen"] = Processor.process_markAlertsAsSeen
3064 chandransh 5343 
    self._processMap["getValidOrderCount"] = Processor.process_getValidOrderCount
5344 
    self._processMap["getNoOfCustomersWithSuccessfulTransaction"] = Processor.process_getNoOfCustomersWithSuccessfulTransaction
5345 
    self._processMap["getValidOrdersAmountRange"] = Processor.process_getValidOrdersAmountRange
5346 
    self._processMap["getValidOrders"] = Processor.process_getValidOrders
1220 chandransh 5347 
    self._processMap["batchOrders"] = Processor.process_batchOrders
1208 chandransh 5348 
    self._processMap["markOrderAsOutOfStock"] = Processor.process_markOrderAsOutOfStock
3064 chandransh 5349 
    self._processMap["verifyOrder"] = Processor.process_verifyOrder
5350 
    self._processMap["acceptOrder"] = Processor.process_acceptOrder
5351 
    self._processMap["addBillingDetails"] = Processor.process_addBillingDetails
4579 rajveer 5352 
    self._processMap["addInvoiceNumber"] = Processor.process_addInvoiceNumber
4410 rajveer 5353 
    self._processMap["markOrdersAsShippedFromWarehouse"] = Processor.process_markOrdersAsShippedFromWarehouse
1113 chandransh 5354 
    self._processMap["markOrdersAsPickedUp"] = Processor.process_markOrdersAsPickedUp
4910 phani.kuma 5355 
    self._processMap["getOrdersNotPickedUp"] = Processor.process_getOrdersNotPickedUp
1132 chandransh 5356 
    self._processMap["markOrdersAsDelivered"] = Processor.process_markOrdersAsDelivered
4910 phani.kuma 5357 
    self._processMap["markAsRTOrders"] = Processor.process_markAsRTOrders
5358 
    self._processMap["getRTOrders"] = Processor.process_getRTOrders
1246 chandransh 5359 
    self._processMap["updateNonDeliveryReason"] = Processor.process_updateNonDeliveryReason
4910 phani.kuma 5360 
    self._processMap["getNonDeliveredOrdersbyCourier"] = Processor.process_getNonDeliveredOrdersbyCourier
5361 
    self._processMap["markOrdersAsLocalConnected"] = Processor.process_markOrdersAsLocalConnected
5362 
    self._processMap["getOrdersNotLocalConnected"] = Processor.process_getOrdersNotLocalConnected
5363 
    self._processMap["markOrdersAsDestinationCityReached"] = Processor.process_markOrdersAsDestinationCityReached
5364 
    self._processMap["markOrdersAsFirstDeliveryAttempted"] = Processor.process_markOrdersAsFirstDeliveryAttempted
1408 ankur.sing 5365 
    self._processMap["getUndeliveredOrders"] = Processor.process_getUndeliveredOrders
4783 phani.kuma 5366 
    self._processMap["getUndeliveredOrdersExpectedDeliveryDateNotMet"] = Processor.process_getUndeliveredOrdersExpectedDeliveryDateNotMet
2536 chandransh 5367 
    self._processMap["toggleDOAFlag"] = Processor.process_toggleDOAFlag
4712 rajveer 5368 
    self._processMap["markOrderAsDelivered"] = Processor.process_markOrderAsDelivered
4454 rajveer 5369 
    self._processMap["markOrderDoaRequestReceived"] = Processor.process_markOrderDoaRequestReceived
5370 
    self._processMap["markOrderDoaRequestAuthorized"] = Processor.process_markOrderDoaRequestAuthorized
4488 rajveer 5371 
    self._processMap["markOrderReturnRequestReceived"] = Processor.process_markOrderReturnRequestReceived
5372 
    self._processMap["markOrderReturnRequestAuthorized"] = Processor.process_markOrderReturnRequestAuthorized
2536 chandransh 5373 
    self._processMap["requestPickupNumber"] = Processor.process_requestPickupNumber
5374 
    self._processMap["authorizePickup"] = Processor.process_authorizePickup
2764 chandransh 5375 
    self._processMap["markDoasAsPickedUp"] = Processor.process_markDoasAsPickedUp
4910 phani.kuma 5376 
    self._processMap["getDoasNotPickedUp"] = Processor.process_getDoasNotPickedUp
4741 phani.kuma 5377 
    self._processMap["markReturnOrdersAsPickedUp"] = Processor.process_markReturnOrdersAsPickedUp
4910 phani.kuma 5378 
    self._processMap["getReturnOrdersNotPickedUp"] = Processor.process_getReturnOrdersNotPickedUp
2616 chandransh 5379 
    self._processMap["receiveReturn"] = Processor.process_receiveReturn
2591 chandransh 5380 
    self._processMap["validateDoa"] = Processor.process_validateDoa
4495 rajveer 5381 
    self._processMap["validateReturnProduct"] = Processor.process_validateReturnProduct
2616 chandransh 5382 
    self._processMap["reshipOrder"] = Processor.process_reshipOrder
5383 
    self._processMap["refundOrder"] = Processor.process_refundOrder
2690 chandransh 5384 
    self._processMap["getReturnOrders"] = Processor.process_getReturnOrders
5481 phani.kuma 5385 
    self._processMap["getAllReturnOrders"] = Processor.process_getAllReturnOrders
2700 chandransh 5386 
    self._processMap["getReturnOrder"] = Processor.process_getReturnOrder
2690 chandransh 5387 
    self._processMap["processReturn"] = Processor.process_processReturn
3451 chandransh 5388 
    self._processMap["updateWeight"] = Processor.process_updateWeight
3469 chandransh 5389 
    self._processMap["changeItem"] = Processor.process_changeItem
5390 
    self._processMap["shiftToWarehouse"] = Processor.process_shiftToWarehouse
3553 chandransh 5391 
    self._processMap["addDelayReason"] = Processor.process_addDelayReason
3956 chandransh 5392 
    self._processMap["reconcileCodCollection"] = Processor.process_reconcileCodCollection
4008 mandeep.dh 5393 
    self._processMap["getTransactionsRequiringExtraProcessing"] = Processor.process_getTransactionsRequiringExtraProcessing
5394 
    self._processMap["markTransactionAsProcessed"] = Processor.process_markTransactionAsProcessed
4018 chandransh 5395 
    self._processMap["getItemWiseRiskyOrdersCount"] = Processor.process_getItemWiseRiskyOrdersCount
4295 varun.gupt 5396 
    self._processMap["getOrdersForItemIds"] = Processor.process_getOrdersForItemIds
4247 rajveer 5397 
    self._processMap["markOrderCancellationRequestReceived"] = Processor.process_markOrderCancellationRequestReceived
5398 
    self._processMap["markOrderCancellationRequestConfirmed"] = Processor.process_markOrderCancellationRequestConfirmed
5399 
    self._processMap["markOrderCancellationRequestDenied"] = Processor.process_markOrderCancellationRequestDenied
4258 rajveer 5400 
    self._processMap["markTransactionAsPaymentFlagRemoved"] = Processor.process_markTransactionAsPaymentFlagRemoved
4259 anupam.sin 5401 
    self._processMap["refundTransaction"] = Processor.process_refundTransaction
4324 mandeep.dh 5402 
    self._processMap["updateShipmentAddress"] = Processor.process_updateShipmentAddress
4285 rajveer 5403 
    self._processMap["acceptOrdersForItemId"] = Processor.process_acceptOrdersForItemId
4303 rajveer 5404 
    self._processMap["markOrdersAsPORaised"] = Processor.process_markOrdersAsPORaised
5405 
    self._processMap["markOrdersAsReversalInitiated"] = Processor.process_markOrdersAsReversalInitiated
5406 
    self._processMap["markOrdersAsNotAvailabke"] = Processor.process_markOrdersAsNotAvailabke
4369 rajveer 5407 
    self._processMap["markOrdersAsTimeout"] = Processor.process_markOrdersAsTimeout
4662 rajveer 5408 
    self._processMap["markOrderAsLostInTransit"] = Processor.process_markOrderAsLostInTransit
4386 anupam.sin 5409 
    self._processMap["getOrderForAwb"] = Processor.process_getOrderForAwb
4506 phani.kuma 5410 
    self._processMap["getOrdersForProviderForStatus"] = Processor.process_getOrdersForProviderForStatus
4600 varun.gupt 5411 
    self._processMap["getBilledOrdersForVendor"] = Processor.process_getBilledOrdersForVendor
4607 rajveer 5412 
    self._processMap["getSlippedSippingDateOrders"] = Processor.process_getSlippedSippingDateOrders
4709 rajveer 5413 
    self._processMap["getCancelledOrders"] = Processor.process_getCancelledOrders
4600 varun.gupt 5414 
    self._processMap["saveBluedartSettlements"] = Processor.process_saveBluedartSettlements
5415 
    self._processMap["savePaymentSettlements"] = Processor.process_savePaymentSettlements
5416 
    self._processMap["saveEBSSettlementSummary"] = Processor.process_saveEBSSettlementSummary
5386 phani.kuma 5417 
    self._processMap["getSettlementForPrepaid"] = Processor.process_getSettlementForPrepaid
5418 
    self._processMap["getSettlementForCod"] = Processor.process_getSettlementForCod
4600 varun.gupt 5419 
    self._processMap["getEBSSettlementSummaries"] = Processor.process_getEBSSettlementSummaries
5420 
    self._processMap["markEBSSettlementUploaded"] = Processor.process_markEBSSettlementUploaded
5421 
    self._processMap["getEBSSettlementDate"] = Processor.process_getEBSSettlementDate
4715 varun.gupt 5422 
    self._processMap["getSettlementsByDate"] = Processor.process_getSettlementsByDate
5423 
    self._processMap["getReshippedOrderIds"] = Processor.process_getReshippedOrderIds
5481 phani.kuma 5424 
    self._processMap["getBilledOrders"] = Processor.process_getBilledOrders
5031 varun.gupt 5425 
    self._processMap["getStatusDistributionOfOrders"] = Processor.process_getStatusDistributionOfOrders
5067 varun.gupt 5426 
    self._processMap["getOrderIdsForStatus"] = Processor.process_getOrderIdsForStatus
5348 anupam.sin 5427 
    self._processMap["updateCODAgent"] = Processor.process_updateCODAgent
5099 varun.gupt 5428 
    self._processMap["updateOrderAsPaidToVendor"] = Processor.process_updateOrderAsPaidToVendor
5386 phani.kuma 5429 
    self._processMap["updateOrderOnlyAsPaidToVendor"] = Processor.process_updateOrderOnlyAsPaidToVendor
5208 varun.gupt 5430 
    self._processMap["getRefundedOrdersMarkedPaid"] = Processor.process_getRefundedOrdersMarkedPaid
5447 anupam.sin 5431 
    self._processMap["getAllVerificationAgents"] = Processor.process_getAllVerificationAgents
5527 anupam.sin 5432 
    self._processMap["getAllAttributesForOrderId"] = Processor.process_getAllAttributesForOrderId
5433 
    self._processMap["setOrderAttributeForTransaction"] = Processor.process_setOrderAttributeForTransaction
94 ashish 5434 
 
5435 
  def process(self, iprot, oprot):
5436 
    (name, type, seqid) = iprot.readMessageBegin()
5437 
    if name not in self._processMap:
5438 
      iprot.skip(TType.STRUCT)
5439 
      iprot.readMessageEnd()
5440 
      x = TApplicationException(TApplicationException.UNKNOWN_METHOD, 'Unknown function %s' % (name))
5441 
      oprot.writeMessageBegin(name, TMessageType.EXCEPTION, seqid)
5442 
      x.write(oprot)
5443 
      oprot.writeMessageEnd()
5444 
      oprot.trans.flush()
5445 
      return
5446 
    else:
5447 
      self._processMap[name](self, seqid, iprot, oprot)
5448 
    return True
5449 
 
5450 
  def process_createTransaction(self, seqid, iprot, oprot):
5451 
    args = createTransaction_args()
5452 
    args.read(iprot)
5453 
    iprot.readMessageEnd()
5454 
    result = createTransaction_result()
5455 
    try:
132 ashish 5456 
      result.success = self._handler.createTransaction(args.transaction)
94 ashish 5457 
    except TransactionServiceException, ex:
5458 
      result.ex = ex
5459 
    oprot.writeMessageBegin("createTransaction", TMessageType.REPLY, seqid)
5460 
    result.write(oprot)
5461 
    oprot.writeMessageEnd()
5462 
    oprot.trans.flush()
5463 
 
5464 
  def process_getTransaction(self, seqid, iprot, oprot):
5465 
    args = getTransaction_args()
5466 
    args.read(iprot)
5467 
    iprot.readMessageEnd()
5468 
    result = getTransaction_result()
5469 
    try:
5470 
      result.success = self._handler.getTransaction(args.id)
5471 
    except TransactionServiceException, ex:
5472 
      result.ex = ex
5473 
    oprot.writeMessageBegin("getTransaction", TMessageType.REPLY, seqid)
5474 
    result.write(oprot)
5475 
    oprot.writeMessageEnd()
5476 
    oprot.trans.flush()
5477 
 
5478 
  def process_getTransactionsForCustomer(self, seqid, iprot, oprot):
5479 
    args = getTransactionsForCustomer_args()
5480 
    args.read(iprot)
5481 
    iprot.readMessageEnd()
5482 
    result = getTransactionsForCustomer_result()
5483 
    try:
5484 
      result.success = self._handler.getTransactionsForCustomer(args.customerId, args.from_date, args.to_date, args.status)
5485 
    except TransactionServiceException, ex:
5486 
      result.ex = ex
5487 
    oprot.writeMessageBegin("getTransactionsForCustomer", TMessageType.REPLY, seqid)
5488 
    result.write(oprot)
5489 
    oprot.writeMessageEnd()
5490 
    oprot.trans.flush()
5491 
 
132 ashish 5492 
  def process_getTransactionsForShoppingCartId(self, seqid, iprot, oprot):
5493 
    args = getTransactionsForShoppingCartId_args()
5494 
    args.read(iprot)
5495 
    iprot.readMessageEnd()
5496 
    result = getTransactionsForShoppingCartId_result()
5497 
    try:
5498 
      result.success = self._handler.getTransactionsForShoppingCartId(args.shoppingCartId)
5499 
    except TransactionServiceException, ex:
5500 
      result.ex = ex
5501 
    oprot.writeMessageBegin("getTransactionsForShoppingCartId", TMessageType.REPLY, seqid)
5502 
    result.write(oprot)
5503 
    oprot.writeMessageEnd()
5504 
    oprot.trans.flush()
5505 
 
94 ashish 5506 
  def process_getTransactionStatus(self, seqid, iprot, oprot):
5507 
    args = getTransactionStatus_args()
5508 
    args.read(iprot)
5509 
    iprot.readMessageEnd()
5510 
    result = getTransactionStatus_result()
5511 
    try:
5512 
      result.success = self._handler.getTransactionStatus(args.transactionId)
5513 
    except TransactionServiceException, ex:
5514 
      result.ex = ex
5515 
    oprot.writeMessageBegin("getTransactionStatus", TMessageType.REPLY, seqid)
5516 
    result.write(oprot)
5517 
    oprot.writeMessageEnd()
5518 
    oprot.trans.flush()
5519 
 
5520 
  def process_changeTransactionStatus(self, seqid, iprot, oprot):
5521 
    args = changeTransactionStatus_args()
5522 
    args.read(iprot)
5523 
    iprot.readMessageEnd()
5524 
    result = changeTransactionStatus_result()
5525 
    try:
5527 anupam.sin 5526 
      result.success = self._handler.changeTransactionStatus(args.transactionId, args.status, args.description, args.pickUp, args.orderType)
94 ashish 5527 
    except TransactionServiceException, ex:
5528 
      result.ex = ex
5529 
    oprot.writeMessageBegin("changeTransactionStatus", TMessageType.REPLY, seqid)
5530 
    result.write(oprot)
5531 
    oprot.writeMessageEnd()
5532 
    oprot.trans.flush()
5533 
 
1398 varun.gupt 5534 
  def process_enqueueTransactionInfoEmail(self, seqid, iprot, oprot):
5535 
    args = enqueueTransactionInfoEmail_args()
1382 varun.gupt 5536 
    args.read(iprot)
5537 
    iprot.readMessageEnd()
1398 varun.gupt 5538 
    result = enqueueTransactionInfoEmail_result()
1382 varun.gupt 5539 
    try:
1398 varun.gupt 5540 
      result.success = self._handler.enqueueTransactionInfoEmail(args.transactionId)
1382 varun.gupt 5541 
    except TransactionServiceException, ex:
5542 
      result.ex = ex
1398 varun.gupt 5543 
    oprot.writeMessageBegin("enqueueTransactionInfoEmail", TMessageType.REPLY, seqid)
1382 varun.gupt 5544 
    result.write(oprot)
5545 
    oprot.writeMessageEnd()
5546 
    oprot.trans.flush()
5547 
 
483 rajveer 5548 
  def process_getAllOrders(self, seqid, iprot, oprot):
5549 
    args = getAllOrders_args()
94 ashish 5550 
    args.read(iprot)
5551 
    iprot.readMessageEnd()
483 rajveer 5552 
    result = getAllOrders_result()
94 ashish 5553 
    try:
4801 anupam.sin 5554 
      result.success = self._handler.getAllOrders(args.statuses, args.from_date, args.to_date, args.warehouse_id)
94 ashish 5555 
    except TransactionServiceException, ex:
5556 
      result.ex = ex
483 rajveer 5557 
    oprot.writeMessageBegin("getAllOrders", TMessageType.REPLY, seqid)
94 ashish 5558 
    result.write(oprot)
5559 
    oprot.writeMessageEnd()
5560 
    oprot.trans.flush()
5561 
 
4133 chandransh 5562 
  def process_getOrdersInBatch(self, seqid, iprot, oprot):
5563 
    args = getOrdersInBatch_args()
5564 
    args.read(iprot)
5565 
    iprot.readMessageEnd()
5566 
    result = getOrdersInBatch_result()
5567 
    try:
5568 
      result.success = self._handler.getOrdersInBatch(args.statuses, args.offset, args.limit, args.warehouse_id)
5569 
    except TransactionServiceException, ex:
5570 
      result.ex = ex
5571 
    oprot.writeMessageBegin("getOrdersInBatch", TMessageType.REPLY, seqid)
5572 
    result.write(oprot)
5573 
    oprot.writeMessageEnd()
5574 
    oprot.trans.flush()
5575 
 
5576 
  def process_getOrderCount(self, seqid, iprot, oprot):
5577 
    args = getOrderCount_args()
5578 
    args.read(iprot)
5579 
    iprot.readMessageEnd()
5580 
    result = getOrderCount_result()
5581 
    try:
5582 
      result.success = self._handler.getOrderCount(args.statuses, args.warehouseId)
5583 
    except TransactionServiceException, ex:
5584 
      result.ex = ex
5585 
    oprot.writeMessageBegin("getOrderCount", TMessageType.REPLY, seqid)
5586 
    result.write(oprot)
5587 
    oprot.writeMessageEnd()
5588 
    oprot.trans.flush()
5589 
 
999 varun.gupt 5590 
  def process_getOrdersByBillingDate(self, seqid, iprot, oprot):
5591 
    args = getOrdersByBillingDate_args()
5592 
    args.read(iprot)
5593 
    iprot.readMessageEnd()
5594 
    result = getOrdersByBillingDate_result()
5595 
    try:
5596 
      result.success = self._handler.getOrdersByBillingDate(args.status, args.start_billing_date, args.end_billing_date, args.warehouse_id)
5597 
    except TransactionServiceException, ex:
5598 
      result.ex = ex
5599 
    oprot.writeMessageBegin("getOrdersByBillingDate", TMessageType.REPLY, seqid)
5600 
    result.write(oprot)
5601 
    oprot.writeMessageEnd()
5602 
    oprot.trans.flush()
5603 
 
3427 chandransh 5604 
  def process_getOrdersByShippingDate(self, seqid, iprot, oprot):
5605 
    args = getOrdersByShippingDate_args()
5606 
    args.read(iprot)
5607 
    iprot.readMessageEnd()
5608 
    result = getOrdersByShippingDate_result()
5609 
    try:
3451 chandransh 5610 
      result.success = self._handler.getOrdersByShippingDate(args.fromShippingDate, args.toShippingDate, args.providerId, args.warehouseId, args.cod)
3427 chandransh 5611 
    except TransactionServiceException, ex:
5612 
      result.ex = ex
5613 
    oprot.writeMessageBegin("getOrdersByShippingDate", TMessageType.REPLY, seqid)
5614 
    result.write(oprot)
5615 
    oprot.writeMessageEnd()
5616 
    oprot.trans.flush()
5617 
 
1382 varun.gupt 5618 
  def process_getReturnableOrdersForCustomer(self, seqid, iprot, oprot):
5619 
    args = getReturnableOrdersForCustomer_args()
5620 
    args.read(iprot)
5621 
    iprot.readMessageEnd()
5622 
    result = getReturnableOrdersForCustomer_result()
5623 
    try:
5624 
      result.success = self._handler.getReturnableOrdersForCustomer(args.customer_id, args.limit)
5625 
    except TransactionServiceException, ex:
5626 
      result.ex = ex
5627 
    oprot.writeMessageBegin("getReturnableOrdersForCustomer", TMessageType.REPLY, seqid)
5628 
    result.write(oprot)
5629 
    oprot.writeMessageEnd()
5630 
    oprot.trans.flush()
5631 
 
5632 
  def process_getCancellableOrdersForCustomer(self, seqid, iprot, oprot):
5633 
    args = getCancellableOrdersForCustomer_args()
5634 
    args.read(iprot)
5635 
    iprot.readMessageEnd()
5636 
    result = getCancellableOrdersForCustomer_result()
5637 
    try:
5638 
      result.success = self._handler.getCancellableOrdersForCustomer(args.customer_id, args.limit)
5639 
    except TransactionServiceException, ex:
5640 
      result.ex = ex
5641 
    oprot.writeMessageBegin("getCancellableOrdersForCustomer", TMessageType.REPLY, seqid)
5642 
    result.write(oprot)
5643 
    oprot.writeMessageEnd()
5644 
    oprot.trans.flush()
5645 
 
483 rajveer 5646 
  def process_changeOrderStatus(self, seqid, iprot, oprot):
5647 
    args = changeOrderStatus_args()
94 ashish 5648 
    args.read(iprot)
5649 
    iprot.readMessageEnd()
483 rajveer 5650 
    result = changeOrderStatus_result()
94 ashish 5651 
    try:
483 rajveer 5652 
      result.success = self._handler.changeOrderStatus(args.orderId, args.status, args.description)
94 ashish 5653 
    except TransactionServiceException, ex:
5654 
      result.ex = ex
483 rajveer 5655 
    oprot.writeMessageBegin("changeOrderStatus", TMessageType.REPLY, seqid)
94 ashish 5656 
    result.write(oprot)
5657 
    oprot.writeMessageEnd()
5658 
    oprot.trans.flush()
5659 
 
483 rajveer 5660 
  def process_getOrdersForTransaction(self, seqid, iprot, oprot):
5661 
    args = getOrdersForTransaction_args()
94 ashish 5662 
    args.read(iprot)
5663 
    iprot.readMessageEnd()
483 rajveer 5664 
    result = getOrdersForTransaction_result()
94 ashish 5665 
    try:
1528 ankur.sing 5666 
      result.success = self._handler.getOrdersForTransaction(args.transactionId, args.customerId)
94 ashish 5667 
    except TransactionServiceException, ex:
5668 
      result.ex = ex
483 rajveer 5669 
    oprot.writeMessageBegin("getOrdersForTransaction", TMessageType.REPLY, seqid)
94 ashish 5670 
    result.write(oprot)
5671 
    oprot.writeMessageEnd()
5672 
    oprot.trans.flush()
5673 
 
483 rajveer 5674 
  def process_getOrdersForCustomer(self, seqid, iprot, oprot):
5675 
    args = getOrdersForCustomer_args()
94 ashish 5676 
    args.read(iprot)
5677 
    iprot.readMessageEnd()
483 rajveer 5678 
    result = getOrdersForCustomer_result()
94 ashish 5679 
    try:
3014 chandransh 5680 
      result.success = self._handler.getOrdersForCustomer(args.customerId, args.from_date, args.to_date, args.statuses)
94 ashish 5681 
    except TransactionServiceException, ex:
5682 
      result.ex = ex
483 rajveer 5683 
    oprot.writeMessageBegin("getOrdersForCustomer", TMessageType.REPLY, seqid)
94 ashish 5684 
    result.write(oprot)
5685 
    oprot.writeMessageEnd()
5686 
    oprot.trans.flush()
5687 
 
483 rajveer 5688 
  def process_createOrder(self, seqid, iprot, oprot):
5689 
    args = createOrder_args()
94 ashish 5690 
    args.read(iprot)
5691 
    iprot.readMessageEnd()
483 rajveer 5692 
    result = createOrder_result()
94 ashish 5693 
    try:
483 rajveer 5694 
      result.success = self._handler.createOrder(args.order)
94 ashish 5695 
    except TransactionServiceException, ex:
5696 
      result.ex = ex
483 rajveer 5697 
    oprot.writeMessageBegin("createOrder", TMessageType.REPLY, seqid)
94 ashish 5698 
    result.write(oprot)
5699 
    oprot.writeMessageEnd()
5700 
    oprot.trans.flush()
5701 
 
483 rajveer 5702 
  def process_getOrder(self, seqid, iprot, oprot):
5703 
    args = getOrder_args()
94 ashish 5704 
    args.read(iprot)
5705 
    iprot.readMessageEnd()
483 rajveer 5706 
    result = getOrder_result()
94 ashish 5707 
    try:
483 rajveer 5708 
      result.success = self._handler.getOrder(args.id)
94 ashish 5709 
    except TransactionServiceException, ex:
5710 
      result.ex = ex
483 rajveer 5711 
    oprot.writeMessageBegin("getOrder", TMessageType.REPLY, seqid)
94 ashish 5712 
    result.write(oprot)
5713 
    oprot.writeMessageEnd()
5714 
    oprot.trans.flush()
5715 
 
483 rajveer 5716 
  def process_getLineItemsForOrder(self, seqid, iprot, oprot):
5717 
    args = getLineItemsForOrder_args()
94 ashish 5718 
    args.read(iprot)
5719 
    iprot.readMessageEnd()
483 rajveer 5720 
    result = getLineItemsForOrder_result()
94 ashish 5721 
    try:
483 rajveer 5722 
      result.success = self._handler.getLineItemsForOrder(args.orderId)
94 ashish 5723 
    except TransactionServiceException, ex:
5724 
      result.ex = ex
483 rajveer 5725 
    oprot.writeMessageBegin("getLineItemsForOrder", TMessageType.REPLY, seqid)
94 ashish 5726 
    result.write(oprot)
5727 
    oprot.writeMessageEnd()
5728 
    oprot.trans.flush()
5729 
 
4999 phani.kuma 5730 
  def process_getOrderList(self, seqid, iprot, oprot):
5731 
    args = getOrderList_args()
5732 
    args.read(iprot)
5733 
    iprot.readMessageEnd()
5734 
    result = getOrderList_result()
5735 
    result.success = self._handler.getOrderList(args.order_ids)
5736 
    oprot.writeMessageBegin("getOrderList", TMessageType.REPLY, seqid)
5737 
    result.write(oprot)
5738 
    oprot.writeMessageEnd()
5739 
    oprot.trans.flush()
5740 
 
5386 phani.kuma 5741 
  def process_getOrderListForVendor(self, seqid, iprot, oprot):
5742 
    args = getOrderListForVendor_args()
5743 
    args.read(iprot)
5744 
    iprot.readMessageEnd()
5745 
    result = getOrderListForVendor_result()
5746 
    result.success = self._handler.getOrderListForVendor(args.order_ids, args.vendorId)
5747 
    oprot.writeMessageBegin("getOrderListForVendor", TMessageType.REPLY, seqid)
5748 
    result.write(oprot)
5749 
    oprot.writeMessageEnd()
5750 
    oprot.trans.flush()
5751 
 
1528 ankur.sing 5752 
  def process_getOrderForCustomer(self, seqid, iprot, oprot):
5753 
    args = getOrderForCustomer_args()
5754 
    args.read(iprot)
5755 
    iprot.readMessageEnd()
5756 
    result = getOrderForCustomer_result()
5757 
    try:
5758 
      result.success = self._handler.getOrderForCustomer(args.orderId, args.customerId)
5759 
    except TransactionServiceException, ex:
5760 
      result.ex = ex
5761 
    oprot.writeMessageBegin("getOrderForCustomer", TMessageType.REPLY, seqid)
5762 
    result.write(oprot)
5763 
    oprot.writeMessageEnd()
5764 
    oprot.trans.flush()
5765 
 
3064 chandransh 5766 
  def process_getAlerts(self, seqid, iprot, oprot):
5767 
    args = getAlerts_args()
5768 
    args.read(iprot)
5769 
    iprot.readMessageEnd()
5770 
    result = getAlerts_result()
4444 rajveer 5771 
    result.success = self._handler.getAlerts(args.type, args.warehouseId, args.status, args.timestamp)
3064 chandransh 5772 
    oprot.writeMessageBegin("getAlerts", TMessageType.REPLY, seqid)
5773 
    result.write(oprot)
5774 
    oprot.writeMessageEnd()
5775 
    oprot.trans.flush()
5776 
 
4394 rajveer 5777 
  def process_addAlert(self, seqid, iprot, oprot):
5778 
    args = addAlert_args()
3064 chandransh 5779 
    args.read(iprot)
5780 
    iprot.readMessageEnd()
4394 rajveer 5781 
    result = addAlert_result()
4444 rajveer 5782 
    self._handler.addAlert(args.type, args.warehouseId, args.description)
4394 rajveer 5783 
    oprot.writeMessageBegin("addAlert", TMessageType.REPLY, seqid)
3064 chandransh 5784 
    result.write(oprot)
5785 
    oprot.writeMessageEnd()
5786 
    oprot.trans.flush()
5787 
 
4444 rajveer 5788 
  def process_markAlertsAsSeen(self, seqid, iprot, oprot):
5789 
    args = markAlertsAsSeen_args()
5790 
    args.read(iprot)
5791 
    iprot.readMessageEnd()
5792 
    result = markAlertsAsSeen_result()
5793 
    self._handler.markAlertsAsSeen(args.warehouseId)
5794 
    oprot.writeMessageBegin("markAlertsAsSeen", TMessageType.REPLY, seqid)
5795 
    result.write(oprot)
5796 
    oprot.writeMessageEnd()
5797 
    oprot.trans.flush()
5798 
 
3064 chandransh 5799 
  def process_getValidOrderCount(self, seqid, iprot, oprot):
5800 
    args = getValidOrderCount_args()
5801 
    args.read(iprot)
5802 
    iprot.readMessageEnd()
5803 
    result = getValidOrderCount_result()
5804 
    result.success = self._handler.getValidOrderCount()
5805 
    oprot.writeMessageBegin("getValidOrderCount", TMessageType.REPLY, seqid)
5806 
    result.write(oprot)
5807 
    oprot.writeMessageEnd()
5808 
    oprot.trans.flush()
5809 
 
5810 
  def process_getNoOfCustomersWithSuccessfulTransaction(self, seqid, iprot, oprot):
5811 
    args = getNoOfCustomersWithSuccessfulTransaction_args()
5812 
    args.read(iprot)
5813 
    iprot.readMessageEnd()
5814 
    result = getNoOfCustomersWithSuccessfulTransaction_result()
5815 
    result.success = self._handler.getNoOfCustomersWithSuccessfulTransaction()
5816 
    oprot.writeMessageBegin("getNoOfCustomersWithSuccessfulTransaction", TMessageType.REPLY, seqid)
5817 
    result.write(oprot)
5818 
    oprot.writeMessageEnd()
5819 
    oprot.trans.flush()
5820 
 
5821 
  def process_getValidOrdersAmountRange(self, seqid, iprot, oprot):
5822 
    args = getValidOrdersAmountRange_args()
5823 
    args.read(iprot)
5824 
    iprot.readMessageEnd()
5825 
    result = getValidOrdersAmountRange_result()
5826 
    result.success = self._handler.getValidOrdersAmountRange()
5827 
    oprot.writeMessageBegin("getValidOrdersAmountRange", TMessageType.REPLY, seqid)
5828 
    result.write(oprot)
5829 
    oprot.writeMessageEnd()
5830 
    oprot.trans.flush()
5831 
 
5832 
  def process_getValidOrders(self, seqid, iprot, oprot):
5833 
    args = getValidOrders_args()
5834 
    args.read(iprot)
5835 
    iprot.readMessageEnd()
5836 
    result = getValidOrders_result()
5837 
    result.success = self._handler.getValidOrders(args.limit)
5838 
    oprot.writeMessageBegin("getValidOrders", TMessageType.REPLY, seqid)
5839 
    result.write(oprot)
5840 
    oprot.writeMessageEnd()
5841 
    oprot.trans.flush()
5842 
 
1220 chandransh 5843 
  def process_batchOrders(self, seqid, iprot, oprot):
5844 
    args = batchOrders_args()
5845 
    args.read(iprot)
5846 
    iprot.readMessageEnd()
5847 
    result = batchOrders_result()
5848 
    try:
5849 
      result.success = self._handler.batchOrders(args.warehouseId)
5850 
    except TransactionServiceException, ex:
5851 
      result.ex = ex
5852 
    oprot.writeMessageBegin("batchOrders", TMessageType.REPLY, seqid)
5853 
    result.write(oprot)
5854 
    oprot.writeMessageEnd()
5855 
    oprot.trans.flush()
5856 
 
1208 chandransh 5857 
  def process_markOrderAsOutOfStock(self, seqid, iprot, oprot):
5858 
    args = markOrderAsOutOfStock_args()
5859 
    args.read(iprot)
5860 
    iprot.readMessageEnd()
5861 
    result = markOrderAsOutOfStock_result()
5862 
    try:
5863 
      result.success = self._handler.markOrderAsOutOfStock(args.orderId)
5864 
    except TransactionServiceException, ex:
5865 
      result.ex = ex
5866 
    oprot.writeMessageBegin("markOrderAsOutOfStock", TMessageType.REPLY, seqid)
5867 
    result.write(oprot)
5868 
    oprot.writeMessageEnd()
5869 
    oprot.trans.flush()
5870 
 
3064 chandransh 5871 
  def process_verifyOrder(self, seqid, iprot, oprot):
5872 
    args = verifyOrder_args()
759 chandransh 5873 
    args.read(iprot)
5874 
    iprot.readMessageEnd()
3064 chandransh 5875 
    result = verifyOrder_result()
759 chandransh 5876 
    try:
3064 chandransh 5877 
      result.success = self._handler.verifyOrder(args.orderId)
759 chandransh 5878 
    except TransactionServiceException, ex:
5879 
      result.ex = ex
3064 chandransh 5880 
    oprot.writeMessageBegin("verifyOrder", TMessageType.REPLY, seqid)
759 chandransh 5881 
    result.write(oprot)
5882 
    oprot.writeMessageEnd()
5883 
    oprot.trans.flush()
5884 
 
3064 chandransh 5885 
  def process_acceptOrder(self, seqid, iprot, oprot):
5886 
    args = acceptOrder_args()
1113 chandransh 5887 
    args.read(iprot)
5888 
    iprot.readMessageEnd()
3064 chandransh 5889 
    result = acceptOrder_result()
1113 chandransh 5890 
    try:
3064 chandransh 5891 
      result.success = self._handler.acceptOrder(args.orderId)
1113 chandransh 5892 
    except TransactionServiceException, ex:
5893 
      result.ex = ex
3064 chandransh 5894 
    oprot.writeMessageBegin("acceptOrder", TMessageType.REPLY, seqid)
1113 chandransh 5895 
    result.write(oprot)
5896 
    oprot.writeMessageEnd()
5897 
    oprot.trans.flush()
5898 
 
3064 chandransh 5899 
  def process_addBillingDetails(self, seqid, iprot, oprot):
5900 
    args = addBillingDetails_args()
1135 chandransh 5901 
    args.read(iprot)
5902 
    iprot.readMessageEnd()
3064 chandransh 5903 
    result = addBillingDetails_result()
1135 chandransh 5904 
    try:
5110 mandeep.dh 5905 
      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 5906 
    except TransactionServiceException, ex:
5907 
      result.ex = ex
3064 chandransh 5908 
    oprot.writeMessageBegin("addBillingDetails", TMessageType.REPLY, seqid)
1135 chandransh 5909 
    result.write(oprot)
5910 
    oprot.writeMessageEnd()
5911 
    oprot.trans.flush()
5912 
 
4579 rajveer 5913 
  def process_addInvoiceNumber(self, seqid, iprot, oprot):
5914 
    args = addInvoiceNumber_args()
5915 
    args.read(iprot)
5916 
    iprot.readMessageEnd()
5917 
    result = addInvoiceNumber_result()
5918 
    try:
4763 rajveer 5919 
      self._handler.addInvoiceNumber(args.orderId, args.invoiceNumber, args.color)
4579 rajveer 5920 
    except TransactionServiceException, ex:
5921 
      result.ex = ex
5922 
    oprot.writeMessageBegin("addInvoiceNumber", TMessageType.REPLY, seqid)
5923 
    result.write(oprot)
5924 
    oprot.writeMessageEnd()
5925 
    oprot.trans.flush()
5926 
 
4410 rajveer 5927 
  def process_markOrdersAsShippedFromWarehouse(self, seqid, iprot, oprot):
5928 
    args = markOrdersAsShippedFromWarehouse_args()
5929 
    args.read(iprot)
5930 
    iprot.readMessageEnd()
5931 
    result = markOrdersAsShippedFromWarehouse_result()
5932 
    try:
4789 rajveer 5933 
      result.success = self._handler.markOrdersAsShippedFromWarehouse(args.warehouseId, args.providerId, args.cod, args.orderIds)
4410 rajveer 5934 
    except TransactionServiceException, ex:
5935 
      result.ex = ex
5936 
    oprot.writeMessageBegin("markOrdersAsShippedFromWarehouse", TMessageType.REPLY, seqid)
5937 
    result.write(oprot)
5938 
    oprot.writeMessageEnd()
5939 
    oprot.trans.flush()
5940 
 
3064 chandransh 5941 
  def process_markOrdersAsPickedUp(self, seqid, iprot, oprot):
5942 
    args = markOrdersAsPickedUp_args()
304 ashish 5943 
    args.read(iprot)
5944 
    iprot.readMessageEnd()
3064 chandransh 5945 
    result = markOrdersAsPickedUp_result()
5946 
    try:
4910 phani.kuma 5947 
      self._handler.markOrdersAsPickedUp(args.providerId, args.pickupDetails)
3064 chandransh 5948 
    except TransactionServiceException, ex:
5949 
      result.ex = ex
5950 
    oprot.writeMessageBegin("markOrdersAsPickedUp", TMessageType.REPLY, seqid)
304 ashish 5951 
    result.write(oprot)
5952 
    oprot.writeMessageEnd()
5953 
    oprot.trans.flush()
94 ashish 5954 
 
4910 phani.kuma 5955 
  def process_getOrdersNotPickedUp(self, seqid, iprot, oprot):
5956 
    args = getOrdersNotPickedUp_args()
5957 
    args.read(iprot)
5958 
    iprot.readMessageEnd()
5959 
    result = getOrdersNotPickedUp_result()
5960 
    result.success = self._handler.getOrdersNotPickedUp(args.providerId)
5961 
    oprot.writeMessageBegin("getOrdersNotPickedUp", TMessageType.REPLY, seqid)
5962 
    result.write(oprot)
5963 
    oprot.writeMessageEnd()
5964 
    oprot.trans.flush()
5965 
 
3064 chandransh 5966 
  def process_markOrdersAsDelivered(self, seqid, iprot, oprot):
5967 
    args = markOrdersAsDelivered_args()
304 ashish 5968 
    args.read(iprot)
5969 
    iprot.readMessageEnd()
3064 chandransh 5970 
    result = markOrdersAsDelivered_result()
5971 
    try:
5972 
      self._handler.markOrdersAsDelivered(args.providerId, args.deliveredOrders)
5973 
    except TransactionServiceException, ex:
5974 
      result.ex = ex
5975 
    oprot.writeMessageBegin("markOrdersAsDelivered", TMessageType.REPLY, seqid)
304 ashish 5976 
    result.write(oprot)
5977 
    oprot.writeMessageEnd()
5978 
    oprot.trans.flush()
5979 
 
4910 phani.kuma 5980 
  def process_markAsRTOrders(self, seqid, iprot, oprot):
5981 
    args = markAsRTOrders_args()
1596 ankur.sing 5982 
    args.read(iprot)
5983 
    iprot.readMessageEnd()
4910 phani.kuma 5984 
    result = markAsRTOrders_result()
3064 chandransh 5985 
    try:
4910 phani.kuma 5986 
      self._handler.markAsRTOrders(args.providerId, args.returnedOrders)
3064 chandransh 5987 
    except TransactionServiceException, ex:
5988 
      result.ex = ex
4910 phani.kuma 5989 
    oprot.writeMessageBegin("markAsRTOrders", TMessageType.REPLY, seqid)
1596 ankur.sing 5990 
    result.write(oprot)
5991 
    oprot.writeMessageEnd()
5992 
    oprot.trans.flush()
304 ashish 5993 
 
4910 phani.kuma 5994 
  def process_getRTOrders(self, seqid, iprot, oprot):
5995 
    args = getRTOrders_args()
5996 
    args.read(iprot)
5997 
    iprot.readMessageEnd()
5998 
    result = getRTOrders_result()
5999 
    result.success = self._handler.getRTOrders(args.providerId)
6000 
    oprot.writeMessageBegin("getRTOrders", TMessageType.REPLY, seqid)
6001 
    result.write(oprot)
6002 
    oprot.writeMessageEnd()
6003 
    oprot.trans.flush()
6004 
 
3064 chandransh 6005 
  def process_updateNonDeliveryReason(self, seqid, iprot, oprot):
6006 
    args = updateNonDeliveryReason_args()
1627 ankur.sing 6007 
    args.read(iprot)
6008 
    iprot.readMessageEnd()
3064 chandransh 6009 
    result = updateNonDeliveryReason_result()
6010 
    try:
4910 phani.kuma 6011 
      self._handler.updateNonDeliveryReason(args.providerId, args.undeliveredOrders)
3064 chandransh 6012 
    except TransactionServiceException, ex:
6013 
      result.ex = ex
6014 
    oprot.writeMessageBegin("updateNonDeliveryReason", TMessageType.REPLY, seqid)
1627 ankur.sing 6015 
    result.write(oprot)
6016 
    oprot.writeMessageEnd()
6017 
    oprot.trans.flush()
1596 ankur.sing 6018 
 
4910 phani.kuma 6019 
  def process_getNonDeliveredOrdersbyCourier(self, seqid, iprot, oprot):
6020 
    args = getNonDeliveredOrdersbyCourier_args()
6021 
    args.read(iprot)
6022 
    iprot.readMessageEnd()
6023 
    result = getNonDeliveredOrdersbyCourier_result()
6024 
    result.success = self._handler.getNonDeliveredOrdersbyCourier(args.providerId)
6025 
    oprot.writeMessageBegin("getNonDeliveredOrdersbyCourier", TMessageType.REPLY, seqid)
6026 
    result.write(oprot)
6027 
    oprot.writeMessageEnd()
6028 
    oprot.trans.flush()
6029 
 
6030 
  def process_markOrdersAsLocalConnected(self, seqid, iprot, oprot):
6031 
    args = markOrdersAsLocalConnected_args()
6032 
    args.read(iprot)
6033 
    iprot.readMessageEnd()
6034 
    result = markOrdersAsLocalConnected_result()
6035 
    try:
6036 
      self._handler.markOrdersAsLocalConnected(args.providerId, args.local_connected_orders)
6037 
    except TransactionServiceException, ex:
6038 
      result.ex = ex
6039 
    oprot.writeMessageBegin("markOrdersAsLocalConnected", TMessageType.REPLY, seqid)
6040 
    result.write(oprot)
6041 
    oprot.writeMessageEnd()
6042 
    oprot.trans.flush()
6043 
 
6044 
  def process_getOrdersNotLocalConnected(self, seqid, iprot, oprot):
6045 
    args = getOrdersNotLocalConnected_args()
6046 
    args.read(iprot)
6047 
    iprot.readMessageEnd()
6048 
    result = getOrdersNotLocalConnected_result()
6049 
    result.success = self._handler.getOrdersNotLocalConnected(args.providerId)
6050 
    oprot.writeMessageBegin("getOrdersNotLocalConnected", TMessageType.REPLY, seqid)
6051 
    result.write(oprot)
6052 
    oprot.writeMessageEnd()
6053 
    oprot.trans.flush()
6054 
 
6055 
  def process_markOrdersAsDestinationCityReached(self, seqid, iprot, oprot):
6056 
    args = markOrdersAsDestinationCityReached_args()
6057 
    args.read(iprot)
6058 
    iprot.readMessageEnd()
6059 
    result = markOrdersAsDestinationCityReached_result()
6060 
    try:
6061 
      self._handler.markOrdersAsDestinationCityReached(args.providerId, args.destination_city_reached_orders)
6062 
    except TransactionServiceException, ex:
6063 
      result.ex = ex
6064 
    oprot.writeMessageBegin("markOrdersAsDestinationCityReached", TMessageType.REPLY, seqid)
6065 
    result.write(oprot)
6066 
    oprot.writeMessageEnd()
6067 
    oprot.trans.flush()
6068 
 
6069 
  def process_markOrdersAsFirstDeliveryAttempted(self, seqid, iprot, oprot):
6070 
    args = markOrdersAsFirstDeliveryAttempted_args()
6071 
    args.read(iprot)
6072 
    iprot.readMessageEnd()
6073 
    result = markOrdersAsFirstDeliveryAttempted_result()
6074 
    try:
6075 
      self._handler.markOrdersAsFirstDeliveryAttempted(args.providerId, args.first_atdl_orders)
6076 
    except TransactionServiceException, ex:
6077 
      result.ex = ex
6078 
    oprot.writeMessageBegin("markOrdersAsFirstDeliveryAttempted", TMessageType.REPLY, seqid)
6079 
    result.write(oprot)
6080 
    oprot.writeMessageEnd()
6081 
    oprot.trans.flush()
6082 
 
3064 chandransh 6083 
  def process_getUndeliveredOrders(self, seqid, iprot, oprot):
6084 
    args = getUndeliveredOrders_args()
1627 ankur.sing 6085 
    args.read(iprot)
6086 
    iprot.readMessageEnd()
3064 chandransh 6087 
    result = getUndeliveredOrders_result()
6088 
    result.success = self._handler.getUndeliveredOrders(args.providerId, args.warehouseId)
6089 
    oprot.writeMessageBegin("getUndeliveredOrders", TMessageType.REPLY, seqid)
1627 ankur.sing 6090 
    result.write(oprot)
6091 
    oprot.writeMessageEnd()
6092 
    oprot.trans.flush()
6093 
 
4783 phani.kuma 6094 
  def process_getUndeliveredOrdersExpectedDeliveryDateNotMet(self, seqid, iprot, oprot):
6095 
    args = getUndeliveredOrdersExpectedDeliveryDateNotMet_args()
6096 
    args.read(iprot)
6097 
    iprot.readMessageEnd()
6098 
    result = getUndeliveredOrdersExpectedDeliveryDateNotMet_result()
6099 
    result.success = self._handler.getUndeliveredOrdersExpectedDeliveryDateNotMet()
6100 
    oprot.writeMessageBegin("getUndeliveredOrdersExpectedDeliveryDateNotMet", TMessageType.REPLY, seqid)
6101 
    result.write(oprot)
6102 
    oprot.writeMessageEnd()
6103 
    oprot.trans.flush()
6104 
 
2536 chandransh 6105 
  def process_toggleDOAFlag(self, seqid, iprot, oprot):
6106 
    args = toggleDOAFlag_args()
6107 
    args.read(iprot)
6108 
    iprot.readMessageEnd()
6109 
    result = toggleDOAFlag_result()
6110 
    try:
6111 
      result.success = self._handler.toggleDOAFlag(args.orderId)
6112 
    except TransactionServiceException, ex:
6113 
      result.ex = ex
6114 
    oprot.writeMessageBegin("toggleDOAFlag", TMessageType.REPLY, seqid)
6115 
    result.write(oprot)
6116 
    oprot.writeMessageEnd()
6117 
    oprot.trans.flush()
1886 ankur.sing 6118 
 
4712 rajveer 6119 
  def process_markOrderAsDelivered(self, seqid, iprot, oprot):
6120 
    args = markOrderAsDelivered_args()
6121 
    args.read(iprot)
6122 
    iprot.readMessageEnd()
6123 
    result = markOrderAsDelivered_result()
6124 
    try:
6125 
      self._handler.markOrderAsDelivered(args.orderId, args.deliveryTimestamp, args.receiver)
6126 
    except TransactionServiceException, ex:
6127 
      result.ex = ex
6128 
    oprot.writeMessageBegin("markOrderAsDelivered", TMessageType.REPLY, seqid)
6129 
    result.write(oprot)
6130 
    oprot.writeMessageEnd()
6131 
    oprot.trans.flush()
6132 
 
4454 rajveer 6133 
  def process_markOrderDoaRequestReceived(self, seqid, iprot, oprot):
6134 
    args = markOrderDoaRequestReceived_args()
6135 
    args.read(iprot)
6136 
    iprot.readMessageEnd()
6137 
    result = markOrderDoaRequestReceived_result()
6138 
    try:
6139 
      result.success = self._handler.markOrderDoaRequestReceived(args.orderId)
6140 
    except TransactionServiceException, ex:
6141 
      result.ex = ex
6142 
    oprot.writeMessageBegin("markOrderDoaRequestReceived", TMessageType.REPLY, seqid)
6143 
    result.write(oprot)
6144 
    oprot.writeMessageEnd()
6145 
    oprot.trans.flush()
6146 
 
6147 
  def process_markOrderDoaRequestAuthorized(self, seqid, iprot, oprot):
6148 
    args = markOrderDoaRequestAuthorized_args()
6149 
    args.read(iprot)
6150 
    iprot.readMessageEnd()
6151 
    result = markOrderDoaRequestAuthorized_result()
6152 
    try:
6153 
      result.success = self._handler.markOrderDoaRequestAuthorized(args.orderId, args.isAuthorized)
6154 
    except TransactionServiceException, ex:
6155 
      result.ex = ex
6156 
    oprot.writeMessageBegin("markOrderDoaRequestAuthorized", TMessageType.REPLY, seqid)
6157 
    result.write(oprot)
6158 
    oprot.writeMessageEnd()
6159 
    oprot.trans.flush()
6160 
 
4488 rajveer 6161 
  def process_markOrderReturnRequestReceived(self, seqid, iprot, oprot):
6162 
    args = markOrderReturnRequestReceived_args()
6163 
    args.read(iprot)
6164 
    iprot.readMessageEnd()
6165 
    result = markOrderReturnRequestReceived_result()
6166 
    try:
6167 
      result.success = self._handler.markOrderReturnRequestReceived(args.orderId)
6168 
    except TransactionServiceException, ex:
6169 
      result.ex = ex
6170 
    oprot.writeMessageBegin("markOrderReturnRequestReceived", TMessageType.REPLY, seqid)
6171 
    result.write(oprot)
6172 
    oprot.writeMessageEnd()
6173 
    oprot.trans.flush()
6174 
 
6175 
  def process_markOrderReturnRequestAuthorized(self, seqid, iprot, oprot):
6176 
    args = markOrderReturnRequestAuthorized_args()
6177 
    args.read(iprot)
6178 
    iprot.readMessageEnd()
6179 
    result = markOrderReturnRequestAuthorized_result()
6180 
    try:
6181 
      result.success = self._handler.markOrderReturnRequestAuthorized(args.orderId, args.isAuthorized)
6182 
    except TransactionServiceException, ex:
6183 
      result.ex = ex
6184 
    oprot.writeMessageBegin("markOrderReturnRequestAuthorized", TMessageType.REPLY, seqid)
6185 
    result.write(oprot)
6186 
    oprot.writeMessageEnd()
6187 
    oprot.trans.flush()
6188 
 
2536 chandransh 6189 
  def process_requestPickupNumber(self, seqid, iprot, oprot):
6190 
    args = requestPickupNumber_args()
6191 
    args.read(iprot)
6192 
    iprot.readMessageEnd()
6193 
    result = requestPickupNumber_result()
6194 
    try:
4579 rajveer 6195 
      result.success = self._handler.requestPickupNumber(args.orderId, args.providerId)
2536 chandransh 6196 
    except TransactionServiceException, ex:
6197 
      result.ex = ex
6198 
    oprot.writeMessageBegin("requestPickupNumber", TMessageType.REPLY, seqid)
6199 
    result.write(oprot)
6200 
    oprot.writeMessageEnd()
6201 
    oprot.trans.flush()
6202 
 
6203 
  def process_authorizePickup(self, seqid, iprot, oprot):
6204 
    args = authorizePickup_args()
6205 
    args.read(iprot)
6206 
    iprot.readMessageEnd()
6207 
    result = authorizePickup_result()
6208 
    try:
4602 rajveer 6209 
      result.success = self._handler.authorizePickup(args.orderId, args.pickupNumber, args.providerId)
2536 chandransh 6210 
    except TransactionServiceException, ex:
6211 
      result.ex = ex
6212 
    oprot.writeMessageBegin("authorizePickup", TMessageType.REPLY, seqid)
6213 
    result.write(oprot)
6214 
    oprot.writeMessageEnd()
6215 
    oprot.trans.flush()
6216 
 
2764 chandransh 6217 
  def process_markDoasAsPickedUp(self, seqid, iprot, oprot):
6218 
    args = markDoasAsPickedUp_args()
6219 
    args.read(iprot)
6220 
    iprot.readMessageEnd()
6221 
    result = markDoasAsPickedUp_result()
4910 phani.kuma 6222 
    self._handler.markDoasAsPickedUp(args.providerId, args.pickupDetails)
2764 chandransh 6223 
    oprot.writeMessageBegin("markDoasAsPickedUp", TMessageType.REPLY, seqid)
6224 
    result.write(oprot)
6225 
    oprot.writeMessageEnd()
6226 
    oprot.trans.flush()
6227 
 
4910 phani.kuma 6228 
  def process_getDoasNotPickedUp(self, seqid, iprot, oprot):
6229 
    args = getDoasNotPickedUp_args()
6230 
    args.read(iprot)
6231 
    iprot.readMessageEnd()
6232 
    result = getDoasNotPickedUp_result()
6233 
    result.success = self._handler.getDoasNotPickedUp(args.providerId)
6234 
    oprot.writeMessageBegin("getDoasNotPickedUp", TMessageType.REPLY, seqid)
6235 
    result.write(oprot)
6236 
    oprot.writeMessageEnd()
6237 
    oprot.trans.flush()
6238 
 
4741 phani.kuma 6239 
  def process_markReturnOrdersAsPickedUp(self, seqid, iprot, oprot):
6240 
    args = markReturnOrdersAsPickedUp_args()
6241 
    args.read(iprot)
6242 
    iprot.readMessageEnd()
6243 
    result = markReturnOrdersAsPickedUp_result()
4910 phani.kuma 6244 
    self._handler.markReturnOrdersAsPickedUp(args.providerId, args.pickupDetails)
4741 phani.kuma 6245 
    oprot.writeMessageBegin("markReturnOrdersAsPickedUp", TMessageType.REPLY, seqid)
6246 
    result.write(oprot)
6247 
    oprot.writeMessageEnd()
6248 
    oprot.trans.flush()
6249 
 
4910 phani.kuma 6250 
  def process_getReturnOrdersNotPickedUp(self, seqid, iprot, oprot):
6251 
    args = getReturnOrdersNotPickedUp_args()
6252 
    args.read(iprot)
6253 
    iprot.readMessageEnd()
6254 
    result = getReturnOrdersNotPickedUp_result()
6255 
    result.success = self._handler.getReturnOrdersNotPickedUp(args.providerId)
6256 
    oprot.writeMessageBegin("getReturnOrdersNotPickedUp", TMessageType.REPLY, seqid)
6257 
    result.write(oprot)
6258 
    oprot.writeMessageEnd()
6259 
    oprot.trans.flush()
6260 
 
2616 chandransh 6261 
  def process_receiveReturn(self, seqid, iprot, oprot):
6262 
    args = receiveReturn_args()
2591 chandransh 6263 
    args.read(iprot)
6264 
    iprot.readMessageEnd()
2616 chandransh 6265 
    result = receiveReturn_result()
2591 chandransh 6266 
    try:
4479 rajveer 6267 
      result.success = self._handler.receiveReturn(args.orderId, args.receiveCondition)
2591 chandransh 6268 
    except TransactionServiceException, ex:
6269 
      result.ex = ex
2616 chandransh 6270 
    oprot.writeMessageBegin("receiveReturn", TMessageType.REPLY, seqid)
2591 chandransh 6271 
    result.write(oprot)
6272 
    oprot.writeMessageEnd()
6273 
    oprot.trans.flush()
2536 chandransh 6274 
 
2591 chandransh 6275 
  def process_validateDoa(self, seqid, iprot, oprot):
6276 
    args = validateDoa_args()
6277 
    args.read(iprot)
6278 
    iprot.readMessageEnd()
6279 
    result = validateDoa_result()
6280 
    try:
6281 
      result.success = self._handler.validateDoa(args.orderId, args.isValid)
6282 
    except TransactionServiceException, ex:
6283 
      result.ex = ex
6284 
    oprot.writeMessageBegin("validateDoa", TMessageType.REPLY, seqid)
6285 
    result.write(oprot)
6286 
    oprot.writeMessageEnd()
6287 
    oprot.trans.flush()
6288 
 
4495 rajveer 6289 
  def process_validateReturnProduct(self, seqid, iprot, oprot):
6290 
    args = validateReturnProduct_args()
6291 
    args.read(iprot)
6292 
    iprot.readMessageEnd()
6293 
    result = validateReturnProduct_result()
6294 
    try:
6295 
      result.success = self._handler.validateReturnProduct(args.orderId, args.isUsable)
6296 
    except TransactionServiceException, ex:
6297 
      result.ex = ex
6298 
    oprot.writeMessageBegin("validateReturnProduct", TMessageType.REPLY, seqid)
6299 
    result.write(oprot)
6300 
    oprot.writeMessageEnd()
6301 
    oprot.trans.flush()
6302 
 
2616 chandransh 6303 
  def process_reshipOrder(self, seqid, iprot, oprot):
6304 
    args = reshipOrder_args()
6305 
    args.read(iprot)
6306 
    iprot.readMessageEnd()
6307 
    result = reshipOrder_result()
6308 
    try:
6309 
      result.success = self._handler.reshipOrder(args.orderId)
6310 
    except TransactionServiceException, ex:
6311 
      result.ex = ex
6312 
    oprot.writeMessageBegin("reshipOrder", TMessageType.REPLY, seqid)
6313 
    result.write(oprot)
6314 
    oprot.writeMessageEnd()
6315 
    oprot.trans.flush()
2591 chandransh 6316 
 
2616 chandransh 6317 
  def process_refundOrder(self, seqid, iprot, oprot):
6318 
    args = refundOrder_args()
6319 
    args.read(iprot)
6320 
    iprot.readMessageEnd()
6321 
    result = refundOrder_result()
6322 
    try:
3226 chandransh 6323 
      result.success = self._handler.refundOrder(args.orderId, args.refundedBy, args.reason)
2616 chandransh 6324 
    except TransactionServiceException, ex:
6325 
      result.ex = ex
6326 
    oprot.writeMessageBegin("refundOrder", TMessageType.REPLY, seqid)
6327 
    result.write(oprot)
6328 
    oprot.writeMessageEnd()
6329 
    oprot.trans.flush()
6330 
 
2690 chandransh 6331 
  def process_getReturnOrders(self, seqid, iprot, oprot):
6332 
    args = getReturnOrders_args()
6333 
    args.read(iprot)
6334 
    iprot.readMessageEnd()
6335 
    result = getReturnOrders_result()
6336 
    result.success = self._handler.getReturnOrders(args.warehouseId, args.fromDate, args.toDate)
6337 
    oprot.writeMessageBegin("getReturnOrders", TMessageType.REPLY, seqid)
6338 
    result.write(oprot)
6339 
    oprot.writeMessageEnd()
6340 
    oprot.trans.flush()
2616 chandransh 6341 
 
5481 phani.kuma 6342 
  def process_getAllReturnOrders(self, seqid, iprot, oprot):
6343 
    args = getAllReturnOrders_args()
6344 
    args.read(iprot)
6345 
    iprot.readMessageEnd()
6346 
    result = getAllReturnOrders_result()
6347 
    result.success = self._handler.getAllReturnOrders(args.onlyNotProcessed, args.fromDate, args.toDate)
6348 
    oprot.writeMessageBegin("getAllReturnOrders", TMessageType.REPLY, seqid)
6349 
    result.write(oprot)
6350 
    oprot.writeMessageEnd()
6351 
    oprot.trans.flush()
6352 
 
2700 chandransh 6353 
  def process_getReturnOrder(self, seqid, iprot, oprot):
6354 
    args = getReturnOrder_args()
6355 
    args.read(iprot)
6356 
    iprot.readMessageEnd()
6357 
    result = getReturnOrder_result()
6358 
    try:
6359 
      result.success = self._handler.getReturnOrder(args.id)
6360 
    except TransactionServiceException, ex:
6361 
      result.ex = ex
6362 
    oprot.writeMessageBegin("getReturnOrder", TMessageType.REPLY, seqid)
6363 
    result.write(oprot)
6364 
    oprot.writeMessageEnd()
6365 
    oprot.trans.flush()
6366 
 
2690 chandransh 6367 
  def process_processReturn(self, seqid, iprot, oprot):
6368 
    args = processReturn_args()
6369 
    args.read(iprot)
6370 
    iprot.readMessageEnd()
6371 
    result = processReturn_result()
6372 
    try:
6373 
      self._handler.processReturn(args.returnOrderId)
6374 
    except TransactionServiceException, ex:
6375 
      result.ex = ex
6376 
    oprot.writeMessageBegin("processReturn", TMessageType.REPLY, seqid)
6377 
    result.write(oprot)
6378 
    oprot.writeMessageEnd()
6379 
    oprot.trans.flush()
6380 
 
3451 chandransh 6381 
  def process_updateWeight(self, seqid, iprot, oprot):
6382 
    args = updateWeight_args()
6383 
    args.read(iprot)
6384 
    iprot.readMessageEnd()
6385 
    result = updateWeight_result()
6386 
    try:
6387 
      result.success = self._handler.updateWeight(args.orderId, args.weight)
6388 
    except TransactionServiceException, ex:
6389 
      result.ex = ex
6390 
    oprot.writeMessageBegin("updateWeight", TMessageType.REPLY, seqid)
6391 
    result.write(oprot)
6392 
    oprot.writeMessageEnd()
6393 
    oprot.trans.flush()
2819 chandransh 6394 
 
3469 chandransh 6395 
  def process_changeItem(self, seqid, iprot, oprot):
6396 
    args = changeItem_args()
6397 
    args.read(iprot)
6398 
    iprot.readMessageEnd()
6399 
    result = changeItem_result()
6400 
    try:
6401 
      result.success = self._handler.changeItem(args.orderId, args.itemId)
6402 
    except TransactionServiceException, ex:
6403 
      result.ex = ex
6404 
    oprot.writeMessageBegin("changeItem", TMessageType.REPLY, seqid)
6405 
    result.write(oprot)
6406 
    oprot.writeMessageEnd()
6407 
    oprot.trans.flush()
3451 chandransh 6408 
 
3469 chandransh 6409 
  def process_shiftToWarehouse(self, seqid, iprot, oprot):
6410 
    args = shiftToWarehouse_args()
6411 
    args.read(iprot)
6412 
    iprot.readMessageEnd()
6413 
    result = shiftToWarehouse_result()
6414 
    try:
6415 
      result.success = self._handler.shiftToWarehouse(args.orderId, args.warehouseId)
6416 
    except TransactionServiceException, ex:
6417 
      result.ex = ex
6418 
    oprot.writeMessageBegin("shiftToWarehouse", TMessageType.REPLY, seqid)
6419 
    result.write(oprot)
6420 
    oprot.writeMessageEnd()
6421 
    oprot.trans.flush()
6422 
 
3553 chandransh 6423 
  def process_addDelayReason(self, seqid, iprot, oprot):
6424 
    args = addDelayReason_args()
6425 
    args.read(iprot)
6426 
    iprot.readMessageEnd()
6427 
    result = addDelayReason_result()
6428 
    try:
4647 rajveer 6429 
      result.success = self._handler.addDelayReason(args.orderId, args.delayReason, args.furtherDelay, args.delayReasonText)
3553 chandransh 6430 
    except TransactionServiceException, ex:
6431 
      result.ex = ex
6432 
    oprot.writeMessageBegin("addDelayReason", TMessageType.REPLY, seqid)
6433 
    result.write(oprot)
6434 
    oprot.writeMessageEnd()
6435 
    oprot.trans.flush()
3469 chandransh 6436 
 
3956 chandransh 6437 
  def process_reconcileCodCollection(self, seqid, iprot, oprot):
6438 
    args = reconcileCodCollection_args()
6439 
    args.read(iprot)
6440 
    iprot.readMessageEnd()
6441 
    result = reconcileCodCollection_result()
6442 
    try:
6443 
      result.success = self._handler.reconcileCodCollection(args.collectedAmountMap, args.xferBy, args.xferTxnId, args.xferDate)
6444 
    except TransactionServiceException, ex:
6445 
      result.ex = ex
6446 
    oprot.writeMessageBegin("reconcileCodCollection", TMessageType.REPLY, seqid)
6447 
    result.write(oprot)
6448 
    oprot.writeMessageEnd()
6449 
    oprot.trans.flush()
3553 chandransh 6450 
 
4008 mandeep.dh 6451 
  def process_getTransactionsRequiringExtraProcessing(self, seqid, iprot, oprot):
6452 
    args = getTransactionsRequiringExtraProcessing_args()
6453 
    args.read(iprot)
6454 
    iprot.readMessageEnd()
6455 
    result = getTransactionsRequiringExtraProcessing_result()
6456 
    result.success = self._handler.getTransactionsRequiringExtraProcessing(args.category)
6457 
    oprot.writeMessageBegin("getTransactionsRequiringExtraProcessing", TMessageType.REPLY, seqid)
6458 
    result.write(oprot)
6459 
    oprot.writeMessageEnd()
6460 
    oprot.trans.flush()
3956 chandransh 6461 
 
4008 mandeep.dh 6462 
  def process_markTransactionAsProcessed(self, seqid, iprot, oprot):
6463 
    args = markTransactionAsProcessed_args()
6464 
    args.read(iprot)
6465 
    iprot.readMessageEnd()
6466 
    result = markTransactionAsProcessed_result()
6467 
    self._handler.markTransactionAsProcessed(args.transactionId, args.category)
6468 
    oprot.writeMessageBegin("markTransactionAsProcessed", TMessageType.REPLY, seqid)
6469 
    result.write(oprot)
6470 
    oprot.writeMessageEnd()
6471 
    oprot.trans.flush()
6472 
 
4018 chandransh 6473 
  def process_getItemWiseRiskyOrdersCount(self, seqid, iprot, oprot):
6474 
    args = getItemWiseRiskyOrdersCount_args()
6475 
    args.read(iprot)
6476 
    iprot.readMessageEnd()
6477 
    result = getItemWiseRiskyOrdersCount_result()
6478 
    result.success = self._handler.getItemWiseRiskyOrdersCount()
6479 
    oprot.writeMessageBegin("getItemWiseRiskyOrdersCount", TMessageType.REPLY, seqid)
6480 
    result.write(oprot)
6481 
    oprot.writeMessageEnd()
6482 
    oprot.trans.flush()
4008 mandeep.dh 6483 
 
4295 varun.gupt 6484 
  def process_getOrdersForItemIds(self, seqid, iprot, oprot):
6485 
    args = getOrdersForItemIds_args()
6486 
    args.read(iprot)
6487 
    iprot.readMessageEnd()
6488 
    result = getOrdersForItemIds_result()
6489 
    result.success = self._handler.getOrdersForItemIds(args.itemIds)
6490 
    oprot.writeMessageBegin("getOrdersForItemIds", TMessageType.REPLY, seqid)
6491 
    result.write(oprot)
6492 
    oprot.writeMessageEnd()
6493 
    oprot.trans.flush()
6494 
 
4247 rajveer 6495 
  def process_markOrderCancellationRequestReceived(self, seqid, iprot, oprot):
6496 
    args = markOrderCancellationRequestReceived_args()
6497 
    args.read(iprot)
6498 
    iprot.readMessageEnd()
6499 
    result = markOrderCancellationRequestReceived_result()
6500 
    try:
6501 
      self._handler.markOrderCancellationRequestReceived(args.orderId)
6502 
    except TransactionServiceException, ex:
6503 
      result.ex = ex
6504 
    oprot.writeMessageBegin("markOrderCancellationRequestReceived", TMessageType.REPLY, seqid)
6505 
    result.write(oprot)
6506 
    oprot.writeMessageEnd()
6507 
    oprot.trans.flush()
4018 chandransh 6508 
 
4247 rajveer 6509 
  def process_markOrderCancellationRequestConfirmed(self, seqid, iprot, oprot):
6510 
    args = markOrderCancellationRequestConfirmed_args()
6511 
    args.read(iprot)
6512 
    iprot.readMessageEnd()
6513 
    result = markOrderCancellationRequestConfirmed_result()
6514 
    try:
6515 
      self._handler.markOrderCancellationRequestConfirmed(args.orderId)
6516 
    except TransactionServiceException, ex:
6517 
      result.ex = ex
6518 
    oprot.writeMessageBegin("markOrderCancellationRequestConfirmed", TMessageType.REPLY, seqid)
6519 
    result.write(oprot)
6520 
    oprot.writeMessageEnd()
6521 
    oprot.trans.flush()
6522 
 
6523 
  def process_markOrderCancellationRequestDenied(self, seqid, iprot, oprot):
6524 
    args = markOrderCancellationRequestDenied_args()
6525 
    args.read(iprot)
6526 
    iprot.readMessageEnd()
6527 
    result = markOrderCancellationRequestDenied_result()
6528 
    try:
6529 
      self._handler.markOrderCancellationRequestDenied(args.orderId)
6530 
    except TransactionServiceException, ex:
6531 
      result.ex = ex
6532 
    oprot.writeMessageBegin("markOrderCancellationRequestDenied", TMessageType.REPLY, seqid)
6533 
    result.write(oprot)
6534 
    oprot.writeMessageEnd()
6535 
    oprot.trans.flush()
6536 
 
4258 rajveer 6537 
  def process_markTransactionAsPaymentFlagRemoved(self, seqid, iprot, oprot):
6538 
    args = markTransactionAsPaymentFlagRemoved_args()
4247 rajveer 6539 
    args.read(iprot)
6540 
    iprot.readMessageEnd()
4258 rajveer 6541 
    result = markTransactionAsPaymentFlagRemoved_result()
4247 rajveer 6542 
    try:
4258 rajveer 6543 
      self._handler.markTransactionAsPaymentFlagRemoved(args.transactionId)
4247 rajveer 6544 
    except TransactionServiceException, ex:
6545 
      result.ex = ex
4258 rajveer 6546 
    oprot.writeMessageBegin("markTransactionAsPaymentFlagRemoved", TMessageType.REPLY, seqid)
4247 rajveer 6547 
    result.write(oprot)
6548 
    oprot.writeMessageEnd()
6549 
    oprot.trans.flush()
6550 
 
4259 anupam.sin 6551 
  def process_refundTransaction(self, seqid, iprot, oprot):
6552 
    args = refundTransaction_args()
6553 
    args.read(iprot)
6554 
    iprot.readMessageEnd()
6555 
    result = refundTransaction_result()
6556 
    try:
6557 
      self._handler.refundTransaction(args.transactionId, args.refundedBy, args.reason)
6558 
    except TransactionServiceException, ex:
6559 
      result.ex = ex
6560 
    oprot.writeMessageBegin("refundTransaction", TMessageType.REPLY, seqid)
6561 
    result.write(oprot)
6562 
    oprot.writeMessageEnd()
6563 
    oprot.trans.flush()
4247 rajveer 6564 
 
4324 mandeep.dh 6565 
  def process_updateShipmentAddress(self, seqid, iprot, oprot):
6566 
    args = updateShipmentAddress_args()
6567 
    args.read(iprot)
6568 
    iprot.readMessageEnd()
6569 
    result = updateShipmentAddress_result()
6570 
    try:
6571 
      self._handler.updateShipmentAddress(args.orderId, args.addressId)
6572 
    except TransactionServiceException, ex:
6573 
      result.ex = ex
6574 
    oprot.writeMessageBegin("updateShipmentAddress", TMessageType.REPLY, seqid)
6575 
    result.write(oprot)
6576 
    oprot.writeMessageEnd()
6577 
    oprot.trans.flush()
6578 
 
4285 rajveer 6579 
  def process_acceptOrdersForItemId(self, seqid, iprot, oprot):
6580 
    args = acceptOrdersForItemId_args()
6581 
    args.read(iprot)
6582 
    iprot.readMessageEnd()
6583 
    result = acceptOrdersForItemId_result()
6584 
    try:
6585 
      result.success = self._handler.acceptOrdersForItemId(args.itemId, args.inventory)
6586 
    except TransactionServiceException, ex:
6587 
      result.ex = ex
6588 
    oprot.writeMessageBegin("acceptOrdersForItemId", TMessageType.REPLY, seqid)
6589 
    result.write(oprot)
6590 
    oprot.writeMessageEnd()
6591 
    oprot.trans.flush()
4259 anupam.sin 6592 
 
4303 rajveer 6593 
  def process_markOrdersAsPORaised(self, seqid, iprot, oprot):
6594 
    args = markOrdersAsPORaised_args()
6595 
    args.read(iprot)
6596 
    iprot.readMessageEnd()
6597 
    result = markOrdersAsPORaised_result()
6598 
    try:
4369 rajveer 6599 
      self._handler.markOrdersAsPORaised(args.vendorId, args.itemId, args.quantity, args.estimate, args.isReminder)
4303 rajveer 6600 
    except TransactionServiceException, ex:
6601 
      result.ex = ex
6602 
    oprot.writeMessageBegin("markOrdersAsPORaised", TMessageType.REPLY, seqid)
6603 
    result.write(oprot)
6604 
    oprot.writeMessageEnd()
6605 
    oprot.trans.flush()
4285 rajveer 6606 
 
4303 rajveer 6607 
  def process_markOrdersAsReversalInitiated(self, seqid, iprot, oprot):
6608 
    args = markOrdersAsReversalInitiated_args()
6609 
    args.read(iprot)
6610 
    iprot.readMessageEnd()
6611 
    result = markOrdersAsReversalInitiated_result()
6612 
    try:
4369 rajveer 6613 
      self._handler.markOrdersAsReversalInitiated(args.vendorId, args.itemId, args.quantity, args.estimate, args.isReminder)
4303 rajveer 6614 
    except TransactionServiceException, ex:
6615 
      result.ex = ex
6616 
    oprot.writeMessageBegin("markOrdersAsReversalInitiated", TMessageType.REPLY, seqid)
6617 
    result.write(oprot)
6618 
    oprot.writeMessageEnd()
6619 
    oprot.trans.flush()
6620 
 
6621 
  def process_markOrdersAsNotAvailabke(self, seqid, iprot, oprot):
6622 
    args = markOrdersAsNotAvailabke_args()
6623 
    args.read(iprot)
6624 
    iprot.readMessageEnd()
6625 
    result = markOrdersAsNotAvailabke_result()
6626 
    try:
4369 rajveer 6627 
      self._handler.markOrdersAsNotAvailabke(args.vendorId, args.itemId, args.quantity, args.estimate, args.isReminder)
4303 rajveer 6628 
    except TransactionServiceException, ex:
6629 
      result.ex = ex
6630 
    oprot.writeMessageBegin("markOrdersAsNotAvailabke", TMessageType.REPLY, seqid)
6631 
    result.write(oprot)
6632 
    oprot.writeMessageEnd()
6633 
    oprot.trans.flush()
6634 
 
4369 rajveer 6635 
  def process_markOrdersAsTimeout(self, seqid, iprot, oprot):
6636 
    args = markOrdersAsTimeout_args()
6637 
    args.read(iprot)
6638 
    iprot.readMessageEnd()
6639 
    result = markOrdersAsTimeout_result()
6640 
    try:
6641 
      result.success = self._handler.markOrdersAsTimeout(args.vendorId)
6642 
    except TransactionServiceException, ex:
6643 
      result.ex = ex
6644 
    oprot.writeMessageBegin("markOrdersAsTimeout", TMessageType.REPLY, seqid)
6645 
    result.write(oprot)
6646 
    oprot.writeMessageEnd()
6647 
    oprot.trans.flush()
4303 rajveer 6648 
 
4662 rajveer 6649 
  def process_markOrderAsLostInTransit(self, seqid, iprot, oprot):
6650 
    args = markOrderAsLostInTransit_args()
6651 
    args.read(iprot)
6652 
    iprot.readMessageEnd()
6653 
    result = markOrderAsLostInTransit_result()
6654 
    try:
6655 
      result.success = self._handler.markOrderAsLostInTransit(args.orderId)
6656 
    except TransactionServiceException, ex:
6657 
      result.ex = ex
6658 
    oprot.writeMessageBegin("markOrderAsLostInTransit", TMessageType.REPLY, seqid)
6659 
    result.write(oprot)
6660 
    oprot.writeMessageEnd()
6661 
    oprot.trans.flush()
6662 
 
4386 anupam.sin 6663 
  def process_getOrderForAwb(self, seqid, iprot, oprot):
6664 
    args = getOrderForAwb_args()
6665 
    args.read(iprot)
6666 
    iprot.readMessageEnd()
6667 
    result = getOrderForAwb_result()
6668 
    try:
6669 
      result.success = self._handler.getOrderForAwb(args.awb)
6670 
    except TransactionServiceException, ex:
6671 
      result.ex = ex
6672 
    oprot.writeMessageBegin("getOrderForAwb", TMessageType.REPLY, seqid)
6673 
    result.write(oprot)
6674 
    oprot.writeMessageEnd()
6675 
    oprot.trans.flush()
4369 rajveer 6676 
 
4506 phani.kuma 6677 
  def process_getOrdersForProviderForStatus(self, seqid, iprot, oprot):
6678 
    args = getOrdersForProviderForStatus_args()
6679 
    args.read(iprot)
6680 
    iprot.readMessageEnd()
6681 
    result = getOrdersForProviderForStatus_result()
6682 
    try:
4910 phani.kuma 6683 
      result.success = self._handler.getOrdersForProviderForStatus(args.logistics_provider_id, args.order_status_list)
4506 phani.kuma 6684 
    except TransactionServiceException, ex:
6685 
      result.ex = ex
6686 
    oprot.writeMessageBegin("getOrdersForProviderForStatus", TMessageType.REPLY, seqid)
6687 
    result.write(oprot)
6688 
    oprot.writeMessageEnd()
6689 
    oprot.trans.flush()
4386 anupam.sin 6690 
 
4600 varun.gupt 6691 
  def process_getBilledOrdersForVendor(self, seqid, iprot, oprot):
6692 
    args = getBilledOrdersForVendor_args()
6693 
    args.read(iprot)
6694 
    iprot.readMessageEnd()
6695 
    result = getBilledOrdersForVendor_result()
6696 
    try:
6697 
      result.success = self._handler.getBilledOrdersForVendor(args.vendorId, args.billingDateFrom, args.billingDateTo)
6698 
    except TransactionServiceException, ex:
6699 
      result.ex = ex
6700 
    oprot.writeMessageBegin("getBilledOrdersForVendor", TMessageType.REPLY, seqid)
6701 
    result.write(oprot)
6702 
    oprot.writeMessageEnd()
6703 
    oprot.trans.flush()
4506 phani.kuma 6704 
 
4607 rajveer 6705 
  def process_getSlippedSippingDateOrders(self, seqid, iprot, oprot):
6706 
    args = getSlippedSippingDateOrders_args()
6707 
    args.read(iprot)
6708 
    iprot.readMessageEnd()
6709 
    result = getSlippedSippingDateOrders_result()
6710 
    try:
6711 
      result.success = self._handler.getSlippedSippingDateOrders()
6712 
    except TransactionServiceException, ex:
6713 
      result.ex = ex
6714 
    oprot.writeMessageBegin("getSlippedSippingDateOrders", TMessageType.REPLY, seqid)
6715 
    result.write(oprot)
6716 
    oprot.writeMessageEnd()
6717 
    oprot.trans.flush()
6718 
 
4709 rajveer 6719 
  def process_getCancelledOrders(self, seqid, iprot, oprot):
6720 
    args = getCancelledOrders_args()
6721 
    args.read(iprot)
6722 
    iprot.readMessageEnd()
6723 
    result = getCancelledOrders_result()
6724 
    try:
6725 
      result.success = self._handler.getCancelledOrders(args.cancelDateFrom, args.cancelDateTo)
6726 
    except TransactionServiceException, ex:
6727 
      result.ex = ex
6728 
    oprot.writeMessageBegin("getCancelledOrders", TMessageType.REPLY, seqid)
6729 
    result.write(oprot)
6730 
    oprot.writeMessageEnd()
6731 
    oprot.trans.flush()
6732 
 
4600 varun.gupt 6733 
  def process_saveBluedartSettlements(self, seqid, iprot, oprot):
6734 
    args = saveBluedartSettlements_args()
6735 
    args.read(iprot)
6736 
    iprot.readMessageEnd()
6737 
    result = saveBluedartSettlements_result()
6738 
    try:
6739 
      self._handler.saveBluedartSettlements(args.mapAWBAndAmount)
6740 
    except TransactionServiceException, ex:
6741 
      result.ex = ex
6742 
    oprot.writeMessageBegin("saveBluedartSettlements", TMessageType.REPLY, seqid)
6743 
    result.write(oprot)
6744 
    oprot.writeMessageEnd()
6745 
    oprot.trans.flush()
6746 
 
6747 
  def process_savePaymentSettlements(self, seqid, iprot, oprot):
6748 
    args = savePaymentSettlements_args()
6749 
    args.read(iprot)
6750 
    iprot.readMessageEnd()
6751 
    result = savePaymentSettlements_result()
6752 
    try:
4905 varun.gupt 6753 
      self._handler.savePaymentSettlements(args.settlementDate, args.paymentGatewayId, args.referenceId, args.serviceTax, args.otherCharges, args.netCollection)
4600 varun.gupt 6754 
    except TransactionServiceException, ex:
6755 
      result.ex = ex
6756 
    oprot.writeMessageBegin("savePaymentSettlements", TMessageType.REPLY, seqid)
6757 
    result.write(oprot)
6758 
    oprot.writeMessageEnd()
6759 
    oprot.trans.flush()
6760 
 
6761 
  def process_saveEBSSettlementSummary(self, seqid, iprot, oprot):
6762 
    args = saveEBSSettlementSummary_args()
6763 
    args.read(iprot)
6764 
    iprot.readMessageEnd()
6765 
    result = saveEBSSettlementSummary_result()
6766 
    try:
6767 
      self._handler.saveEBSSettlementSummary(args.settlementId, args.settlementDate, args.transactionDateFrom, args.transactionDateTo, args.amount)
6768 
    except TransactionServiceException, ex:
6769 
      result.ex = ex
6770 
    oprot.writeMessageBegin("saveEBSSettlementSummary", TMessageType.REPLY, seqid)
6771 
    result.write(oprot)
6772 
    oprot.writeMessageEnd()
6773 
    oprot.trans.flush()
6774 
 
5386 phani.kuma 6775 
  def process_getSettlementForPrepaid(self, seqid, iprot, oprot):
6776 
    args = getSettlementForPrepaid_args()
4600 varun.gupt 6777 
    args.read(iprot)
6778 
    iprot.readMessageEnd()
5386 phani.kuma 6779 
    result = getSettlementForPrepaid_result()
4600 varun.gupt 6780 
    try:
5386 phani.kuma 6781 
      result.success = self._handler.getSettlementForPrepaid(args.referenceId, args.isRefund)
4600 varun.gupt 6782 
    except TransactionServiceException, ex:
6783 
      result.ex = ex
5386 phani.kuma 6784 
    oprot.writeMessageBegin("getSettlementForPrepaid", TMessageType.REPLY, seqid)
4600 varun.gupt 6785 
    result.write(oprot)
6786 
    oprot.writeMessageEnd()
6787 
    oprot.trans.flush()
6788 
 
5386 phani.kuma 6789 
  def process_getSettlementForCod(self, seqid, iprot, oprot):
6790 
    args = getSettlementForCod_args()
6791 
    args.read(iprot)
6792 
    iprot.readMessageEnd()
6793 
    result = getSettlementForCod_result()
6794 
    try:
6795 
      result.success = self._handler.getSettlementForCod(args.orderId, args.isRefund)
6796 
    except TransactionServiceException, ex:
6797 
      result.ex = ex
6798 
    oprot.writeMessageBegin("getSettlementForCod", TMessageType.REPLY, seqid)
6799 
    result.write(oprot)
6800 
    oprot.writeMessageEnd()
6801 
    oprot.trans.flush()
6802 
 
4600 varun.gupt 6803 
  def process_getEBSSettlementSummaries(self, seqid, iprot, oprot):
6804 
    args = getEBSSettlementSummaries_args()
6805 
    args.read(iprot)
6806 
    iprot.readMessageEnd()
6807 
    result = getEBSSettlementSummaries_result()
6808 
    try:
6809 
      result.success = self._handler.getEBSSettlementSummaries()
6810 
    except TransactionServiceException, ex:
6811 
      result.ex = ex
6812 
    oprot.writeMessageBegin("getEBSSettlementSummaries", TMessageType.REPLY, seqid)
6813 
    result.write(oprot)
6814 
    oprot.writeMessageEnd()
6815 
    oprot.trans.flush()
6816 
 
6817 
  def process_markEBSSettlementUploaded(self, seqid, iprot, oprot):
6818 
    args = markEBSSettlementUploaded_args()
6819 
    args.read(iprot)
6820 
    iprot.readMessageEnd()
6821 
    result = markEBSSettlementUploaded_result()
6822 
    try:
6823 
      self._handler.markEBSSettlementUploaded(args.settlementId)
6824 
    except TransactionServiceException, ex:
6825 
      result.ex = ex
6826 
    oprot.writeMessageBegin("markEBSSettlementUploaded", TMessageType.REPLY, seqid)
6827 
    result.write(oprot)
6828 
    oprot.writeMessageEnd()
6829 
    oprot.trans.flush()
6830 
 
6831 
  def process_getEBSSettlementDate(self, seqid, iprot, oprot):
6832 
    args = getEBSSettlementDate_args()
6833 
    args.read(iprot)
6834 
    iprot.readMessageEnd()
6835 
    result = getEBSSettlementDate_result()
6836 
    try:
6837 
      result.success = self._handler.getEBSSettlementDate(args.settlementId)
6838 
    except TransactionServiceException, ex:
6839 
      result.ex = ex
6840 
    oprot.writeMessageBegin("getEBSSettlementDate", TMessageType.REPLY, seqid)
6841 
    result.write(oprot)
6842 
    oprot.writeMessageEnd()
6843 
    oprot.trans.flush()
6844 
 
4715 varun.gupt 6845 
  def process_getSettlementsByDate(self, seqid, iprot, oprot):
6846 
    args = getSettlementsByDate_args()
6847 
    args.read(iprot)
6848 
    iprot.readMessageEnd()
6849 
    result = getSettlementsByDate_result()
6850 
    try:
6851 
      result.success = self._handler.getSettlementsByDate(args.settlementDateFrom, args.settlementDateTo, args.isRefund)
6852 
    except TransactionServiceException, ex:
6853 
      result.ex = ex
6854 
    oprot.writeMessageBegin("getSettlementsByDate", TMessageType.REPLY, seqid)
6855 
    result.write(oprot)
6856 
    oprot.writeMessageEnd()
6857 
    oprot.trans.flush()
4600 varun.gupt 6858 
 
4715 varun.gupt 6859 
  def process_getReshippedOrderIds(self, seqid, iprot, oprot):
6860 
    args = getReshippedOrderIds_args()
6861 
    args.read(iprot)
6862 
    iprot.readMessageEnd()
6863 
    result = getReshippedOrderIds_result()
6864 
    try:
6865 
      result.success = self._handler.getReshippedOrderIds(args.orderIds)
6866 
    except TransactionServiceException, ex:
6867 
      result.ex = ex
6868 
    oprot.writeMessageBegin("getReshippedOrderIds", TMessageType.REPLY, seqid)
6869 
    result.write(oprot)
6870 
    oprot.writeMessageEnd()
6871 
    oprot.trans.flush()
6872 
 
5481 phani.kuma 6873 
  def process_getBilledOrders(self, seqid, iprot, oprot):
6874 
    args = getBilledOrders_args()
4875 varun.gupt 6875 
    args.read(iprot)
6876 
    iprot.readMessageEnd()
5481 phani.kuma 6877 
    result = getBilledOrders_result()
4875 varun.gupt 6878 
    try:
5481 phani.kuma 6879 
      result.success = self._handler.getBilledOrders(args.vendorId, args.onlyVendorNotPaid, args.billingDateFrom, args.billingDateTo)
4875 varun.gupt 6880 
    except TransactionServiceException, ex:
6881 
      result.ex = ex
5481 phani.kuma 6882 
    oprot.writeMessageBegin("getBilledOrders", TMessageType.REPLY, seqid)
4875 varun.gupt 6883 
    result.write(oprot)
6884 
    oprot.writeMessageEnd()
6885 
    oprot.trans.flush()
4757 mandeep.dh 6886 
 
5031 varun.gupt 6887 
  def process_getStatusDistributionOfOrders(self, seqid, iprot, oprot):
6888 
    args = getStatusDistributionOfOrders_args()
6889 
    args.read(iprot)
6890 
    iprot.readMessageEnd()
6891 
    result = getStatusDistributionOfOrders_result()
6892 
    try:
6893 
      result.success = self._handler.getStatusDistributionOfOrders(args.startDate, args.endDate)
6894 
    except TransactionServiceException, ex:
6895 
      result.ex = ex
6896 
    oprot.writeMessageBegin("getStatusDistributionOfOrders", TMessageType.REPLY, seqid)
6897 
    result.write(oprot)
6898 
    oprot.writeMessageEnd()
6899 
    oprot.trans.flush()
4875 varun.gupt 6900 
 
5067 varun.gupt 6901 
  def process_getOrderIdsForStatus(self, seqid, iprot, oprot):
6902 
    args = getOrderIdsForStatus_args()
6903 
    args.read(iprot)
6904 
    iprot.readMessageEnd()
6905 
    result = getOrderIdsForStatus_result()
6906 
    try:
6907 
      result.success = self._handler.getOrderIdsForStatus(args.status, args.startDatetime, args.endDatetime)
6908 
    except TransactionServiceException, ex:
6909 
      result.ex = ex
6910 
    oprot.writeMessageBegin("getOrderIdsForStatus", TMessageType.REPLY, seqid)
6911 
    result.write(oprot)
6912 
    oprot.writeMessageEnd()
6913 
    oprot.trans.flush()
5031 varun.gupt 6914 
 
5348 anupam.sin 6915 
  def process_updateCODAgent(self, seqid, iprot, oprot):
6916 
    args = updateCODAgent_args()
6917 
    args.read(iprot)
6918 
    iprot.readMessageEnd()
6919 
    result = updateCODAgent_result()
6920 
    try:
6921 
      self._handler.updateCODAgent(args.agent, args.orderId)
6922 
    except TransactionServiceException, ex:
6923 
      result.ex = ex
6924 
    oprot.writeMessageBegin("updateCODAgent", TMessageType.REPLY, seqid)
6925 
    result.write(oprot)
6926 
    oprot.writeMessageEnd()
6927 
    oprot.trans.flush()
6928 
 
5099 varun.gupt 6929 
  def process_updateOrderAsPaidToVendor(self, seqid, iprot, oprot):
6930 
    args = updateOrderAsPaidToVendor_args()
6931 
    args.read(iprot)
6932 
    iprot.readMessageEnd()
6933 
    result = updateOrderAsPaidToVendor_result()
6934 
    try:
6935 
      self._handler.updateOrderAsPaidToVendor(args.orderId)
6936 
    except TransactionServiceException, ex:
6937 
      result.ex = ex
6938 
    oprot.writeMessageBegin("updateOrderAsPaidToVendor", TMessageType.REPLY, seqid)
6939 
    result.write(oprot)
6940 
    oprot.writeMessageEnd()
6941 
    oprot.trans.flush()
5067 varun.gupt 6942 
 
5386 phani.kuma 6943 
  def process_updateOrderOnlyAsPaidToVendor(self, seqid, iprot, oprot):
6944 
    args = updateOrderOnlyAsPaidToVendor_args()
6945 
    args.read(iprot)
6946 
    iprot.readMessageEnd()
6947 
    result = updateOrderOnlyAsPaidToVendor_result()
6948 
    try:
6949 
      self._handler.updateOrderOnlyAsPaidToVendor(args.orderId)
6950 
    except TransactionServiceException, ex:
6951 
      result.ex = ex
6952 
    oprot.writeMessageBegin("updateOrderOnlyAsPaidToVendor", TMessageType.REPLY, seqid)
6953 
    result.write(oprot)
6954 
    oprot.writeMessageEnd()
6955 
    oprot.trans.flush()
6956 
 
5208 varun.gupt 6957 
  def process_getRefundedOrdersMarkedPaid(self, seqid, iprot, oprot):
6958 
    args = getRefundedOrdersMarkedPaid_args()
6959 
    args.read(iprot)
6960 
    iprot.readMessageEnd()
6961 
    result = getRefundedOrdersMarkedPaid_result()
6962 
    try:
6963 
      result.success = self._handler.getRefundedOrdersMarkedPaid()
6964 
    except TransactionServiceException, ex:
6965 
      result.ex = ex
6966 
    oprot.writeMessageBegin("getRefundedOrdersMarkedPaid", TMessageType.REPLY, seqid)
6967 
    result.write(oprot)
6968 
    oprot.writeMessageEnd()
6969 
    oprot.trans.flush()
5099 varun.gupt 6970 
 
5447 anupam.sin 6971 
  def process_getAllVerificationAgents(self, seqid, iprot, oprot):
6972 
    args = getAllVerificationAgents_args()
6973 
    args.read(iprot)
6974 
    iprot.readMessageEnd()
6975 
    result = getAllVerificationAgents_result()
6976 
    result.success = self._handler.getAllVerificationAgents(args.minOrderId, args.maxOrderId)
6977 
    oprot.writeMessageBegin("getAllVerificationAgents", TMessageType.REPLY, seqid)
6978 
    result.write(oprot)
6979 
    oprot.writeMessageEnd()
6980 
    oprot.trans.flush()
5208 varun.gupt 6981 
 
5527 anupam.sin 6982 
  def process_getAllAttributesForOrderId(self, seqid, iprot, oprot):
6983 
    args = getAllAttributesForOrderId_args()
6984 
    args.read(iprot)
6985 
    iprot.readMessageEnd()
6986 
    result = getAllAttributesForOrderId_result()
6987 
    result.success = self._handler.getAllAttributesForOrderId(args.orderId)
6988 
    oprot.writeMessageBegin("getAllAttributesForOrderId", TMessageType.REPLY, seqid)
6989 
    result.write(oprot)
6990 
    oprot.writeMessageEnd()
6991 
    oprot.trans.flush()
5447 anupam.sin 6992 
 
5527 anupam.sin 6993 
  def process_setOrderAttributeForTransaction(self, seqid, iprot, oprot):
6994 
    args = setOrderAttributeForTransaction_args()
6995 
    args.read(iprot)
6996 
    iprot.readMessageEnd()
6997 
    result = setOrderAttributeForTransaction_result()
6998 
    self._handler.setOrderAttributeForTransaction(args.transactionId, args.attribute)
6999 
    oprot.writeMessageBegin("setOrderAttributeForTransaction", TMessageType.REPLY, seqid)
7000 
    result.write(oprot)
7001 
    oprot.writeMessageEnd()
7002 
    oprot.trans.flush()
7003 
 
7004 
 
94 ashish 7005 
# HELPER FUNCTIONS AND STRUCTURES
7006 
 
7007 
class createTransaction_args:
7008 
  """
7009 
  Attributes:
7010 
   - transaction
7011 
  """
7012 
 
7013 
  thrift_spec = (
7014 
    None, # 0
7015 
    (1, TType.STRUCT, 'transaction', (Transaction, Transaction.thrift_spec), None, ), # 1
7016 
  )
7017 
 
7018 
  def __init__(self, transaction=None,):
7019 
    self.transaction = transaction
7020 
 
7021 
  def read(self, iprot):
7022 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
7023 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
7024 
      return
7025 
    iprot.readStructBegin()
7026 
    while True:
7027 
      (fname, ftype, fid) = iprot.readFieldBegin()
7028 
      if ftype == TType.STOP:
7029 
        break
7030 
      if fid == 1:
7031 
        if ftype == TType.STRUCT:
7032 
          self.transaction = Transaction()
7033 
          self.transaction.read(iprot)
7034 
        else:
7035 
          iprot.skip(ftype)
7036 
      else:
7037 
        iprot.skip(ftype)
7038 
      iprot.readFieldEnd()
7039 
    iprot.readStructEnd()
7040 
 
7041 
  def write(self, oprot):
7042 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
7043 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
7044 
      return
7045 
    oprot.writeStructBegin('createTransaction_args')
3431 rajveer 7046 
    if self.transaction is not None:
94 ashish 7047 
      oprot.writeFieldBegin('transaction', TType.STRUCT, 1)
7048 
      self.transaction.write(oprot)
7049 
      oprot.writeFieldEnd()
7050 
    oprot.writeFieldStop()
7051 
    oprot.writeStructEnd()
7052 
 
3431 rajveer 7053 
  def validate(self):
7054 
    return
7055 
 
7056 
 
94 ashish 7057 
  def __repr__(self):
7058 
    L = ['%s=%r' % (key, value)
7059 
      for key, value in self.__dict__.iteritems()]
7060 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
7061 
 
7062 
  def __eq__(self, other):
7063 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
7064 
 
7065 
  def __ne__(self, other):
7066 
    return not (self == other)
7067 
 
7068 
class createTransaction_result:
7069 
  """
7070 
  Attributes:
132 ashish 7071 
   - success
94 ashish 7072 
   - ex
7073 
  """
7074 
 
7075 
  thrift_spec = (
132 ashish 7076 
    (0, TType.I64, 'success', None, None, ), # 0
94 ashish 7077 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
7078 
  )
7079 
 
132 ashish 7080 
  def __init__(self, success=None, ex=None,):
7081 
    self.success = success
94 ashish 7082 
    self.ex = ex
7083 
 
7084 
  def read(self, iprot):
7085 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
7086 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
7087 
      return
7088 
    iprot.readStructBegin()
7089 
    while True:
7090 
      (fname, ftype, fid) = iprot.readFieldBegin()
7091 
      if ftype == TType.STOP:
7092 
        break
132 ashish 7093 
      if fid == 0:
7094 
        if ftype == TType.I64:
7095 
          self.success = iprot.readI64();
7096 
        else:
7097 
          iprot.skip(ftype)
7098 
      elif fid == 1:
94 ashish 7099 
        if ftype == TType.STRUCT:
7100 
          self.ex = TransactionServiceException()
7101 
          self.ex.read(iprot)
7102 
        else:
7103 
          iprot.skip(ftype)
7104 
      else:
7105 
        iprot.skip(ftype)
7106 
      iprot.readFieldEnd()
7107 
    iprot.readStructEnd()
7108 
 
7109 
  def write(self, oprot):
7110 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
7111 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
7112 
      return
7113 
    oprot.writeStructBegin('createTransaction_result')
3431 rajveer 7114 
    if self.success is not None:
132 ashish 7115 
      oprot.writeFieldBegin('success', TType.I64, 0)
7116 
      oprot.writeI64(self.success)
7117 
      oprot.writeFieldEnd()
3431 rajveer 7118 
    if self.ex is not None:
94 ashish 7119 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
7120 
      self.ex.write(oprot)
7121 
      oprot.writeFieldEnd()
7122 
    oprot.writeFieldStop()
7123 
    oprot.writeStructEnd()
7124 
 
3431 rajveer 7125 
  def validate(self):
7126 
    return
7127 
 
7128 
 
94 ashish 7129 
  def __repr__(self):
7130 
    L = ['%s=%r' % (key, value)
7131 
      for key, value in self.__dict__.iteritems()]
7132 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
7133 
 
7134 
  def __eq__(self, other):
7135 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
7136 
 
7137 
  def __ne__(self, other):
7138 
    return not (self == other)
7139 
 
7140 
class getTransaction_args:
7141 
  """
7142 
  Attributes:
7143 
   - id
7144 
  """
7145 
 
7146 
  thrift_spec = (
7147 
    None, # 0
7148 
    (1, TType.I64, 'id', None, None, ), # 1
7149 
  )
7150 
 
7151 
  def __init__(self, id=None,):
7152 
    self.id = id
7153 
 
7154 
  def read(self, iprot):
7155 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
7156 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
7157 
      return
7158 
    iprot.readStructBegin()
7159 
    while True:
7160 
      (fname, ftype, fid) = iprot.readFieldBegin()
7161 
      if ftype == TType.STOP:
7162 
        break
7163 
      if fid == 1:
7164 
        if ftype == TType.I64:
7165 
          self.id = iprot.readI64();
7166 
        else:
7167 
          iprot.skip(ftype)
7168 
      else:
7169 
        iprot.skip(ftype)
7170 
      iprot.readFieldEnd()
7171 
    iprot.readStructEnd()
7172 
 
7173 
  def write(self, oprot):
7174 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
7175 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
7176 
      return
7177 
    oprot.writeStructBegin('getTransaction_args')
3431 rajveer 7178 
    if self.id is not None:
94 ashish 7179 
      oprot.writeFieldBegin('id', TType.I64, 1)
7180 
      oprot.writeI64(self.id)
7181 
      oprot.writeFieldEnd()
7182 
    oprot.writeFieldStop()
7183 
    oprot.writeStructEnd()
7184 
 
3431 rajveer 7185 
  def validate(self):
7186 
    return
7187 
 
7188 
 
94 ashish 7189 
  def __repr__(self):
7190 
    L = ['%s=%r' % (key, value)
7191 
      for key, value in self.__dict__.iteritems()]
7192 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
7193 
 
7194 
  def __eq__(self, other):
7195 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
7196 
 
7197 
  def __ne__(self, other):
7198 
    return not (self == other)
7199 
 
7200 
class getTransaction_result:
7201 
  """
7202 
  Attributes:
7203 
   - success
7204 
   - ex
7205 
  """
7206 
 
7207 
  thrift_spec = (
7208 
    (0, TType.STRUCT, 'success', (Transaction, Transaction.thrift_spec), None, ), # 0
7209 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
7210 
  )
7211 
 
7212 
  def __init__(self, success=None, ex=None,):
7213 
    self.success = success
7214 
    self.ex = ex
7215 
 
7216 
  def read(self, iprot):
7217 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
7218 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
7219 
      return
7220 
    iprot.readStructBegin()
7221 
    while True:
7222 
      (fname, ftype, fid) = iprot.readFieldBegin()
7223 
      if ftype == TType.STOP:
7224 
        break
7225 
      if fid == 0:
7226 
        if ftype == TType.STRUCT:
7227 
          self.success = Transaction()
7228 
          self.success.read(iprot)
7229 
        else:
7230 
          iprot.skip(ftype)
7231 
      elif fid == 1:
7232 
        if ftype == TType.STRUCT:
7233 
          self.ex = TransactionServiceException()
7234 
          self.ex.read(iprot)
7235 
        else:
7236 
          iprot.skip(ftype)
7237 
      else:
7238 
        iprot.skip(ftype)
7239 
      iprot.readFieldEnd()
7240 
    iprot.readStructEnd()
7241 
 
7242 
  def write(self, oprot):
7243 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
7244 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
7245 
      return
7246 
    oprot.writeStructBegin('getTransaction_result')
3431 rajveer 7247 
    if self.success is not None:
94 ashish 7248 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
7249 
      self.success.write(oprot)
7250 
      oprot.writeFieldEnd()
3431 rajveer 7251 
    if self.ex is not None:
94 ashish 7252 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
7253 
      self.ex.write(oprot)
7254 
      oprot.writeFieldEnd()
7255 
    oprot.writeFieldStop()
7256 
    oprot.writeStructEnd()
7257 
 
3431 rajveer 7258 
  def validate(self):
7259 
    return
7260 
 
7261 
 
94 ashish 7262 
  def __repr__(self):
7263 
    L = ['%s=%r' % (key, value)
7264 
      for key, value in self.__dict__.iteritems()]
7265 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
7266 
 
7267 
  def __eq__(self, other):
7268 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
7269 
 
7270 
  def __ne__(self, other):
7271 
    return not (self == other)
7272 
 
7273 
class getTransactionsForCustomer_args:
7274 
  """
7275 
  Attributes:
7276 
   - customerId
7277 
   - from_date
7278 
   - to_date
7279 
   - status
7280 
  """
7281 
 
7282 
  thrift_spec = (
7283 
    None, # 0
7284 
    (1, TType.I64, 'customerId', None, None, ), # 1
7285 
    (2, TType.I64, 'from_date', None, None, ), # 2
7286 
    (3, TType.I64, 'to_date', None, None, ), # 3
7287 
    (4, TType.I32, 'status', None, None, ), # 4
7288 
  )
7289 
 
7290 
  def __init__(self, customerId=None, from_date=None, to_date=None, status=None,):
7291 
    self.customerId = customerId
7292 
    self.from_date = from_date
7293 
    self.to_date = to_date
7294 
    self.status = status
7295 
 
7296 
  def read(self, iprot):
7297 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
7298 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
7299 
      return
7300 
    iprot.readStructBegin()
7301 
    while True:
7302 
      (fname, ftype, fid) = iprot.readFieldBegin()
7303 
      if ftype == TType.STOP:
7304 
        break
7305 
      if fid == 1:
7306 
        if ftype == TType.I64:
7307 
          self.customerId = iprot.readI64();
7308 
        else:
7309 
          iprot.skip(ftype)
7310 
      elif fid == 2:
7311 
        if ftype == TType.I64:
7312 
          self.from_date = iprot.readI64();
7313 
        else:
7314 
          iprot.skip(ftype)
7315 
      elif fid == 3:
7316 
        if ftype == TType.I64:
7317 
          self.to_date = iprot.readI64();
7318 
        else:
7319 
          iprot.skip(ftype)
7320 
      elif fid == 4:
7321 
        if ftype == TType.I32:
7322 
          self.status = iprot.readI32();
7323 
        else:
7324 
          iprot.skip(ftype)
7325 
      else:
7326 
        iprot.skip(ftype)
7327 
      iprot.readFieldEnd()
7328 
    iprot.readStructEnd()
7329 
 
7330 
  def write(self, oprot):
7331 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
7332 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
7333 
      return
7334 
    oprot.writeStructBegin('getTransactionsForCustomer_args')
3431 rajveer 7335 
    if self.customerId is not None:
94 ashish 7336 
      oprot.writeFieldBegin('customerId', TType.I64, 1)
7337 
      oprot.writeI64(self.customerId)
7338 
      oprot.writeFieldEnd()
3431 rajveer 7339 
    if self.from_date is not None:
94 ashish 7340 
      oprot.writeFieldBegin('from_date', TType.I64, 2)
7341 
      oprot.writeI64(self.from_date)
7342 
      oprot.writeFieldEnd()
3431 rajveer 7343 
    if self.to_date is not None:
94 ashish 7344 
      oprot.writeFieldBegin('to_date', TType.I64, 3)
7345 
      oprot.writeI64(self.to_date)
7346 
      oprot.writeFieldEnd()
3431 rajveer 7347 
    if self.status is not None:
94 ashish 7348 
      oprot.writeFieldBegin('status', TType.I32, 4)
7349 
      oprot.writeI32(self.status)
7350 
      oprot.writeFieldEnd()
7351 
    oprot.writeFieldStop()
7352 
    oprot.writeStructEnd()
7353 
 
3431 rajveer 7354 
  def validate(self):
7355 
    return
7356 
 
7357 
 
94 ashish 7358 
  def __repr__(self):
7359 
    L = ['%s=%r' % (key, value)
7360 
      for key, value in self.__dict__.iteritems()]
7361 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
7362 
 
7363 
  def __eq__(self, other):
7364 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
7365 
 
7366 
  def __ne__(self, other):
7367 
    return not (self == other)
7368 
 
7369 
class getTransactionsForCustomer_result:
7370 
  """
7371 
  Attributes:
7372 
   - success
7373 
   - ex
7374 
  """
7375 
 
7376 
  thrift_spec = (
7377 
    (0, TType.LIST, 'success', (TType.STRUCT,(Transaction, Transaction.thrift_spec)), None, ), # 0
7378 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
7379 
  )
7380 
 
7381 
  def __init__(self, success=None, ex=None,):
7382 
    self.success = success
7383 
    self.ex = ex
7384 
 
7385 
  def read(self, iprot):
7386 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
7387 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
7388 
      return
7389 
    iprot.readStructBegin()
7390 
    while True:
7391 
      (fname, ftype, fid) = iprot.readFieldBegin()
7392 
      if ftype == TType.STOP:
7393 
        break
7394 
      if fid == 0:
7395 
        if ftype == TType.LIST:
7396 
          self.success = []
5031 varun.gupt 7397 
          (_etype66, _size63) = iprot.readListBegin()
7398 
          for _i67 in xrange(_size63):
7399 
            _elem68 = Transaction()
7400 
            _elem68.read(iprot)
7401 
            self.success.append(_elem68)
94 ashish 7402 
          iprot.readListEnd()
7403 
        else:
7404 
          iprot.skip(ftype)
7405 
      elif fid == 1:
7406 
        if ftype == TType.STRUCT:
7407 
          self.ex = TransactionServiceException()
7408 
          self.ex.read(iprot)
7409 
        else:
7410 
          iprot.skip(ftype)
7411 
      else:
7412 
        iprot.skip(ftype)
7413 
      iprot.readFieldEnd()
7414 
    iprot.readStructEnd()
7415 
 
7416 
  def write(self, oprot):
7417 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
7418 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
7419 
      return
7420 
    oprot.writeStructBegin('getTransactionsForCustomer_result')
3431 rajveer 7421 
    if self.success is not None:
94 ashish 7422 
      oprot.writeFieldBegin('success', TType.LIST, 0)
7423 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
5031 varun.gupt 7424 
      for iter69 in self.success:
7425 
        iter69.write(oprot)
94 ashish 7426 
      oprot.writeListEnd()
7427 
      oprot.writeFieldEnd()
3431 rajveer 7428 
    if self.ex is not None:
94 ashish 7429 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
7430 
      self.ex.write(oprot)
7431 
      oprot.writeFieldEnd()
7432 
    oprot.writeFieldStop()
7433 
    oprot.writeStructEnd()
7434 
 
3431 rajveer 7435 
  def validate(self):
7436 
    return
7437 
 
7438 
 
94 ashish 7439 
  def __repr__(self):
7440 
    L = ['%s=%r' % (key, value)
7441 
      for key, value in self.__dict__.iteritems()]
7442 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
7443 
 
7444 
  def __eq__(self, other):
7445 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
7446 
 
7447 
  def __ne__(self, other):
7448 
    return not (self == other)
7449 
 
132 ashish 7450 
class getTransactionsForShoppingCartId_args:
7451 
  """
7452 
  Attributes:
7453 
   - shoppingCartId
7454 
  """
7455 
 
7456 
  thrift_spec = (
7457 
    None, # 0
7458 
    (1, TType.I64, 'shoppingCartId', None, None, ), # 1
7459 
  )
7460 
 
7461 
  def __init__(self, shoppingCartId=None,):
7462 
    self.shoppingCartId = shoppingCartId
7463 
 
7464 
  def read(self, iprot):
7465 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
7466 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
7467 
      return
7468 
    iprot.readStructBegin()
7469 
    while True:
7470 
      (fname, ftype, fid) = iprot.readFieldBegin()
7471 
      if ftype == TType.STOP:
7472 
        break
7473 
      if fid == 1:
7474 
        if ftype == TType.I64:
7475 
          self.shoppingCartId = iprot.readI64();
7476 
        else:
7477 
          iprot.skip(ftype)
7478 
      else:
7479 
        iprot.skip(ftype)
7480 
      iprot.readFieldEnd()
7481 
    iprot.readStructEnd()
7482 
 
7483 
  def write(self, oprot):
7484 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
7485 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
7486 
      return
7487 
    oprot.writeStructBegin('getTransactionsForShoppingCartId_args')
3431 rajveer 7488 
    if self.shoppingCartId is not None:
132 ashish 7489 
      oprot.writeFieldBegin('shoppingCartId', TType.I64, 1)
7490 
      oprot.writeI64(self.shoppingCartId)
7491 
      oprot.writeFieldEnd()
7492 
    oprot.writeFieldStop()
7493 
    oprot.writeStructEnd()
7494 
 
3431 rajveer 7495 
  def validate(self):
7496 
    return
7497 
 
7498 
 
132 ashish 7499 
  def __repr__(self):
7500 
    L = ['%s=%r' % (key, value)
7501 
      for key, value in self.__dict__.iteritems()]
7502 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
7503 
 
7504 
  def __eq__(self, other):
7505 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
7506 
 
7507 
  def __ne__(self, other):
7508 
    return not (self == other)
7509 
 
7510 
class getTransactionsForShoppingCartId_result:
7511 
  """
7512 
  Attributes:
7513 
   - success
7514 
   - ex
7515 
  """
7516 
 
7517 
  thrift_spec = (
7518 
    (0, TType.LIST, 'success', (TType.STRUCT,(Transaction, Transaction.thrift_spec)), None, ), # 0
7519 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
7520 
  )
7521 
 
7522 
  def __init__(self, success=None, ex=None,):
7523 
    self.success = success
7524 
    self.ex = ex
7525 
 
7526 
  def read(self, iprot):
7527 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
7528 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
7529 
      return
7530 
    iprot.readStructBegin()
7531 
    while True:
7532 
      (fname, ftype, fid) = iprot.readFieldBegin()
7533 
      if ftype == TType.STOP:
7534 
        break
7535 
      if fid == 0:
7536 
        if ftype == TType.LIST:
7537 
          self.success = []
5031 varun.gupt 7538 
          (_etype73, _size70) = iprot.readListBegin()
7539 
          for _i74 in xrange(_size70):
7540 
            _elem75 = Transaction()
7541 
            _elem75.read(iprot)
7542 
            self.success.append(_elem75)
132 ashish 7543 
          iprot.readListEnd()
7544 
        else:
7545 
          iprot.skip(ftype)
7546 
      elif fid == 1:
7547 
        if ftype == TType.STRUCT:
7548 
          self.ex = TransactionServiceException()
7549 
          self.ex.read(iprot)
7550 
        else:
7551 
          iprot.skip(ftype)
7552 
      else:
7553 
        iprot.skip(ftype)
7554 
      iprot.readFieldEnd()
7555 
    iprot.readStructEnd()
7556 
 
7557 
  def write(self, oprot):
7558 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
7559 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
7560 
      return
7561 
    oprot.writeStructBegin('getTransactionsForShoppingCartId_result')
3431 rajveer 7562 
    if self.success is not None:
132 ashish 7563 
      oprot.writeFieldBegin('success', TType.LIST, 0)
7564 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
5031 varun.gupt 7565 
      for iter76 in self.success:
7566 
        iter76.write(oprot)
132 ashish 7567 
      oprot.writeListEnd()
7568 
      oprot.writeFieldEnd()
3431 rajveer 7569 
    if self.ex is not None:
132 ashish 7570 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
7571 
      self.ex.write(oprot)
7572 
      oprot.writeFieldEnd()
7573 
    oprot.writeFieldStop()
7574 
    oprot.writeStructEnd()
7575 
 
3431 rajveer 7576 
  def validate(self):
7577 
    return
7578 
 
7579 
 
132 ashish 7580 
  def __repr__(self):
7581 
    L = ['%s=%r' % (key, value)
7582 
      for key, value in self.__dict__.iteritems()]
7583 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
7584 
 
7585 
  def __eq__(self, other):
7586 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
7587 
 
7588 
  def __ne__(self, other):
7589 
    return not (self == other)
7590 
 
94 ashish 7591 
class getTransactionStatus_args:
7592 
  """
7593 
  Attributes:
7594 
   - transactionId
7595 
  """
7596 
 
7597 
  thrift_spec = (
7598 
    None, # 0
7599 
    (1, TType.I64, 'transactionId', None, None, ), # 1
7600 
  )
7601 
 
7602 
  def __init__(self, transactionId=None,):
7603 
    self.transactionId = transactionId
7604 
 
7605 
  def read(self, iprot):
7606 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
7607 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
7608 
      return
7609 
    iprot.readStructBegin()
7610 
    while True:
7611 
      (fname, ftype, fid) = iprot.readFieldBegin()
7612 
      if ftype == TType.STOP:
7613 
        break
7614 
      if fid == 1:
7615 
        if ftype == TType.I64:
7616 
          self.transactionId = iprot.readI64();
7617 
        else:
7618 
          iprot.skip(ftype)
7619 
      else:
7620 
        iprot.skip(ftype)
7621 
      iprot.readFieldEnd()
7622 
    iprot.readStructEnd()
7623 
 
7624 
  def write(self, oprot):
7625 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
7626 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
7627 
      return
7628 
    oprot.writeStructBegin('getTransactionStatus_args')
3431 rajveer 7629 
    if self.transactionId is not None:
94 ashish 7630 
      oprot.writeFieldBegin('transactionId', TType.I64, 1)
7631 
      oprot.writeI64(self.transactionId)
7632 
      oprot.writeFieldEnd()
7633 
    oprot.writeFieldStop()
7634 
    oprot.writeStructEnd()
7635 
 
3431 rajveer 7636 
  def validate(self):
7637 
    return
7638 
 
7639 
 
94 ashish 7640 
  def __repr__(self):
7641 
    L = ['%s=%r' % (key, value)
7642 
      for key, value in self.__dict__.iteritems()]
7643 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
7644 
 
7645 
  def __eq__(self, other):
7646 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
7647 
 
7648 
  def __ne__(self, other):
7649 
    return not (self == other)
7650 
 
7651 
class getTransactionStatus_result:
7652 
  """
7653 
  Attributes:
7654 
   - success
7655 
   - ex
7656 
  """
7657 
 
7658 
  thrift_spec = (
7659 
    (0, TType.I32, 'success', None, None, ), # 0
7660 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
7661 
  )
7662 
 
7663 
  def __init__(self, success=None, ex=None,):
7664 
    self.success = success
7665 
    self.ex = ex
7666 
 
7667 
  def read(self, iprot):
7668 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
7669 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
7670 
      return
7671 
    iprot.readStructBegin()
7672 
    while True:
7673 
      (fname, ftype, fid) = iprot.readFieldBegin()
7674 
      if ftype == TType.STOP:
7675 
        break
7676 
      if fid == 0:
7677 
        if ftype == TType.I32:
7678 
          self.success = iprot.readI32();
7679 
        else:
7680 
          iprot.skip(ftype)
7681 
      elif fid == 1:
7682 
        if ftype == TType.STRUCT:
7683 
          self.ex = TransactionServiceException()
7684 
          self.ex.read(iprot)
7685 
        else:
7686 
          iprot.skip(ftype)
7687 
      else:
7688 
        iprot.skip(ftype)
7689 
      iprot.readFieldEnd()
7690 
    iprot.readStructEnd()
7691 
 
7692 
  def write(self, oprot):
7693 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
7694 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
7695 
      return
7696 
    oprot.writeStructBegin('getTransactionStatus_result')
3431 rajveer 7697 
    if self.success is not None:
94 ashish 7698 
      oprot.writeFieldBegin('success', TType.I32, 0)
7699 
      oprot.writeI32(self.success)
7700 
      oprot.writeFieldEnd()
3431 rajveer 7701 
    if self.ex is not None:
94 ashish 7702 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
7703 
      self.ex.write(oprot)
7704 
      oprot.writeFieldEnd()
7705 
    oprot.writeFieldStop()
7706 
    oprot.writeStructEnd()
7707 
 
3431 rajveer 7708 
  def validate(self):
7709 
    return
7710 
 
7711 
 
94 ashish 7712 
  def __repr__(self):
7713 
    L = ['%s=%r' % (key, value)
7714 
      for key, value in self.__dict__.iteritems()]
7715 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
7716 
 
7717 
  def __eq__(self, other):
7718 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
7719 
 
7720 
  def __ne__(self, other):
7721 
    return not (self == other)
7722 
 
7723 
class changeTransactionStatus_args:
7724 
  """
7725 
  Attributes:
7726 
   - transactionId
7727 
   - status
7728 
   - description
5527 anupam.sin 7729 
   - pickUp
7730 
   - orderType
94 ashish 7731 
  """
7732 
 
7733 
  thrift_spec = (
7734 
    None, # 0
7735 
    (1, TType.I64, 'transactionId', None, None, ), # 1
7736 
    (2, TType.I32, 'status', None, None, ), # 2
7737 
    (3, TType.STRING, 'description', None, None, ), # 3
5527 anupam.sin 7738 
    (4, TType.I64, 'pickUp', None, None, ), # 4
7739 
    (5, TType.I32, 'orderType', None, None, ), # 5
94 ashish 7740 
  )
7741 
 
5527 anupam.sin 7742 
  def __init__(self, transactionId=None, status=None, description=None, pickUp=None, orderType=None,):
94 ashish 7743 
    self.transactionId = transactionId
7744 
    self.status = status
7745 
    self.description = description
5527 anupam.sin 7746 
    self.pickUp = pickUp
7747 
    self.orderType = orderType
94 ashish 7748 
 
7749 
  def read(self, iprot):
7750 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
7751 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
7752 
      return
7753 
    iprot.readStructBegin()
7754 
    while True:
7755 
      (fname, ftype, fid) = iprot.readFieldBegin()
7756 
      if ftype == TType.STOP:
7757 
        break
7758 
      if fid == 1:
7759 
        if ftype == TType.I64:
7760 
          self.transactionId = iprot.readI64();
7761 
        else:
7762 
          iprot.skip(ftype)
7763 
      elif fid == 2:
7764 
        if ftype == TType.I32:
7765 
          self.status = iprot.readI32();
7766 
        else:
7767 
          iprot.skip(ftype)
7768 
      elif fid == 3:
7769 
        if ftype == TType.STRING:
7770 
          self.description = iprot.readString();
7771 
        else:
7772 
          iprot.skip(ftype)
5387 rajveer 7773 
      elif fid == 4:
5527 anupam.sin 7774 
        if ftype == TType.I64:
7775 
          self.pickUp = iprot.readI64();
5387 rajveer 7776 
        else:
7777 
          iprot.skip(ftype)
5527 anupam.sin 7778 
      elif fid == 5:
7779 
        if ftype == TType.I32:
7780 
          self.orderType = iprot.readI32();
7781 
        else:
7782 
          iprot.skip(ftype)
94 ashish 7783 
      else:
7784 
        iprot.skip(ftype)
7785 
      iprot.readFieldEnd()
7786 
    iprot.readStructEnd()
7787 
 
7788 
  def write(self, oprot):
7789 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
7790 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
7791 
      return
7792 
    oprot.writeStructBegin('changeTransactionStatus_args')
3431 rajveer 7793 
    if self.transactionId is not None:
94 ashish 7794 
      oprot.writeFieldBegin('transactionId', TType.I64, 1)
7795 
      oprot.writeI64(self.transactionId)
7796 
      oprot.writeFieldEnd()
3431 rajveer 7797 
    if self.status is not None:
94 ashish 7798 
      oprot.writeFieldBegin('status', TType.I32, 2)
7799 
      oprot.writeI32(self.status)
7800 
      oprot.writeFieldEnd()
3431 rajveer 7801 
    if self.description is not None:
94 ashish 7802 
      oprot.writeFieldBegin('description', TType.STRING, 3)
7803 
      oprot.writeString(self.description)
7804 
      oprot.writeFieldEnd()
5527 anupam.sin 7805 
    if self.pickUp is not None:
7806 
      oprot.writeFieldBegin('pickUp', TType.I64, 4)
7807 
      oprot.writeI64(self.pickUp)
5387 rajveer 7808 
      oprot.writeFieldEnd()
5527 anupam.sin 7809 
    if self.orderType is not None:
7810 
      oprot.writeFieldBegin('orderType', TType.I32, 5)
7811 
      oprot.writeI32(self.orderType)
7812 
      oprot.writeFieldEnd()
94 ashish 7813 
    oprot.writeFieldStop()
7814 
    oprot.writeStructEnd()
7815 
 
3431 rajveer 7816 
  def validate(self):
7817 
    return
7818 
 
7819 
 
94 ashish 7820 
  def __repr__(self):
7821 
    L = ['%s=%r' % (key, value)
7822 
      for key, value in self.__dict__.iteritems()]
7823 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
7824 
 
7825 
  def __eq__(self, other):
7826 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
7827 
 
7828 
  def __ne__(self, other):
7829 
    return not (self == other)
7830 
 
7831 
class changeTransactionStatus_result:
7832 
  """
7833 
  Attributes:
7834 
   - success
7835 
   - ex
7836 
  """
7837 
 
7838 
  thrift_spec = (
7839 
    (0, TType.BOOL, 'success', None, None, ), # 0
7840 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
7841 
  )
7842 
 
7843 
  def __init__(self, success=None, ex=None,):
7844 
    self.success = success
7845 
    self.ex = ex
7846 
 
7847 
  def read(self, iprot):
7848 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
7849 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
7850 
      return
7851 
    iprot.readStructBegin()
7852 
    while True:
7853 
      (fname, ftype, fid) = iprot.readFieldBegin()
7854 
      if ftype == TType.STOP:
7855 
        break
7856 
      if fid == 0:
7857 
        if ftype == TType.BOOL:
7858 
          self.success = iprot.readBool();
7859 
        else:
7860 
          iprot.skip(ftype)
7861 
      elif fid == 1:
7862 
        if ftype == TType.STRUCT:
7863 
          self.ex = TransactionServiceException()
7864 
          self.ex.read(iprot)
7865 
        else:
7866 
          iprot.skip(ftype)
7867 
      else:
7868 
        iprot.skip(ftype)
7869 
      iprot.readFieldEnd()
7870 
    iprot.readStructEnd()
7871 
 
7872 
  def write(self, oprot):
7873 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
7874 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
7875 
      return
7876 
    oprot.writeStructBegin('changeTransactionStatus_result')
3431 rajveer 7877 
    if self.success is not None:
94 ashish 7878 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
7879 
      oprot.writeBool(self.success)
7880 
      oprot.writeFieldEnd()
3431 rajveer 7881 
    if self.ex is not None:
94 ashish 7882 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
7883 
      self.ex.write(oprot)
7884 
      oprot.writeFieldEnd()
7885 
    oprot.writeFieldStop()
7886 
    oprot.writeStructEnd()
7887 
 
3431 rajveer 7888 
  def validate(self):
7889 
    return
7890 
 
7891 
 
94 ashish 7892 
  def __repr__(self):
7893 
    L = ['%s=%r' % (key, value)
7894 
      for key, value in self.__dict__.iteritems()]
7895 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
7896 
 
7897 
  def __eq__(self, other):
7898 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
7899 
 
7900 
  def __ne__(self, other):
7901 
    return not (self == other)
7902 
 
1398 varun.gupt 7903 
class enqueueTransactionInfoEmail_args:
1382 varun.gupt 7904 
  """
7905 
  Attributes:
7906 
   - transactionId
7907 
  """
7908 
 
7909 
  thrift_spec = (
7910 
    None, # 0
7911 
    (1, TType.I64, 'transactionId', None, None, ), # 1
7912 
  )
7913 
 
7914 
  def __init__(self, transactionId=None,):
7915 
    self.transactionId = transactionId
7916 
 
7917 
  def read(self, iprot):
7918 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
7919 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
7920 
      return
7921 
    iprot.readStructBegin()
7922 
    while True:
7923 
      (fname, ftype, fid) = iprot.readFieldBegin()
7924 
      if ftype == TType.STOP:
7925 
        break
7926 
      if fid == 1:
7927 
        if ftype == TType.I64:
7928 
          self.transactionId = iprot.readI64();
7929 
        else:
7930 
          iprot.skip(ftype)
7931 
      else:
7932 
        iprot.skip(ftype)
7933 
      iprot.readFieldEnd()
7934 
    iprot.readStructEnd()
7935 
 
7936 
  def write(self, oprot):
7937 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
7938 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
7939 
      return
1398 varun.gupt 7940 
    oprot.writeStructBegin('enqueueTransactionInfoEmail_args')
3431 rajveer 7941 
    if self.transactionId is not None:
1382 varun.gupt 7942 
      oprot.writeFieldBegin('transactionId', TType.I64, 1)
7943 
      oprot.writeI64(self.transactionId)
7944 
      oprot.writeFieldEnd()
7945 
    oprot.writeFieldStop()
7946 
    oprot.writeStructEnd()
7947 
 
3431 rajveer 7948 
  def validate(self):
7949 
    return
7950 
 
7951 
 
1382 varun.gupt 7952 
  def __repr__(self):
7953 
    L = ['%s=%r' % (key, value)
7954 
      for key, value in self.__dict__.iteritems()]
7955 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
7956 
 
7957 
  def __eq__(self, other):
7958 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
7959 
 
7960 
  def __ne__(self, other):
7961 
    return not (self == other)
7962 
 
1398 varun.gupt 7963 
class enqueueTransactionInfoEmail_result:
1382 varun.gupt 7964 
  """
7965 
  Attributes:
7966 
   - success
7967 
   - ex
7968 
  """
7969 
 
7970 
  thrift_spec = (
7971 
    (0, TType.BOOL, 'success', None, None, ), # 0
7972 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
7973 
  )
7974 
 
7975 
  def __init__(self, success=None, ex=None,):
7976 
    self.success = success
7977 
    self.ex = ex
7978 
 
7979 
  def read(self, iprot):
7980 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
7981 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
7982 
      return
7983 
    iprot.readStructBegin()
7984 
    while True:
7985 
      (fname, ftype, fid) = iprot.readFieldBegin()
7986 
      if ftype == TType.STOP:
7987 
        break
7988 
      if fid == 0:
7989 
        if ftype == TType.BOOL:
7990 
          self.success = iprot.readBool();
7991 
        else:
7992 
          iprot.skip(ftype)
7993 
      elif fid == 1:
7994 
        if ftype == TType.STRUCT:
7995 
          self.ex = TransactionServiceException()
7996 
          self.ex.read(iprot)
7997 
        else:
7998 
          iprot.skip(ftype)
7999 
      else:
8000 
        iprot.skip(ftype)
8001 
      iprot.readFieldEnd()
8002 
    iprot.readStructEnd()
8003 
 
8004 
  def write(self, oprot):
8005 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8006 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8007 
      return
1398 varun.gupt 8008 
    oprot.writeStructBegin('enqueueTransactionInfoEmail_result')
3431 rajveer 8009 
    if self.success is not None:
1382 varun.gupt 8010 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
8011 
      oprot.writeBool(self.success)
8012 
      oprot.writeFieldEnd()
3431 rajveer 8013 
    if self.ex is not None:
1382 varun.gupt 8014 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
8015 
      self.ex.write(oprot)
8016 
      oprot.writeFieldEnd()
8017 
    oprot.writeFieldStop()
8018 
    oprot.writeStructEnd()
8019 
 
3431 rajveer 8020 
  def validate(self):
8021 
    return
8022 
 
8023 
 
1382 varun.gupt 8024 
  def __repr__(self):
8025 
    L = ['%s=%r' % (key, value)
8026 
      for key, value in self.__dict__.iteritems()]
8027 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8028 
 
8029 
  def __eq__(self, other):
8030 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8031 
 
8032 
  def __ne__(self, other):
8033 
    return not (self == other)
8034 
 
483 rajveer 8035 
class getAllOrders_args:
94 ashish 8036 
  """
8037 
  Attributes:
4801 anupam.sin 8038 
   - statuses
483 rajveer 8039 
   - from_date
8040 
   - to_date
8041 
   - warehouse_id
94 ashish 8042 
  """
8043 
 
8044 
  thrift_spec = (
8045 
    None, # 0
4801 anupam.sin 8046 
    (1, TType.LIST, 'statuses', (TType.I32,None), None, ), # 1
483 rajveer 8047 
    (2, TType.I64, 'from_date', None, None, ), # 2
8048 
    (3, TType.I64, 'to_date', None, None, ), # 3
8049 
    (4, TType.I64, 'warehouse_id', None, None, ), # 4
94 ashish 8050 
  )
8051 
 
4801 anupam.sin 8052 
  def __init__(self, statuses=None, from_date=None, to_date=None, warehouse_id=None,):
8053 
    self.statuses = statuses
483 rajveer 8054 
    self.from_date = from_date
8055 
    self.to_date = to_date
8056 
    self.warehouse_id = warehouse_id
94 ashish 8057 
 
8058 
  def read(self, iprot):
8059 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8060 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8061 
      return
8062 
    iprot.readStructBegin()
8063 
    while True:
8064 
      (fname, ftype, fid) = iprot.readFieldBegin()
8065 
      if ftype == TType.STOP:
8066 
        break
8067 
      if fid == 1:
4801 anupam.sin 8068 
        if ftype == TType.LIST:
8069 
          self.statuses = []
5031 varun.gupt 8070 
          (_etype80, _size77) = iprot.readListBegin()
8071 
          for _i81 in xrange(_size77):
8072 
            _elem82 = iprot.readI32();
8073 
            self.statuses.append(_elem82)
4801 anupam.sin 8074 
          iprot.readListEnd()
94 ashish 8075 
        else:
8076 
          iprot.skip(ftype)
483 rajveer 8077 
      elif fid == 2:
8078 
        if ftype == TType.I64:
8079 
          self.from_date = iprot.readI64();
94 ashish 8080 
        else:
8081 
          iprot.skip(ftype)
483 rajveer 8082 
      elif fid == 3:
8083 
        if ftype == TType.I64:
8084 
          self.to_date = iprot.readI64();
94 ashish 8085 
        else:
8086 
          iprot.skip(ftype)
483 rajveer 8087 
      elif fid == 4:
94 ashish 8088 
        if ftype == TType.I64:
483 rajveer 8089 
          self.warehouse_id = iprot.readI64();
94 ashish 8090 
        else:
8091 
          iprot.skip(ftype)
8092 
      else:
8093 
        iprot.skip(ftype)
8094 
      iprot.readFieldEnd()
8095 
    iprot.readStructEnd()
8096 
 
8097 
  def write(self, oprot):
8098 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8099 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8100 
      return
483 rajveer 8101 
    oprot.writeStructBegin('getAllOrders_args')
4801 anupam.sin 8102 
    if self.statuses is not None:
8103 
      oprot.writeFieldBegin('statuses', TType.LIST, 1)
8104 
      oprot.writeListBegin(TType.I32, len(self.statuses))
5031 varun.gupt 8105 
      for iter83 in self.statuses:
8106 
        oprot.writeI32(iter83)
4801 anupam.sin 8107 
      oprot.writeListEnd()
94 ashish 8108 
      oprot.writeFieldEnd()
3431 rajveer 8109 
    if self.from_date is not None:
483 rajveer 8110 
      oprot.writeFieldBegin('from_date', TType.I64, 2)
8111 
      oprot.writeI64(self.from_date)
94 ashish 8112 
      oprot.writeFieldEnd()
3431 rajveer 8113 
    if self.to_date is not None:
483 rajveer 8114 
      oprot.writeFieldBegin('to_date', TType.I64, 3)
8115 
      oprot.writeI64(self.to_date)
94 ashish 8116 
      oprot.writeFieldEnd()
3431 rajveer 8117 
    if self.warehouse_id is not None:
483 rajveer 8118 
      oprot.writeFieldBegin('warehouse_id', TType.I64, 4)
8119 
      oprot.writeI64(self.warehouse_id)
94 ashish 8120 
      oprot.writeFieldEnd()
8121 
    oprot.writeFieldStop()
8122 
    oprot.writeStructEnd()
8123 
 
3431 rajveer 8124 
  def validate(self):
8125 
    return
8126 
 
8127 
 
94 ashish 8128 
  def __repr__(self):
8129 
    L = ['%s=%r' % (key, value)
8130 
      for key, value in self.__dict__.iteritems()]
8131 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8132 
 
8133 
  def __eq__(self, other):
8134 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8135 
 
8136 
  def __ne__(self, other):
8137 
    return not (self == other)
8138 
 
483 rajveer 8139 
class getAllOrders_result:
94 ashish 8140 
  """
8141 
  Attributes:
8142 
   - success
8143 
   - ex
8144 
  """
8145 
 
8146 
  thrift_spec = (
483 rajveer 8147 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
94 ashish 8148 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
8149 
  )
8150 
 
8151 
  def __init__(self, success=None, ex=None,):
8152 
    self.success = success
8153 
    self.ex = ex
8154 
 
8155 
  def read(self, iprot):
8156 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8157 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8158 
      return
8159 
    iprot.readStructBegin()
8160 
    while True:
8161 
      (fname, ftype, fid) = iprot.readFieldBegin()
8162 
      if ftype == TType.STOP:
8163 
        break
8164 
      if fid == 0:
483 rajveer 8165 
        if ftype == TType.LIST:
8166 
          self.success = []
5031 varun.gupt 8167 
          (_etype87, _size84) = iprot.readListBegin()
8168 
          for _i88 in xrange(_size84):
8169 
            _elem89 = Order()
8170 
            _elem89.read(iprot)
8171 
            self.success.append(_elem89)
483 rajveer 8172 
          iprot.readListEnd()
94 ashish 8173 
        else:
8174 
          iprot.skip(ftype)
8175 
      elif fid == 1:
8176 
        if ftype == TType.STRUCT:
8177 
          self.ex = TransactionServiceException()
8178 
          self.ex.read(iprot)
8179 
        else:
8180 
          iprot.skip(ftype)
8181 
      else:
8182 
        iprot.skip(ftype)
8183 
      iprot.readFieldEnd()
8184 
    iprot.readStructEnd()
8185 
 
8186 
  def write(self, oprot):
8187 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8188 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8189 
      return
483 rajveer 8190 
    oprot.writeStructBegin('getAllOrders_result')
3431 rajveer 8191 
    if self.success is not None:
483 rajveer 8192 
      oprot.writeFieldBegin('success', TType.LIST, 0)
8193 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
5031 varun.gupt 8194 
      for iter90 in self.success:
8195 
        iter90.write(oprot)
483 rajveer 8196 
      oprot.writeListEnd()
94 ashish 8197 
      oprot.writeFieldEnd()
3431 rajveer 8198 
    if self.ex is not None:
94 ashish 8199 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
8200 
      self.ex.write(oprot)
8201 
      oprot.writeFieldEnd()
8202 
    oprot.writeFieldStop()
8203 
    oprot.writeStructEnd()
8204 
 
3431 rajveer 8205 
  def validate(self):
8206 
    return
8207 
 
8208 
 
94 ashish 8209 
  def __repr__(self):
8210 
    L = ['%s=%r' % (key, value)
8211 
      for key, value in self.__dict__.iteritems()]
8212 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8213 
 
8214 
  def __eq__(self, other):
8215 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8216 
 
8217 
  def __ne__(self, other):
8218 
    return not (self == other)
8219 
 
4133 chandransh 8220 
class getOrdersInBatch_args:
8221 
  """
8222 
  Attributes:
8223 
   - statuses
8224 
   - offset
8225 
   - limit
8226 
   - warehouse_id
8227 
  """
8228 
 
8229 
  thrift_spec = (
8230 
    None, # 0
8231 
    (1, TType.LIST, 'statuses', (TType.I32,None), None, ), # 1
8232 
    (2, TType.I64, 'offset', None, None, ), # 2
8233 
    (3, TType.I64, 'limit', None, None, ), # 3
8234 
    (4, TType.I64, 'warehouse_id', None, None, ), # 4
8235 
  )
8236 
 
8237 
  def __init__(self, statuses=None, offset=None, limit=None, warehouse_id=None,):
8238 
    self.statuses = statuses
8239 
    self.offset = offset
8240 
    self.limit = limit
8241 
    self.warehouse_id = warehouse_id
8242 
 
8243 
  def read(self, iprot):
8244 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8245 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8246 
      return
8247 
    iprot.readStructBegin()
8248 
    while True:
8249 
      (fname, ftype, fid) = iprot.readFieldBegin()
8250 
      if ftype == TType.STOP:
8251 
        break
8252 
      if fid == 1:
8253 
        if ftype == TType.LIST:
8254 
          self.statuses = []
5031 varun.gupt 8255 
          (_etype94, _size91) = iprot.readListBegin()
8256 
          for _i95 in xrange(_size91):
8257 
            _elem96 = iprot.readI32();
8258 
            self.statuses.append(_elem96)
4133 chandransh 8259 
          iprot.readListEnd()
8260 
        else:
8261 
          iprot.skip(ftype)
8262 
      elif fid == 2:
8263 
        if ftype == TType.I64:
8264 
          self.offset = iprot.readI64();
8265 
        else:
8266 
          iprot.skip(ftype)
8267 
      elif fid == 3:
8268 
        if ftype == TType.I64:
8269 
          self.limit = iprot.readI64();
8270 
        else:
8271 
          iprot.skip(ftype)
8272 
      elif fid == 4:
8273 
        if ftype == TType.I64:
8274 
          self.warehouse_id = iprot.readI64();
8275 
        else:
8276 
          iprot.skip(ftype)
8277 
      else:
8278 
        iprot.skip(ftype)
8279 
      iprot.readFieldEnd()
8280 
    iprot.readStructEnd()
8281 
 
8282 
  def write(self, oprot):
8283 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8284 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8285 
      return
8286 
    oprot.writeStructBegin('getOrdersInBatch_args')
8287 
    if self.statuses is not None:
8288 
      oprot.writeFieldBegin('statuses', TType.LIST, 1)
8289 
      oprot.writeListBegin(TType.I32, len(self.statuses))
5031 varun.gupt 8290 
      for iter97 in self.statuses:
8291 
        oprot.writeI32(iter97)
4133 chandransh 8292 
      oprot.writeListEnd()
8293 
      oprot.writeFieldEnd()
8294 
    if self.offset is not None:
8295 
      oprot.writeFieldBegin('offset', TType.I64, 2)
8296 
      oprot.writeI64(self.offset)
8297 
      oprot.writeFieldEnd()
8298 
    if self.limit is not None:
8299 
      oprot.writeFieldBegin('limit', TType.I64, 3)
8300 
      oprot.writeI64(self.limit)
8301 
      oprot.writeFieldEnd()
8302 
    if self.warehouse_id is not None:
8303 
      oprot.writeFieldBegin('warehouse_id', TType.I64, 4)
8304 
      oprot.writeI64(self.warehouse_id)
8305 
      oprot.writeFieldEnd()
8306 
    oprot.writeFieldStop()
8307 
    oprot.writeStructEnd()
8308 
 
8309 
  def validate(self):
8310 
    return
8311 
 
8312 
 
8313 
  def __repr__(self):
8314 
    L = ['%s=%r' % (key, value)
8315 
      for key, value in self.__dict__.iteritems()]
8316 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8317 
 
8318 
  def __eq__(self, other):
8319 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8320 
 
8321 
  def __ne__(self, other):
8322 
    return not (self == other)
8323 
 
8324 
class getOrdersInBatch_result:
8325 
  """
8326 
  Attributes:
8327 
   - success
8328 
   - ex
8329 
  """
8330 
 
8331 
  thrift_spec = (
8332 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
8333 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
8334 
  )
8335 
 
8336 
  def __init__(self, success=None, ex=None,):
8337 
    self.success = success
8338 
    self.ex = ex
8339 
 
8340 
  def read(self, iprot):
8341 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8342 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8343 
      return
8344 
    iprot.readStructBegin()
8345 
    while True:
8346 
      (fname, ftype, fid) = iprot.readFieldBegin()
8347 
      if ftype == TType.STOP:
8348 
        break
8349 
      if fid == 0:
8350 
        if ftype == TType.LIST:
8351 
          self.success = []
5031 varun.gupt 8352 
          (_etype101, _size98) = iprot.readListBegin()
8353 
          for _i102 in xrange(_size98):
8354 
            _elem103 = Order()
8355 
            _elem103.read(iprot)
8356 
            self.success.append(_elem103)
4133 chandransh 8357 
          iprot.readListEnd()
8358 
        else:
8359 
          iprot.skip(ftype)
8360 
      elif fid == 1:
8361 
        if ftype == TType.STRUCT:
8362 
          self.ex = TransactionServiceException()
8363 
          self.ex.read(iprot)
8364 
        else:
8365 
          iprot.skip(ftype)
8366 
      else:
8367 
        iprot.skip(ftype)
8368 
      iprot.readFieldEnd()
8369 
    iprot.readStructEnd()
8370 
 
8371 
  def write(self, oprot):
8372 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8373 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8374 
      return
8375 
    oprot.writeStructBegin('getOrdersInBatch_result')
8376 
    if self.success is not None:
8377 
      oprot.writeFieldBegin('success', TType.LIST, 0)
8378 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
5031 varun.gupt 8379 
      for iter104 in self.success:
8380 
        iter104.write(oprot)
4133 chandransh 8381 
      oprot.writeListEnd()
8382 
      oprot.writeFieldEnd()
8383 
    if self.ex is not None:
8384 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
8385 
      self.ex.write(oprot)
8386 
      oprot.writeFieldEnd()
8387 
    oprot.writeFieldStop()
8388 
    oprot.writeStructEnd()
8389 
 
8390 
  def validate(self):
8391 
    return
8392 
 
8393 
 
8394 
  def __repr__(self):
8395 
    L = ['%s=%r' % (key, value)
8396 
      for key, value in self.__dict__.iteritems()]
8397 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8398 
 
8399 
  def __eq__(self, other):
8400 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8401 
 
8402 
  def __ne__(self, other):
8403 
    return not (self == other)
8404 
 
8405 
class getOrderCount_args:
8406 
  """
8407 
  Attributes:
8408 
   - statuses
8409 
   - warehouseId
8410 
  """
8411 
 
8412 
  thrift_spec = (
8413 
    None, # 0
8414 
    (1, TType.LIST, 'statuses', (TType.I32,None), None, ), # 1
8415 
    (2, TType.I64, 'warehouseId', None, None, ), # 2
8416 
  )
8417 
 
8418 
  def __init__(self, statuses=None, warehouseId=None,):
8419 
    self.statuses = statuses
8420 
    self.warehouseId = warehouseId
8421 
 
8422 
  def read(self, iprot):
8423 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8424 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8425 
      return
8426 
    iprot.readStructBegin()
8427 
    while True:
8428 
      (fname, ftype, fid) = iprot.readFieldBegin()
8429 
      if ftype == TType.STOP:
8430 
        break
8431 
      if fid == 1:
8432 
        if ftype == TType.LIST:
8433 
          self.statuses = []
5031 varun.gupt 8434 
          (_etype108, _size105) = iprot.readListBegin()
8435 
          for _i109 in xrange(_size105):
8436 
            _elem110 = iprot.readI32();
8437 
            self.statuses.append(_elem110)
4133 chandransh 8438 
          iprot.readListEnd()
8439 
        else:
8440 
          iprot.skip(ftype)
8441 
      elif fid == 2:
8442 
        if ftype == TType.I64:
8443 
          self.warehouseId = iprot.readI64();
8444 
        else:
8445 
          iprot.skip(ftype)
8446 
      else:
8447 
        iprot.skip(ftype)
8448 
      iprot.readFieldEnd()
8449 
    iprot.readStructEnd()
8450 
 
8451 
  def write(self, oprot):
8452 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8453 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8454 
      return
8455 
    oprot.writeStructBegin('getOrderCount_args')
8456 
    if self.statuses is not None:
8457 
      oprot.writeFieldBegin('statuses', TType.LIST, 1)
8458 
      oprot.writeListBegin(TType.I32, len(self.statuses))
5031 varun.gupt 8459 
      for iter111 in self.statuses:
8460 
        oprot.writeI32(iter111)
4133 chandransh 8461 
      oprot.writeListEnd()
8462 
      oprot.writeFieldEnd()
8463 
    if self.warehouseId is not None:
8464 
      oprot.writeFieldBegin('warehouseId', TType.I64, 2)
8465 
      oprot.writeI64(self.warehouseId)
8466 
      oprot.writeFieldEnd()
8467 
    oprot.writeFieldStop()
8468 
    oprot.writeStructEnd()
8469 
 
8470 
  def validate(self):
8471 
    return
8472 
 
8473 
 
8474 
  def __repr__(self):
8475 
    L = ['%s=%r' % (key, value)
8476 
      for key, value in self.__dict__.iteritems()]
8477 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8478 
 
8479 
  def __eq__(self, other):
8480 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8481 
 
8482 
  def __ne__(self, other):
8483 
    return not (self == other)
8484 
 
8485 
class getOrderCount_result:
8486 
  """
8487 
  Attributes:
8488 
   - success
8489 
   - ex
8490 
  """
8491 
 
8492 
  thrift_spec = (
8493 
    (0, TType.I32, 'success', None, None, ), # 0
8494 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
8495 
  )
8496 
 
8497 
  def __init__(self, success=None, ex=None,):
8498 
    self.success = success
8499 
    self.ex = ex
8500 
 
8501 
  def read(self, iprot):
8502 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8503 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8504 
      return
8505 
    iprot.readStructBegin()
8506 
    while True:
8507 
      (fname, ftype, fid) = iprot.readFieldBegin()
8508 
      if ftype == TType.STOP:
8509 
        break
8510 
      if fid == 0:
8511 
        if ftype == TType.I32:
8512 
          self.success = iprot.readI32();
8513 
        else:
8514 
          iprot.skip(ftype)
8515 
      elif fid == 1:
8516 
        if ftype == TType.STRUCT:
8517 
          self.ex = TransactionServiceException()
8518 
          self.ex.read(iprot)
8519 
        else:
8520 
          iprot.skip(ftype)
8521 
      else:
8522 
        iprot.skip(ftype)
8523 
      iprot.readFieldEnd()
8524 
    iprot.readStructEnd()
8525 
 
8526 
  def write(self, oprot):
8527 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8528 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8529 
      return
8530 
    oprot.writeStructBegin('getOrderCount_result')
8531 
    if self.success is not None:
8532 
      oprot.writeFieldBegin('success', TType.I32, 0)
8533 
      oprot.writeI32(self.success)
8534 
      oprot.writeFieldEnd()
8535 
    if self.ex is not None:
8536 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
8537 
      self.ex.write(oprot)
8538 
      oprot.writeFieldEnd()
8539 
    oprot.writeFieldStop()
8540 
    oprot.writeStructEnd()
8541 
 
8542 
  def validate(self):
8543 
    return
8544 
 
8545 
 
8546 
  def __repr__(self):
8547 
    L = ['%s=%r' % (key, value)
8548 
      for key, value in self.__dict__.iteritems()]
8549 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8550 
 
8551 
  def __eq__(self, other):
8552 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8553 
 
8554 
  def __ne__(self, other):
8555 
    return not (self == other)
8556 
 
999 varun.gupt 8557 
class getOrdersByBillingDate_args:
8558 
  """
8559 
  Attributes:
8560 
   - status
8561 
   - start_billing_date
8562 
   - end_billing_date
8563 
   - warehouse_id
8564 
  """
8565 
 
8566 
  thrift_spec = (
8567 
    None, # 0
8568 
    (1, TType.I32, 'status', None, None, ), # 1
8569 
    (2, TType.I64, 'start_billing_date', None, None, ), # 2
8570 
    (3, TType.I64, 'end_billing_date', None, None, ), # 3
8571 
    (4, TType.I64, 'warehouse_id', None, None, ), # 4
8572 
  )
8573 
 
8574 
  def __init__(self, status=None, start_billing_date=None, end_billing_date=None, warehouse_id=None,):
8575 
    self.status = status
8576 
    self.start_billing_date = start_billing_date
8577 
    self.end_billing_date = end_billing_date
8578 
    self.warehouse_id = warehouse_id
8579 
 
8580 
  def read(self, iprot):
8581 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8582 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8583 
      return
8584 
    iprot.readStructBegin()
8585 
    while True:
8586 
      (fname, ftype, fid) = iprot.readFieldBegin()
8587 
      if ftype == TType.STOP:
8588 
        break
8589 
      if fid == 1:
8590 
        if ftype == TType.I32:
8591 
          self.status = iprot.readI32();
8592 
        else:
8593 
          iprot.skip(ftype)
8594 
      elif fid == 2:
8595 
        if ftype == TType.I64:
8596 
          self.start_billing_date = iprot.readI64();
8597 
        else:
8598 
          iprot.skip(ftype)
8599 
      elif fid == 3:
8600 
        if ftype == TType.I64:
8601 
          self.end_billing_date = iprot.readI64();
8602 
        else:
8603 
          iprot.skip(ftype)
8604 
      elif fid == 4:
8605 
        if ftype == TType.I64:
8606 
          self.warehouse_id = iprot.readI64();
8607 
        else:
8608 
          iprot.skip(ftype)
8609 
      else:
8610 
        iprot.skip(ftype)
8611 
      iprot.readFieldEnd()
8612 
    iprot.readStructEnd()
8613 
 
8614 
  def write(self, oprot):
8615 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8616 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8617 
      return
8618 
    oprot.writeStructBegin('getOrdersByBillingDate_args')
3431 rajveer 8619 
    if self.status is not None:
999 varun.gupt 8620 
      oprot.writeFieldBegin('status', TType.I32, 1)
8621 
      oprot.writeI32(self.status)
8622 
      oprot.writeFieldEnd()
3431 rajveer 8623 
    if self.start_billing_date is not None:
999 varun.gupt 8624 
      oprot.writeFieldBegin('start_billing_date', TType.I64, 2)
8625 
      oprot.writeI64(self.start_billing_date)
8626 
      oprot.writeFieldEnd()
3431 rajveer 8627 
    if self.end_billing_date is not None:
999 varun.gupt 8628 
      oprot.writeFieldBegin('end_billing_date', TType.I64, 3)
8629 
      oprot.writeI64(self.end_billing_date)
8630 
      oprot.writeFieldEnd()
3431 rajveer 8631 
    if self.warehouse_id is not None:
999 varun.gupt 8632 
      oprot.writeFieldBegin('warehouse_id', TType.I64, 4)
8633 
      oprot.writeI64(self.warehouse_id)
8634 
      oprot.writeFieldEnd()
8635 
    oprot.writeFieldStop()
8636 
    oprot.writeStructEnd()
8637 
 
3431 rajveer 8638 
  def validate(self):
8639 
    return
8640 
 
8641 
 
999 varun.gupt 8642 
  def __repr__(self):
8643 
    L = ['%s=%r' % (key, value)
8644 
      for key, value in self.__dict__.iteritems()]
8645 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8646 
 
8647 
  def __eq__(self, other):
8648 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8649 
 
8650 
  def __ne__(self, other):
8651 
    return not (self == other)
8652 
 
8653 
class getOrdersByBillingDate_result:
8654 
  """
8655 
  Attributes:
8656 
   - success
8657 
   - ex
8658 
  """
8659 
 
8660 
  thrift_spec = (
8661 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
8662 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
8663 
  )
8664 
 
8665 
  def __init__(self, success=None, ex=None,):
8666 
    self.success = success
8667 
    self.ex = ex
8668 
 
8669 
  def read(self, iprot):
8670 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8671 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8672 
      return
8673 
    iprot.readStructBegin()
8674 
    while True:
8675 
      (fname, ftype, fid) = iprot.readFieldBegin()
8676 
      if ftype == TType.STOP:
8677 
        break
8678 
      if fid == 0:
8679 
        if ftype == TType.LIST:
8680 
          self.success = []
5031 varun.gupt 8681 
          (_etype115, _size112) = iprot.readListBegin()
8682 
          for _i116 in xrange(_size112):
8683 
            _elem117 = Order()
8684 
            _elem117.read(iprot)
8685 
            self.success.append(_elem117)
999 varun.gupt 8686 
          iprot.readListEnd()
8687 
        else:
8688 
          iprot.skip(ftype)
8689 
      elif fid == 1:
8690 
        if ftype == TType.STRUCT:
8691 
          self.ex = TransactionServiceException()
8692 
          self.ex.read(iprot)
8693 
        else:
8694 
          iprot.skip(ftype)
8695 
      else:
8696 
        iprot.skip(ftype)
8697 
      iprot.readFieldEnd()
8698 
    iprot.readStructEnd()
8699 
 
8700 
  def write(self, oprot):
8701 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8702 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8703 
      return
8704 
    oprot.writeStructBegin('getOrdersByBillingDate_result')
3431 rajveer 8705 
    if self.success is not None:
999 varun.gupt 8706 
      oprot.writeFieldBegin('success', TType.LIST, 0)
8707 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
5031 varun.gupt 8708 
      for iter118 in self.success:
8709 
        iter118.write(oprot)
999 varun.gupt 8710 
      oprot.writeListEnd()
8711 
      oprot.writeFieldEnd()
3431 rajveer 8712 
    if self.ex is not None:
999 varun.gupt 8713 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
8714 
      self.ex.write(oprot)
8715 
      oprot.writeFieldEnd()
8716 
    oprot.writeFieldStop()
8717 
    oprot.writeStructEnd()
8718 
 
3431 rajveer 8719 
  def validate(self):
8720 
    return
8721 
 
8722 
 
999 varun.gupt 8723 
  def __repr__(self):
8724 
    L = ['%s=%r' % (key, value)
8725 
      for key, value in self.__dict__.iteritems()]
8726 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8727 
 
8728 
  def __eq__(self, other):
8729 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8730 
 
8731 
  def __ne__(self, other):
8732 
    return not (self == other)
8733 
 
3427 chandransh 8734 
class getOrdersByShippingDate_args:
8735 
  """
8736 
  Attributes:
8737 
   - fromShippingDate
8738 
   - toShippingDate
8739 
   - providerId
8740 
   - warehouseId
3451 chandransh 8741 
   - cod
3427 chandransh 8742 
  """
8743 
 
8744 
  thrift_spec = (
8745 
    None, # 0
8746 
    (1, TType.I64, 'fromShippingDate', None, None, ), # 1
8747 
    (2, TType.I64, 'toShippingDate', None, None, ), # 2
8748 
    (3, TType.I64, 'providerId', None, None, ), # 3
8749 
    (4, TType.I64, 'warehouseId', None, None, ), # 4
3451 chandransh 8750 
    (5, TType.BOOL, 'cod', None, None, ), # 5
3427 chandransh 8751 
  )
8752 
 
3451 chandransh 8753 
  def __init__(self, fromShippingDate=None, toShippingDate=None, providerId=None, warehouseId=None, cod=None,):
3427 chandransh 8754 
    self.fromShippingDate = fromShippingDate
8755 
    self.toShippingDate = toShippingDate
8756 
    self.providerId = providerId
8757 
    self.warehouseId = warehouseId
3451 chandransh 8758 
    self.cod = cod
3427 chandransh 8759 
 
8760 
  def read(self, iprot):
8761 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8762 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8763 
      return
8764 
    iprot.readStructBegin()
8765 
    while True:
8766 
      (fname, ftype, fid) = iprot.readFieldBegin()
8767 
      if ftype == TType.STOP:
8768 
        break
8769 
      if fid == 1:
8770 
        if ftype == TType.I64:
8771 
          self.fromShippingDate = iprot.readI64();
8772 
        else:
8773 
          iprot.skip(ftype)
8774 
      elif fid == 2:
8775 
        if ftype == TType.I64:
8776 
          self.toShippingDate = iprot.readI64();
8777 
        else:
8778 
          iprot.skip(ftype)
8779 
      elif fid == 3:
8780 
        if ftype == TType.I64:
8781 
          self.providerId = iprot.readI64();
8782 
        else:
8783 
          iprot.skip(ftype)
8784 
      elif fid == 4:
8785 
        if ftype == TType.I64:
8786 
          self.warehouseId = iprot.readI64();
8787 
        else:
8788 
          iprot.skip(ftype)
3451 chandransh 8789 
      elif fid == 5:
8790 
        if ftype == TType.BOOL:
8791 
          self.cod = iprot.readBool();
8792 
        else:
8793 
          iprot.skip(ftype)
3427 chandransh 8794 
      else:
8795 
        iprot.skip(ftype)
8796 
      iprot.readFieldEnd()
8797 
    iprot.readStructEnd()
8798 
 
8799 
  def write(self, oprot):
8800 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8801 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8802 
      return
8803 
    oprot.writeStructBegin('getOrdersByShippingDate_args')
3431 rajveer 8804 
    if self.fromShippingDate is not None:
3427 chandransh 8805 
      oprot.writeFieldBegin('fromShippingDate', TType.I64, 1)
8806 
      oprot.writeI64(self.fromShippingDate)
8807 
      oprot.writeFieldEnd()
3431 rajveer 8808 
    if self.toShippingDate is not None:
3427 chandransh 8809 
      oprot.writeFieldBegin('toShippingDate', TType.I64, 2)
8810 
      oprot.writeI64(self.toShippingDate)
8811 
      oprot.writeFieldEnd()
3431 rajveer 8812 
    if self.providerId is not None:
3427 chandransh 8813 
      oprot.writeFieldBegin('providerId', TType.I64, 3)
8814 
      oprot.writeI64(self.providerId)
8815 
      oprot.writeFieldEnd()
3431 rajveer 8816 
    if self.warehouseId is not None:
3427 chandransh 8817 
      oprot.writeFieldBegin('warehouseId', TType.I64, 4)
8818 
      oprot.writeI64(self.warehouseId)
8819 
      oprot.writeFieldEnd()
3451 chandransh 8820 
    if self.cod is not None:
8821 
      oprot.writeFieldBegin('cod', TType.BOOL, 5)
8822 
      oprot.writeBool(self.cod)
8823 
      oprot.writeFieldEnd()
3427 chandransh 8824 
    oprot.writeFieldStop()
8825 
    oprot.writeStructEnd()
8826 
 
3431 rajveer 8827 
  def validate(self):
8828 
    return
8829 
 
8830 
 
3427 chandransh 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 
 
8842 
class getOrdersByShippingDate_result:
8843 
  """
8844 
  Attributes:
8845 
   - success
8846 
   - ex
8847 
  """
8848 
 
8849 
  thrift_spec = (
8850 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
8851 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
8852 
  )
8853 
 
8854 
  def __init__(self, success=None, ex=None,):
8855 
    self.success = success
8856 
    self.ex = ex
8857 
 
8858 
  def read(self, iprot):
8859 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8860 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8861 
      return
8862 
    iprot.readStructBegin()
8863 
    while True:
8864 
      (fname, ftype, fid) = iprot.readFieldBegin()
8865 
      if ftype == TType.STOP:
8866 
        break
8867 
      if fid == 0:
8868 
        if ftype == TType.LIST:
8869 
          self.success = []
5031 varun.gupt 8870 
          (_etype122, _size119) = iprot.readListBegin()
8871 
          for _i123 in xrange(_size119):
8872 
            _elem124 = Order()
8873 
            _elem124.read(iprot)
8874 
            self.success.append(_elem124)
3427 chandransh 8875 
          iprot.readListEnd()
8876 
        else:
8877 
          iprot.skip(ftype)
8878 
      elif fid == 1:
8879 
        if ftype == TType.STRUCT:
8880 
          self.ex = TransactionServiceException()
8881 
          self.ex.read(iprot)
8882 
        else:
8883 
          iprot.skip(ftype)
8884 
      else:
8885 
        iprot.skip(ftype)
8886 
      iprot.readFieldEnd()
8887 
    iprot.readStructEnd()
8888 
 
8889 
  def write(self, oprot):
8890 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8891 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8892 
      return
8893 
    oprot.writeStructBegin('getOrdersByShippingDate_result')
3431 rajveer 8894 
    if self.success is not None:
3427 chandransh 8895 
      oprot.writeFieldBegin('success', TType.LIST, 0)
8896 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
5031 varun.gupt 8897 
      for iter125 in self.success:
8898 
        iter125.write(oprot)
3427 chandransh 8899 
      oprot.writeListEnd()
8900 
      oprot.writeFieldEnd()
3431 rajveer 8901 
    if self.ex is not None:
3427 chandransh 8902 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
8903 
      self.ex.write(oprot)
8904 
      oprot.writeFieldEnd()
8905 
    oprot.writeFieldStop()
8906 
    oprot.writeStructEnd()
8907 
 
3431 rajveer 8908 
  def validate(self):
8909 
    return
8910 
 
8911 
 
3427 chandransh 8912 
  def __repr__(self):
8913 
    L = ['%s=%r' % (key, value)
8914 
      for key, value in self.__dict__.iteritems()]
8915 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8916 
 
8917 
  def __eq__(self, other):
8918 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8919 
 
8920 
  def __ne__(self, other):
8921 
    return not (self == other)
8922 
 
1382 varun.gupt 8923 
class getReturnableOrdersForCustomer_args:
8924 
  """
8925 
  Attributes:
8926 
   - customer_id
8927 
   - limit
8928 
  """
8929 
 
8930 
  thrift_spec = (
8931 
    None, # 0
8932 
    (1, TType.I64, 'customer_id', None, None, ), # 1
8933 
    (2, TType.I64, 'limit', None, None, ), # 2
8934 
  )
8935 
 
8936 
  def __init__(self, customer_id=None, limit=None,):
8937 
    self.customer_id = customer_id
8938 
    self.limit = limit
8939 
 
8940 
  def read(self, iprot):
8941 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8942 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8943 
      return
8944 
    iprot.readStructBegin()
8945 
    while True:
8946 
      (fname, ftype, fid) = iprot.readFieldBegin()
8947 
      if ftype == TType.STOP:
8948 
        break
8949 
      if fid == 1:
8950 
        if ftype == TType.I64:
8951 
          self.customer_id = iprot.readI64();
8952 
        else:
8953 
          iprot.skip(ftype)
8954 
      elif fid == 2:
8955 
        if ftype == TType.I64:
8956 
          self.limit = iprot.readI64();
8957 
        else:
8958 
          iprot.skip(ftype)
8959 
      else:
8960 
        iprot.skip(ftype)
8961 
      iprot.readFieldEnd()
8962 
    iprot.readStructEnd()
8963 
 
8964 
  def write(self, oprot):
8965 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8966 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8967 
      return
8968 
    oprot.writeStructBegin('getReturnableOrdersForCustomer_args')
3431 rajveer 8969 
    if self.customer_id is not None:
1382 varun.gupt 8970 
      oprot.writeFieldBegin('customer_id', TType.I64, 1)
8971 
      oprot.writeI64(self.customer_id)
8972 
      oprot.writeFieldEnd()
3431 rajveer 8973 
    if self.limit is not None:
1382 varun.gupt 8974 
      oprot.writeFieldBegin('limit', TType.I64, 2)
8975 
      oprot.writeI64(self.limit)
8976 
      oprot.writeFieldEnd()
8977 
    oprot.writeFieldStop()
8978 
    oprot.writeStructEnd()
8979 
 
3431 rajveer 8980 
  def validate(self):
8981 
    return
8982 
 
8983 
 
1382 varun.gupt 8984 
  def __repr__(self):
8985 
    L = ['%s=%r' % (key, value)
8986 
      for key, value in self.__dict__.iteritems()]
8987 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8988 
 
8989 
  def __eq__(self, other):
8990 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8991 
 
8992 
  def __ne__(self, other):
8993 
    return not (self == other)
8994 
 
8995 
class getReturnableOrdersForCustomer_result:
8996 
  """
8997 
  Attributes:
8998 
   - success
8999 
   - ex
9000 
  """
9001 
 
9002 
  thrift_spec = (
9003 
    (0, TType.LIST, 'success', (TType.I64,None), None, ), # 0
9004 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
9005 
  )
9006 
 
9007 
  def __init__(self, success=None, ex=None,):
9008 
    self.success = success
9009 
    self.ex = ex
9010 
 
9011 
  def read(self, iprot):
9012 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9013 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9014 
      return
9015 
    iprot.readStructBegin()
9016 
    while True:
9017 
      (fname, ftype, fid) = iprot.readFieldBegin()
9018 
      if ftype == TType.STOP:
9019 
        break
9020 
      if fid == 0:
9021 
        if ftype == TType.LIST:
9022 
          self.success = []
5031 varun.gupt 9023 
          (_etype129, _size126) = iprot.readListBegin()
9024 
          for _i130 in xrange(_size126):
9025 
            _elem131 = iprot.readI64();
9026 
            self.success.append(_elem131)
1382 varun.gupt 9027 
          iprot.readListEnd()
9028 
        else:
9029 
          iprot.skip(ftype)
9030 
      elif fid == 1:
9031 
        if ftype == TType.STRUCT:
9032 
          self.ex = TransactionServiceException()
9033 
          self.ex.read(iprot)
9034 
        else:
9035 
          iprot.skip(ftype)
9036 
      else:
9037 
        iprot.skip(ftype)
9038 
      iprot.readFieldEnd()
9039 
    iprot.readStructEnd()
9040 
 
9041 
  def write(self, oprot):
9042 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9043 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9044 
      return
9045 
    oprot.writeStructBegin('getReturnableOrdersForCustomer_result')
3431 rajveer 9046 
    if self.success is not None:
1382 varun.gupt 9047 
      oprot.writeFieldBegin('success', TType.LIST, 0)
9048 
      oprot.writeListBegin(TType.I64, len(self.success))
5031 varun.gupt 9049 
      for iter132 in self.success:
9050 
        oprot.writeI64(iter132)
1382 varun.gupt 9051 
      oprot.writeListEnd()
9052 
      oprot.writeFieldEnd()
3431 rajveer 9053 
    if self.ex is not None:
1382 varun.gupt 9054 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
9055 
      self.ex.write(oprot)
9056 
      oprot.writeFieldEnd()
9057 
    oprot.writeFieldStop()
9058 
    oprot.writeStructEnd()
9059 
 
3431 rajveer 9060 
  def validate(self):
9061 
    return
9062 
 
9063 
 
1382 varun.gupt 9064 
  def __repr__(self):
9065 
    L = ['%s=%r' % (key, value)
9066 
      for key, value in self.__dict__.iteritems()]
9067 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9068 
 
9069 
  def __eq__(self, other):
9070 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9071 
 
9072 
  def __ne__(self, other):
9073 
    return not (self == other)
9074 
 
9075 
class getCancellableOrdersForCustomer_args:
9076 
  """
9077 
  Attributes:
9078 
   - customer_id
9079 
   - limit
9080 
  """
9081 
 
9082 
  thrift_spec = (
9083 
    None, # 0
9084 
    (1, TType.I64, 'customer_id', None, None, ), # 1
9085 
    (2, TType.I64, 'limit', None, None, ), # 2
9086 
  )
9087 
 
9088 
  def __init__(self, customer_id=None, limit=None,):
9089 
    self.customer_id = customer_id
9090 
    self.limit = limit
9091 
 
9092 
  def read(self, iprot):
9093 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9094 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9095 
      return
9096 
    iprot.readStructBegin()
9097 
    while True:
9098 
      (fname, ftype, fid) = iprot.readFieldBegin()
9099 
      if ftype == TType.STOP:
9100 
        break
9101 
      if fid == 1:
9102 
        if ftype == TType.I64:
9103 
          self.customer_id = iprot.readI64();
9104 
        else:
9105 
          iprot.skip(ftype)
9106 
      elif fid == 2:
9107 
        if ftype == TType.I64:
9108 
          self.limit = iprot.readI64();
9109 
        else:
9110 
          iprot.skip(ftype)
9111 
      else:
9112 
        iprot.skip(ftype)
9113 
      iprot.readFieldEnd()
9114 
    iprot.readStructEnd()
9115 
 
9116 
  def write(self, oprot):
9117 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9118 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9119 
      return
9120 
    oprot.writeStructBegin('getCancellableOrdersForCustomer_args')
3431 rajveer 9121 
    if self.customer_id is not None:
1382 varun.gupt 9122 
      oprot.writeFieldBegin('customer_id', TType.I64, 1)
9123 
      oprot.writeI64(self.customer_id)
9124 
      oprot.writeFieldEnd()
3431 rajveer 9125 
    if self.limit is not None:
1382 varun.gupt 9126 
      oprot.writeFieldBegin('limit', TType.I64, 2)
9127 
      oprot.writeI64(self.limit)
9128 
      oprot.writeFieldEnd()
9129 
    oprot.writeFieldStop()
9130 
    oprot.writeStructEnd()
9131 
 
3431 rajveer 9132 
  def validate(self):
9133 
    return
9134 
 
9135 
 
1382 varun.gupt 9136 
  def __repr__(self):
9137 
    L = ['%s=%r' % (key, value)
9138 
      for key, value in self.__dict__.iteritems()]
9139 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9140 
 
9141 
  def __eq__(self, other):
9142 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9143 
 
9144 
  def __ne__(self, other):
9145 
    return not (self == other)
9146 
 
9147 
class getCancellableOrdersForCustomer_result:
9148 
  """
9149 
  Attributes:
9150 
   - success
9151 
   - ex
9152 
  """
9153 
 
9154 
  thrift_spec = (
9155 
    (0, TType.LIST, 'success', (TType.I64,None), None, ), # 0
9156 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
9157 
  )
9158 
 
9159 
  def __init__(self, success=None, ex=None,):
9160 
    self.success = success
9161 
    self.ex = ex
9162 
 
9163 
  def read(self, iprot):
9164 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9165 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9166 
      return
9167 
    iprot.readStructBegin()
9168 
    while True:
9169 
      (fname, ftype, fid) = iprot.readFieldBegin()
9170 
      if ftype == TType.STOP:
9171 
        break
9172 
      if fid == 0:
9173 
        if ftype == TType.LIST:
9174 
          self.success = []
5031 varun.gupt 9175 
          (_etype136, _size133) = iprot.readListBegin()
9176 
          for _i137 in xrange(_size133):
9177 
            _elem138 = iprot.readI64();
9178 
            self.success.append(_elem138)
1382 varun.gupt 9179 
          iprot.readListEnd()
9180 
        else:
9181 
          iprot.skip(ftype)
9182 
      elif fid == 1:
9183 
        if ftype == TType.STRUCT:
9184 
          self.ex = TransactionServiceException()
9185 
          self.ex.read(iprot)
9186 
        else:
9187 
          iprot.skip(ftype)
9188 
      else:
9189 
        iprot.skip(ftype)
9190 
      iprot.readFieldEnd()
9191 
    iprot.readStructEnd()
9192 
 
9193 
  def write(self, oprot):
9194 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9195 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9196 
      return
9197 
    oprot.writeStructBegin('getCancellableOrdersForCustomer_result')
3431 rajveer 9198 
    if self.success is not None:
1382 varun.gupt 9199 
      oprot.writeFieldBegin('success', TType.LIST, 0)
9200 
      oprot.writeListBegin(TType.I64, len(self.success))
5031 varun.gupt 9201 
      for iter139 in self.success:
9202 
        oprot.writeI64(iter139)
1382 varun.gupt 9203 
      oprot.writeListEnd()
9204 
      oprot.writeFieldEnd()
3431 rajveer 9205 
    if self.ex is not None:
1382 varun.gupt 9206 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
9207 
      self.ex.write(oprot)
9208 
      oprot.writeFieldEnd()
9209 
    oprot.writeFieldStop()
9210 
    oprot.writeStructEnd()
9211 
 
3431 rajveer 9212 
  def validate(self):
9213 
    return
9214 
 
9215 
 
1382 varun.gupt 9216 
  def __repr__(self):
9217 
    L = ['%s=%r' % (key, value)
9218 
      for key, value in self.__dict__.iteritems()]
9219 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9220 
 
9221 
  def __eq__(self, other):
9222 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9223 
 
9224 
  def __ne__(self, other):
9225 
    return not (self == other)
9226 
 
483 rajveer 9227 
class changeOrderStatus_args:
94 ashish 9228 
  """
9229 
  Attributes:
483 rajveer 9230 
   - orderId
9231 
   - status
9232 
   - description
94 ashish 9233 
  """
9234 
 
9235 
  thrift_spec = (
9236 
    None, # 0
483 rajveer 9237 
    (1, TType.I64, 'orderId', None, None, ), # 1
9238 
    (2, TType.I32, 'status', None, None, ), # 2
9239 
    (3, TType.STRING, 'description', None, None, ), # 3
94 ashish 9240 
  )
9241 
 
483 rajveer 9242 
  def __init__(self, orderId=None, status=None, description=None,):
9243 
    self.orderId = orderId
9244 
    self.status = status
9245 
    self.description = description
94 ashish 9246 
 
9247 
  def read(self, iprot):
9248 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9249 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9250 
      return
9251 
    iprot.readStructBegin()
9252 
    while True:
9253 
      (fname, ftype, fid) = iprot.readFieldBegin()
9254 
      if ftype == TType.STOP:
9255 
        break
9256 
      if fid == 1:
9257 
        if ftype == TType.I64:
483 rajveer 9258 
          self.orderId = iprot.readI64();
94 ashish 9259 
        else:
9260 
          iprot.skip(ftype)
9261 
      elif fid == 2:
483 rajveer 9262 
        if ftype == TType.I32:
9263 
          self.status = iprot.readI32();
94 ashish 9264 
        else:
9265 
          iprot.skip(ftype)
483 rajveer 9266 
      elif fid == 3:
9267 
        if ftype == TType.STRING:
9268 
          self.description = iprot.readString();
9269 
        else:
9270 
          iprot.skip(ftype)
94 ashish 9271 
      else:
9272 
        iprot.skip(ftype)
9273 
      iprot.readFieldEnd()
9274 
    iprot.readStructEnd()
9275 
 
9276 
  def write(self, oprot):
9277 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9278 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9279 
      return
483 rajveer 9280 
    oprot.writeStructBegin('changeOrderStatus_args')
3431 rajveer 9281 
    if self.orderId is not None:
483 rajveer 9282 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
9283 
      oprot.writeI64(self.orderId)
94 ashish 9284 
      oprot.writeFieldEnd()
3431 rajveer 9285 
    if self.status is not None:
483 rajveer 9286 
      oprot.writeFieldBegin('status', TType.I32, 2)
9287 
      oprot.writeI32(self.status)
94 ashish 9288 
      oprot.writeFieldEnd()
3431 rajveer 9289 
    if self.description is not None:
483 rajveer 9290 
      oprot.writeFieldBegin('description', TType.STRING, 3)
9291 
      oprot.writeString(self.description)
9292 
      oprot.writeFieldEnd()
94 ashish 9293 
    oprot.writeFieldStop()
9294 
    oprot.writeStructEnd()
9295 
 
3431 rajveer 9296 
  def validate(self):
9297 
    return
9298 
 
9299 
 
94 ashish 9300 
  def __repr__(self):
9301 
    L = ['%s=%r' % (key, value)
9302 
      for key, value in self.__dict__.iteritems()]
9303 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9304 
 
9305 
  def __eq__(self, other):
9306 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9307 
 
9308 
  def __ne__(self, other):
9309 
    return not (self == other)
9310 
 
483 rajveer 9311 
class changeOrderStatus_result:
94 ashish 9312 
  """
9313 
  Attributes:
9314 
   - success
9315 
   - ex
9316 
  """
9317 
 
9318 
  thrift_spec = (
9319 
    (0, TType.BOOL, 'success', None, None, ), # 0
9320 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
9321 
  )
9322 
 
9323 
  def __init__(self, success=None, ex=None,):
9324 
    self.success = success
9325 
    self.ex = ex
9326 
 
9327 
  def read(self, iprot):
9328 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9329 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9330 
      return
9331 
    iprot.readStructBegin()
9332 
    while True:
9333 
      (fname, ftype, fid) = iprot.readFieldBegin()
9334 
      if ftype == TType.STOP:
9335 
        break
9336 
      if fid == 0:
9337 
        if ftype == TType.BOOL:
9338 
          self.success = iprot.readBool();
9339 
        else:
9340 
          iprot.skip(ftype)
9341 
      elif fid == 1:
9342 
        if ftype == TType.STRUCT:
9343 
          self.ex = TransactionServiceException()
9344 
          self.ex.read(iprot)
9345 
        else:
9346 
          iprot.skip(ftype)
9347 
      else:
9348 
        iprot.skip(ftype)
9349 
      iprot.readFieldEnd()
9350 
    iprot.readStructEnd()
9351 
 
9352 
  def write(self, oprot):
9353 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9354 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9355 
      return
483 rajveer 9356 
    oprot.writeStructBegin('changeOrderStatus_result')
3431 rajveer 9357 
    if self.success is not None:
94 ashish 9358 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
9359 
      oprot.writeBool(self.success)
9360 
      oprot.writeFieldEnd()
3431 rajveer 9361 
    if self.ex is not None:
94 ashish 9362 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
9363 
      self.ex.write(oprot)
9364 
      oprot.writeFieldEnd()
9365 
    oprot.writeFieldStop()
9366 
    oprot.writeStructEnd()
9367 
 
3431 rajveer 9368 
  def validate(self):
9369 
    return
9370 
 
9371 
 
94 ashish 9372 
  def __repr__(self):
9373 
    L = ['%s=%r' % (key, value)
9374 
      for key, value in self.__dict__.iteritems()]
9375 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9376 
 
9377 
  def __eq__(self, other):
9378 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9379 
 
9380 
  def __ne__(self, other):
9381 
    return not (self == other)
9382 
 
3064 chandransh 9383 
class getOrdersForTransaction_args:
494 rajveer 9384 
  """
9385 
  Attributes:
3064 chandransh 9386 
   - transactionId
9387 
   - customerId
494 rajveer 9388 
  """
9389 
 
9390 
  thrift_spec = (
9391 
    None, # 0
3064 chandransh 9392 
    (1, TType.I64, 'transactionId', None, None, ), # 1
9393 
    (2, TType.I64, 'customerId', None, None, ), # 2
494 rajveer 9394 
  )
9395 
 
3064 chandransh 9396 
  def __init__(self, transactionId=None, customerId=None,):
9397 
    self.transactionId = transactionId
9398 
    self.customerId = customerId
494 rajveer 9399 
 
9400 
  def read(self, iprot):
9401 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9402 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9403 
      return
9404 
    iprot.readStructBegin()
9405 
    while True:
9406 
      (fname, ftype, fid) = iprot.readFieldBegin()
9407 
      if ftype == TType.STOP:
9408 
        break
9409 
      if fid == 1:
9410 
        if ftype == TType.I64:
3064 chandransh 9411 
          self.transactionId = iprot.readI64();
494 rajveer 9412 
        else:
9413 
          iprot.skip(ftype)
9414 
      elif fid == 2:
3064 chandransh 9415 
        if ftype == TType.I64:
9416 
          self.customerId = iprot.readI64();
494 rajveer 9417 
        else:
9418 
          iprot.skip(ftype)
9419 
      else:
9420 
        iprot.skip(ftype)
9421 
      iprot.readFieldEnd()
9422 
    iprot.readStructEnd()
9423 
 
9424 
  def write(self, oprot):
9425 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9426 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9427 
      return
3064 chandransh 9428 
    oprot.writeStructBegin('getOrdersForTransaction_args')
3431 rajveer 9429 
    if self.transactionId is not None:
3064 chandransh 9430 
      oprot.writeFieldBegin('transactionId', TType.I64, 1)
9431 
      oprot.writeI64(self.transactionId)
494 rajveer 9432 
      oprot.writeFieldEnd()
3431 rajveer 9433 
    if self.customerId is not None:
3064 chandransh 9434 
      oprot.writeFieldBegin('customerId', TType.I64, 2)
9435 
      oprot.writeI64(self.customerId)
494 rajveer 9436 
      oprot.writeFieldEnd()
9437 
    oprot.writeFieldStop()
9438 
    oprot.writeStructEnd()
9439 
 
3431 rajveer 9440 
  def validate(self):
9441 
    return
9442 
 
9443 
 
494 rajveer 9444 
  def __repr__(self):
9445 
    L = ['%s=%r' % (key, value)
9446 
      for key, value in self.__dict__.iteritems()]
9447 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9448 
 
9449 
  def __eq__(self, other):
9450 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9451 
 
9452 
  def __ne__(self, other):
9453 
    return not (self == other)
9454 
 
3064 chandransh 9455 
class getOrdersForTransaction_result:
494 rajveer 9456 
  """
9457 
  Attributes:
9458 
   - success
9459 
   - ex
9460 
  """
9461 
 
9462 
  thrift_spec = (
3064 chandransh 9463 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
494 rajveer 9464 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
9465 
  )
9466 
 
9467 
  def __init__(self, success=None, ex=None,):
9468 
    self.success = success
9469 
    self.ex = ex
9470 
 
9471 
  def read(self, iprot):
9472 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9473 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9474 
      return
9475 
    iprot.readStructBegin()
9476 
    while True:
9477 
      (fname, ftype, fid) = iprot.readFieldBegin()
9478 
      if ftype == TType.STOP:
9479 
        break
9480 
      if fid == 0:
3064 chandransh 9481 
        if ftype == TType.LIST:
9482 
          self.success = []
5031 varun.gupt 9483 
          (_etype143, _size140) = iprot.readListBegin()
9484 
          for _i144 in xrange(_size140):
9485 
            _elem145 = Order()
9486 
            _elem145.read(iprot)
9487 
            self.success.append(_elem145)
3064 chandransh 9488 
          iprot.readListEnd()
494 rajveer 9489 
        else:
9490 
          iprot.skip(ftype)
9491 
      elif fid == 1:
9492 
        if ftype == TType.STRUCT:
9493 
          self.ex = TransactionServiceException()
9494 
          self.ex.read(iprot)
9495 
        else:
9496 
          iprot.skip(ftype)
9497 
      else:
9498 
        iprot.skip(ftype)
9499 
      iprot.readFieldEnd()
9500 
    iprot.readStructEnd()
9501 
 
9502 
  def write(self, oprot):
9503 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9504 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9505 
      return
3064 chandransh 9506 
    oprot.writeStructBegin('getOrdersForTransaction_result')
3431 rajveer 9507 
    if self.success is not None:
3064 chandransh 9508 
      oprot.writeFieldBegin('success', TType.LIST, 0)
9509 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
5031 varun.gupt 9510 
      for iter146 in self.success:
9511 
        iter146.write(oprot)
3064 chandransh 9512 
      oprot.writeListEnd()
494 rajveer 9513 
      oprot.writeFieldEnd()
3431 rajveer 9514 
    if self.ex is not None:
494 rajveer 9515 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
9516 
      self.ex.write(oprot)
9517 
      oprot.writeFieldEnd()
9518 
    oprot.writeFieldStop()
9519 
    oprot.writeStructEnd()
9520 
 
3431 rajveer 9521 
  def validate(self):
9522 
    return
9523 
 
9524 
 
494 rajveer 9525 
  def __repr__(self):
9526 
    L = ['%s=%r' % (key, value)
9527 
      for key, value in self.__dict__.iteritems()]
9528 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9529 
 
9530 
  def __eq__(self, other):
9531 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9532 
 
9533 
  def __ne__(self, other):
9534 
    return not (self == other)
9535 
 
3064 chandransh 9536 
class getOrdersForCustomer_args:
1149 chandransh 9537 
  """
9538 
  Attributes:
3064 chandransh 9539 
   - customerId
9540 
   - from_date
9541 
   - to_date
9542 
   - statuses
1149 chandransh 9543 
  """
9544 
 
9545 
  thrift_spec = (
9546 
    None, # 0
3064 chandransh 9547 
    (1, TType.I64, 'customerId', None, None, ), # 1
9548 
    (2, TType.I64, 'from_date', None, None, ), # 2
9549 
    (3, TType.I64, 'to_date', None, None, ), # 3
9550 
    (4, TType.LIST, 'statuses', (TType.I32,None), None, ), # 4
1149 chandransh 9551 
  )
9552 
 
3064 chandransh 9553 
  def __init__(self, customerId=None, from_date=None, to_date=None, statuses=None,):
9554 
    self.customerId = customerId
9555 
    self.from_date = from_date
9556 
    self.to_date = to_date
9557 
    self.statuses = statuses
1149 chandransh 9558 
 
9559 
  def read(self, iprot):
9560 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9561 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9562 
      return
9563 
    iprot.readStructBegin()
9564 
    while True:
9565 
      (fname, ftype, fid) = iprot.readFieldBegin()
9566 
      if ftype == TType.STOP:
9567 
        break
9568 
      if fid == 1:
9569 
        if ftype == TType.I64:
3064 chandransh 9570 
          self.customerId = iprot.readI64();
1149 chandransh 9571 
        else:
9572 
          iprot.skip(ftype)
9573 
      elif fid == 2:
9574 
        if ftype == TType.I64:
3064 chandransh 9575 
          self.from_date = iprot.readI64();
1149 chandransh 9576 
        else:
9577 
          iprot.skip(ftype)
2783 chandransh 9578 
      elif fid == 3:
9579 
        if ftype == TType.I64:
3064 chandransh 9580 
          self.to_date = iprot.readI64();
2783 chandransh 9581 
        else:
9582 
          iprot.skip(ftype)
9583 
      elif fid == 4:
3064 chandransh 9584 
        if ftype == TType.LIST:
9585 
          self.statuses = []
5031 varun.gupt 9586 
          (_etype150, _size147) = iprot.readListBegin()
9587 
          for _i151 in xrange(_size147):
9588 
            _elem152 = iprot.readI32();
9589 
            self.statuses.append(_elem152)
3064 chandransh 9590 
          iprot.readListEnd()
2783 chandransh 9591 
        else:
9592 
          iprot.skip(ftype)
1149 chandransh 9593 
      else:
9594 
        iprot.skip(ftype)
9595 
      iprot.readFieldEnd()
9596 
    iprot.readStructEnd()
9597 
 
9598 
  def write(self, oprot):
9599 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9600 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9601 
      return
3064 chandransh 9602 
    oprot.writeStructBegin('getOrdersForCustomer_args')
3431 rajveer 9603 
    if self.customerId is not None:
3064 chandransh 9604 
      oprot.writeFieldBegin('customerId', TType.I64, 1)
9605 
      oprot.writeI64(self.customerId)
1149 chandransh 9606 
      oprot.writeFieldEnd()
3431 rajveer 9607 
    if self.from_date is not None:
3064 chandransh 9608 
      oprot.writeFieldBegin('from_date', TType.I64, 2)
9609 
      oprot.writeI64(self.from_date)
1149 chandransh 9610 
      oprot.writeFieldEnd()
3431 rajveer 9611 
    if self.to_date is not None:
3064 chandransh 9612 
      oprot.writeFieldBegin('to_date', TType.I64, 3)
9613 
      oprot.writeI64(self.to_date)
2783 chandransh 9614 
      oprot.writeFieldEnd()
3431 rajveer 9615 
    if self.statuses is not None:
3064 chandransh 9616 
      oprot.writeFieldBegin('statuses', TType.LIST, 4)
9617 
      oprot.writeListBegin(TType.I32, len(self.statuses))
5031 varun.gupt 9618 
      for iter153 in self.statuses:
9619 
        oprot.writeI32(iter153)
3064 chandransh 9620 
      oprot.writeListEnd()
2783 chandransh 9621 
      oprot.writeFieldEnd()
1149 chandransh 9622 
    oprot.writeFieldStop()
9623 
    oprot.writeStructEnd()
9624 
 
3431 rajveer 9625 
  def validate(self):
9626 
    return
9627 
 
9628 
 
1149 chandransh 9629 
  def __repr__(self):
9630 
    L = ['%s=%r' % (key, value)
9631 
      for key, value in self.__dict__.iteritems()]
9632 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9633 
 
9634 
  def __eq__(self, other):
9635 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9636 
 
9637 
  def __ne__(self, other):
9638 
    return not (self == other)
9639 
 
3064 chandransh 9640 
class getOrdersForCustomer_result:
1149 chandransh 9641 
  """
9642 
  Attributes:
9643 
   - success
9644 
   - ex
9645 
  """
9646 
 
9647 
  thrift_spec = (
3064 chandransh 9648 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
1149 chandransh 9649 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
9650 
  )
9651 
 
9652 
  def __init__(self, success=None, ex=None,):
9653 
    self.success = success
9654 
    self.ex = ex
9655 
 
9656 
  def read(self, iprot):
9657 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9658 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9659 
      return
9660 
    iprot.readStructBegin()
9661 
    while True:
9662 
      (fname, ftype, fid) = iprot.readFieldBegin()
9663 
      if ftype == TType.STOP:
9664 
        break
9665 
      if fid == 0:
3064 chandransh 9666 
        if ftype == TType.LIST:
9667 
          self.success = []
5031 varun.gupt 9668 
          (_etype157, _size154) = iprot.readListBegin()
9669 
          for _i158 in xrange(_size154):
9670 
            _elem159 = Order()
9671 
            _elem159.read(iprot)
9672 
            self.success.append(_elem159)
3064 chandransh 9673 
          iprot.readListEnd()
1149 chandransh 9674 
        else:
9675 
          iprot.skip(ftype)
9676 
      elif fid == 1:
9677 
        if ftype == TType.STRUCT:
9678 
          self.ex = TransactionServiceException()
9679 
          self.ex.read(iprot)
9680 
        else:
9681 
          iprot.skip(ftype)
9682 
      else:
9683 
        iprot.skip(ftype)
9684 
      iprot.readFieldEnd()
9685 
    iprot.readStructEnd()
9686 
 
9687 
  def write(self, oprot):
9688 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9689 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9690 
      return
3064 chandransh 9691 
    oprot.writeStructBegin('getOrdersForCustomer_result')
3431 rajveer 9692 
    if self.success is not None:
3064 chandransh 9693 
      oprot.writeFieldBegin('success', TType.LIST, 0)
9694 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
5031 varun.gupt 9695 
      for iter160 in self.success:
9696 
        iter160.write(oprot)
3064 chandransh 9697 
      oprot.writeListEnd()
1149 chandransh 9698 
      oprot.writeFieldEnd()
3431 rajveer 9699 
    if self.ex is not None:
1149 chandransh 9700 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
9701 
      self.ex.write(oprot)
9702 
      oprot.writeFieldEnd()
9703 
    oprot.writeFieldStop()
9704 
    oprot.writeStructEnd()
9705 
 
3431 rajveer 9706 
  def validate(self):
9707 
    return
9708 
 
9709 
 
1149 chandransh 9710 
  def __repr__(self):
9711 
    L = ['%s=%r' % (key, value)
9712 
      for key, value in self.__dict__.iteritems()]
9713 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9714 
 
9715 
  def __eq__(self, other):
9716 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9717 
 
9718 
  def __ne__(self, other):
9719 
    return not (self == other)
9720 
 
3064 chandransh 9721 
class createOrder_args:
921 rajveer 9722 
  """
9723 
  Attributes:
3064 chandransh 9724 
   - order
921 rajveer 9725 
  """
9726 
 
9727 
  thrift_spec = (
9728 
    None, # 0
3064 chandransh 9729 
    (1, TType.STRUCT, 'order', (Order, Order.thrift_spec), None, ), # 1
921 rajveer 9730 
  )
9731 
 
3064 chandransh 9732 
  def __init__(self, order=None,):
9733 
    self.order = order
921 rajveer 9734 
 
9735 
  def read(self, iprot):
9736 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9737 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9738 
      return
9739 
    iprot.readStructBegin()
9740 
    while True:
9741 
      (fname, ftype, fid) = iprot.readFieldBegin()
9742 
      if ftype == TType.STOP:
9743 
        break
9744 
      if fid == 1:
3064 chandransh 9745 
        if ftype == TType.STRUCT:
9746 
          self.order = Order()
9747 
          self.order.read(iprot)
921 rajveer 9748 
        else:
9749 
          iprot.skip(ftype)
9750 
      else:
9751 
        iprot.skip(ftype)
9752 
      iprot.readFieldEnd()
9753 
    iprot.readStructEnd()
9754 
 
9755 
  def write(self, oprot):
9756 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9757 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9758 
      return
3064 chandransh 9759 
    oprot.writeStructBegin('createOrder_args')
3431 rajveer 9760 
    if self.order is not None:
3064 chandransh 9761 
      oprot.writeFieldBegin('order', TType.STRUCT, 1)
9762 
      self.order.write(oprot)
921 rajveer 9763 
      oprot.writeFieldEnd()
9764 
    oprot.writeFieldStop()
9765 
    oprot.writeStructEnd()
9766 
 
3431 rajveer 9767 
  def validate(self):
9768 
    return
9769 
 
9770 
 
921 rajveer 9771 
  def __repr__(self):
9772 
    L = ['%s=%r' % (key, value)
9773 
      for key, value in self.__dict__.iteritems()]
9774 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9775 
 
9776 
  def __eq__(self, other):
9777 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9778 
 
9779 
  def __ne__(self, other):
9780 
    return not (self == other)
9781 
 
3064 chandransh 9782 
class createOrder_result:
921 rajveer 9783 
  """
9784 
  Attributes:
9785 
   - success
9786 
   - ex
9787 
  """
9788 
 
9789 
  thrift_spec = (
3064 chandransh 9790 
    (0, TType.I64, 'success', None, None, ), # 0
921 rajveer 9791 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
9792 
  )
9793 
 
9794 
  def __init__(self, success=None, ex=None,):
9795 
    self.success = success
9796 
    self.ex = ex
9797 
 
9798 
  def read(self, iprot):
9799 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9800 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9801 
      return
9802 
    iprot.readStructBegin()
9803 
    while True:
9804 
      (fname, ftype, fid) = iprot.readFieldBegin()
9805 
      if ftype == TType.STOP:
9806 
        break
9807 
      if fid == 0:
3064 chandransh 9808 
        if ftype == TType.I64:
9809 
          self.success = iprot.readI64();
921 rajveer 9810 
        else:
9811 
          iprot.skip(ftype)
9812 
      elif fid == 1:
9813 
        if ftype == TType.STRUCT:
9814 
          self.ex = TransactionServiceException()
9815 
          self.ex.read(iprot)
9816 
        else:
9817 
          iprot.skip(ftype)
9818 
      else:
9819 
        iprot.skip(ftype)
9820 
      iprot.readFieldEnd()
9821 
    iprot.readStructEnd()
9822 
 
9823 
  def write(self, oprot):
9824 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9825 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9826 
      return
3064 chandransh 9827 
    oprot.writeStructBegin('createOrder_result')
3431 rajveer 9828 
    if self.success is not None:
3064 chandransh 9829 
      oprot.writeFieldBegin('success', TType.I64, 0)
9830 
      oprot.writeI64(self.success)
921 rajveer 9831 
      oprot.writeFieldEnd()
3431 rajveer 9832 
    if self.ex is not None:
921 rajveer 9833 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
9834 
      self.ex.write(oprot)
9835 
      oprot.writeFieldEnd()
9836 
    oprot.writeFieldStop()
9837 
    oprot.writeStructEnd()
9838 
 
3431 rajveer 9839 
  def validate(self):
9840 
    return
9841 
 
9842 
 
921 rajveer 9843 
  def __repr__(self):
9844 
    L = ['%s=%r' % (key, value)
9845 
      for key, value in self.__dict__.iteritems()]
9846 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9847 
 
9848 
  def __eq__(self, other):
9849 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9850 
 
9851 
  def __ne__(self, other):
9852 
    return not (self == other)
9853 
 
3064 chandransh 9854 
class getOrder_args:
921 rajveer 9855 
  """
9856 
  Attributes:
3064 chandransh 9857 
   - id
921 rajveer 9858 
  """
9859 
 
9860 
  thrift_spec = (
9861 
    None, # 0
3064 chandransh 9862 
    (1, TType.I64, 'id', None, None, ), # 1
921 rajveer 9863 
  )
9864 
 
3064 chandransh 9865 
  def __init__(self, id=None,):
9866 
    self.id = id
921 rajveer 9867 
 
9868 
  def read(self, iprot):
9869 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9870 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9871 
      return
9872 
    iprot.readStructBegin()
9873 
    while True:
9874 
      (fname, ftype, fid) = iprot.readFieldBegin()
9875 
      if ftype == TType.STOP:
9876 
        break
9877 
      if fid == 1:
9878 
        if ftype == TType.I64:
3064 chandransh 9879 
          self.id = iprot.readI64();
921 rajveer 9880 
        else:
9881 
          iprot.skip(ftype)
9882 
      else:
9883 
        iprot.skip(ftype)
9884 
      iprot.readFieldEnd()
9885 
    iprot.readStructEnd()
9886 
 
9887 
  def write(self, oprot):
9888 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9889 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9890 
      return
3064 chandransh 9891 
    oprot.writeStructBegin('getOrder_args')
3431 rajveer 9892 
    if self.id is not None:
3064 chandransh 9893 
      oprot.writeFieldBegin('id', TType.I64, 1)
9894 
      oprot.writeI64(self.id)
921 rajveer 9895 
      oprot.writeFieldEnd()
9896 
    oprot.writeFieldStop()
9897 
    oprot.writeStructEnd()
9898 
 
3431 rajveer 9899 
  def validate(self):
9900 
    return
9901 
 
9902 
 
921 rajveer 9903 
  def __repr__(self):
9904 
    L = ['%s=%r' % (key, value)
9905 
      for key, value in self.__dict__.iteritems()]
9906 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9907 
 
9908 
  def __eq__(self, other):
9909 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9910 
 
9911 
  def __ne__(self, other):
9912 
    return not (self == other)
9913 
 
3064 chandransh 9914 
class getOrder_result:
921 rajveer 9915 
  """
9916 
  Attributes:
9917 
   - success
9918 
   - ex
9919 
  """
9920 
 
9921 
  thrift_spec = (
3064 chandransh 9922 
    (0, TType.STRUCT, 'success', (Order, Order.thrift_spec), None, ), # 0
921 rajveer 9923 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
9924 
  )
9925 
 
9926 
  def __init__(self, success=None, ex=None,):
9927 
    self.success = success
9928 
    self.ex = ex
9929 
 
9930 
  def read(self, iprot):
9931 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9932 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9933 
      return
9934 
    iprot.readStructBegin()
9935 
    while True:
9936 
      (fname, ftype, fid) = iprot.readFieldBegin()
9937 
      if ftype == TType.STOP:
9938 
        break
9939 
      if fid == 0:
3064 chandransh 9940 
        if ftype == TType.STRUCT:
9941 
          self.success = Order()
9942 
          self.success.read(iprot)
921 rajveer 9943 
        else:
9944 
          iprot.skip(ftype)
9945 
      elif fid == 1:
9946 
        if ftype == TType.STRUCT:
9947 
          self.ex = TransactionServiceException()
9948 
          self.ex.read(iprot)
9949 
        else:
9950 
          iprot.skip(ftype)
9951 
      else:
9952 
        iprot.skip(ftype)
9953 
      iprot.readFieldEnd()
9954 
    iprot.readStructEnd()
9955 
 
9956 
  def write(self, oprot):
9957 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9958 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9959 
      return
3064 chandransh 9960 
    oprot.writeStructBegin('getOrder_result')
3431 rajveer 9961 
    if self.success is not None:
3064 chandransh 9962 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
9963 
      self.success.write(oprot)
921 rajveer 9964 
      oprot.writeFieldEnd()
3431 rajveer 9965 
    if self.ex is not None:
921 rajveer 9966 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
9967 
      self.ex.write(oprot)
9968 
      oprot.writeFieldEnd()
9969 
    oprot.writeFieldStop()
9970 
    oprot.writeStructEnd()
9971 
 
3431 rajveer 9972 
  def validate(self):
9973 
    return
9974 
 
9975 
 
921 rajveer 9976 
  def __repr__(self):
9977 
    L = ['%s=%r' % (key, value)
9978 
      for key, value in self.__dict__.iteritems()]
9979 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9980 
 
9981 
  def __eq__(self, other):
9982 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9983 
 
9984 
  def __ne__(self, other):
9985 
    return not (self == other)
9986 
 
3064 chandransh 9987 
class getLineItemsForOrder_args:
94 ashish 9988 
  """
9989 
  Attributes:
3064 chandransh 9990 
   - orderId
94 ashish 9991 
  """
9992 
 
9993 
  thrift_spec = (
9994 
    None, # 0
3064 chandransh 9995 
    (1, TType.I64, 'orderId', None, None, ), # 1
94 ashish 9996 
  )
9997 
 
3064 chandransh 9998 
  def __init__(self, orderId=None,):
9999 
    self.orderId = orderId
94 ashish 10000 
 
10001 
  def read(self, iprot):
10002 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10003 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10004 
      return
10005 
    iprot.readStructBegin()
10006 
    while True:
10007 
      (fname, ftype, fid) = iprot.readFieldBegin()
10008 
      if ftype == TType.STOP:
10009 
        break
10010 
      if fid == 1:
10011 
        if ftype == TType.I64:
3064 chandransh 10012 
          self.orderId = iprot.readI64();
94 ashish 10013 
        else:
10014 
          iprot.skip(ftype)
10015 
      else:
10016 
        iprot.skip(ftype)
10017 
      iprot.readFieldEnd()
10018 
    iprot.readStructEnd()
10019 
 
10020 
  def write(self, oprot):
10021 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10022 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10023 
      return
3064 chandransh 10024 
    oprot.writeStructBegin('getLineItemsForOrder_args')
3431 rajveer 10025 
    if self.orderId is not None:
3064 chandransh 10026 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
10027 
      oprot.writeI64(self.orderId)
94 ashish 10028 
      oprot.writeFieldEnd()
10029 
    oprot.writeFieldStop()
10030 
    oprot.writeStructEnd()
10031 
 
3431 rajveer 10032 
  def validate(self):
10033 
    return
10034 
 
10035 
 
94 ashish 10036 
  def __repr__(self):
10037 
    L = ['%s=%r' % (key, value)
10038 
      for key, value in self.__dict__.iteritems()]
10039 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10040 
 
10041 
  def __eq__(self, other):
10042 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10043 
 
10044 
  def __ne__(self, other):
10045 
    return not (self == other)
10046 
 
3064 chandransh 10047 
class getLineItemsForOrder_result:
94 ashish 10048 
  """
10049 
  Attributes:
10050 
   - success
10051 
   - ex
10052 
  """
10053 
 
10054 
  thrift_spec = (
3064 chandransh 10055 
    (0, TType.LIST, 'success', (TType.STRUCT,(LineItem, LineItem.thrift_spec)), None, ), # 0
94 ashish 10056 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
10057 
  )
10058 
 
10059 
  def __init__(self, success=None, ex=None,):
10060 
    self.success = success
10061 
    self.ex = ex
10062 
 
10063 
  def read(self, iprot):
10064 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10065 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10066 
      return
10067 
    iprot.readStructBegin()
10068 
    while True:
10069 
      (fname, ftype, fid) = iprot.readFieldBegin()
10070 
      if ftype == TType.STOP:
10071 
        break
10072 
      if fid == 0:
483 rajveer 10073 
        if ftype == TType.LIST:
10074 
          self.success = []
5031 varun.gupt 10075 
          (_etype164, _size161) = iprot.readListBegin()
10076 
          for _i165 in xrange(_size161):
10077 
            _elem166 = LineItem()
10078 
            _elem166.read(iprot)
10079 
            self.success.append(_elem166)
483 rajveer 10080 
          iprot.readListEnd()
94 ashish 10081 
        else:
10082 
          iprot.skip(ftype)
10083 
      elif fid == 1:
10084 
        if ftype == TType.STRUCT:
10085 
          self.ex = TransactionServiceException()
10086 
          self.ex.read(iprot)
10087 
        else:
10088 
          iprot.skip(ftype)
10089 
      else:
10090 
        iprot.skip(ftype)
10091 
      iprot.readFieldEnd()
10092 
    iprot.readStructEnd()
10093 
 
10094 
  def write(self, oprot):
10095 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10096 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10097 
      return
3064 chandransh 10098 
    oprot.writeStructBegin('getLineItemsForOrder_result')
3431 rajveer 10099 
    if self.success is not None:
483 rajveer 10100 
      oprot.writeFieldBegin('success', TType.LIST, 0)
10101 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
5031 varun.gupt 10102 
      for iter167 in self.success:
10103 
        iter167.write(oprot)
483 rajveer 10104 
      oprot.writeListEnd()
94 ashish 10105 
      oprot.writeFieldEnd()
3431 rajveer 10106 
    if self.ex is not None:
94 ashish 10107 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
10108 
      self.ex.write(oprot)
10109 
      oprot.writeFieldEnd()
10110 
    oprot.writeFieldStop()
10111 
    oprot.writeStructEnd()
10112 
 
3431 rajveer 10113 
  def validate(self):
10114 
    return
10115 
 
10116 
 
94 ashish 10117 
  def __repr__(self):
10118 
    L = ['%s=%r' % (key, value)
10119 
      for key, value in self.__dict__.iteritems()]
10120 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10121 
 
10122 
  def __eq__(self, other):
10123 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10124 
 
10125 
  def __ne__(self, other):
10126 
    return not (self == other)
10127 
 
4999 phani.kuma 10128 
class getOrderList_args:
10129 
  """
10130 
  Attributes:
10131 
   - order_ids
10132 
  """
10133 
 
10134 
  thrift_spec = (
10135 
    None, # 0
10136 
    (1, TType.LIST, 'order_ids', (TType.I64,None), None, ), # 1
10137 
  )
10138 
 
10139 
  def __init__(self, order_ids=None,):
10140 
    self.order_ids = order_ids
10141 
 
10142 
  def read(self, iprot):
10143 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10144 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10145 
      return
10146 
    iprot.readStructBegin()
10147 
    while True:
10148 
      (fname, ftype, fid) = iprot.readFieldBegin()
10149 
      if ftype == TType.STOP:
10150 
        break
10151 
      if fid == 1:
10152 
        if ftype == TType.LIST:
10153 
          self.order_ids = []
5031 varun.gupt 10154 
          (_etype171, _size168) = iprot.readListBegin()
10155 
          for _i172 in xrange(_size168):
10156 
            _elem173 = iprot.readI64();
10157 
            self.order_ids.append(_elem173)
4999 phani.kuma 10158 
          iprot.readListEnd()
10159 
        else:
10160 
          iprot.skip(ftype)
10161 
      else:
10162 
        iprot.skip(ftype)
10163 
      iprot.readFieldEnd()
10164 
    iprot.readStructEnd()
10165 
 
10166 
  def write(self, oprot):
10167 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10168 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10169 
      return
10170 
    oprot.writeStructBegin('getOrderList_args')
10171 
    if self.order_ids is not None:
10172 
      oprot.writeFieldBegin('order_ids', TType.LIST, 1)
10173 
      oprot.writeListBegin(TType.I64, len(self.order_ids))
5031 varun.gupt 10174 
      for iter174 in self.order_ids:
10175 
        oprot.writeI64(iter174)
4999 phani.kuma 10176 
      oprot.writeListEnd()
10177 
      oprot.writeFieldEnd()
10178 
    oprot.writeFieldStop()
10179 
    oprot.writeStructEnd()
10180 
 
10181 
  def validate(self):
10182 
    return
10183 
 
10184 
 
10185 
  def __repr__(self):
10186 
    L = ['%s=%r' % (key, value)
10187 
      for key, value in self.__dict__.iteritems()]
10188 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10189 
 
10190 
  def __eq__(self, other):
10191 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10192 
 
10193 
  def __ne__(self, other):
10194 
    return not (self == other)
10195 
 
10196 
class getOrderList_result:
10197 
  """
10198 
  Attributes:
10199 
   - success
10200 
  """
10201 
 
10202 
  thrift_spec = (
10203 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
10204 
  )
10205 
 
10206 
  def __init__(self, success=None,):
10207 
    self.success = success
10208 
 
10209 
  def read(self, iprot):
10210 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10211 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10212 
      return
10213 
    iprot.readStructBegin()
10214 
    while True:
10215 
      (fname, ftype, fid) = iprot.readFieldBegin()
10216 
      if ftype == TType.STOP:
10217 
        break
10218 
      if fid == 0:
10219 
        if ftype == TType.LIST:
10220 
          self.success = []
5031 varun.gupt 10221 
          (_etype178, _size175) = iprot.readListBegin()
10222 
          for _i179 in xrange(_size175):
10223 
            _elem180 = Order()
10224 
            _elem180.read(iprot)
10225 
            self.success.append(_elem180)
4999 phani.kuma 10226 
          iprot.readListEnd()
10227 
        else:
10228 
          iprot.skip(ftype)
10229 
      else:
10230 
        iprot.skip(ftype)
10231 
      iprot.readFieldEnd()
10232 
    iprot.readStructEnd()
10233 
 
10234 
  def write(self, oprot):
10235 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10236 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10237 
      return
10238 
    oprot.writeStructBegin('getOrderList_result')
10239 
    if self.success is not None:
10240 
      oprot.writeFieldBegin('success', TType.LIST, 0)
10241 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
5031 varun.gupt 10242 
      for iter181 in self.success:
10243 
        iter181.write(oprot)
4999 phani.kuma 10244 
      oprot.writeListEnd()
10245 
      oprot.writeFieldEnd()
10246 
    oprot.writeFieldStop()
10247 
    oprot.writeStructEnd()
10248 
 
10249 
  def validate(self):
10250 
    return
10251 
 
10252 
 
10253 
  def __repr__(self):
10254 
    L = ['%s=%r' % (key, value)
10255 
      for key, value in self.__dict__.iteritems()]
10256 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10257 
 
10258 
  def __eq__(self, other):
10259 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10260 
 
10261 
  def __ne__(self, other):
10262 
    return not (self == other)
10263 
 
5386 phani.kuma 10264 
class getOrderListForVendor_args:
10265 
  """
10266 
  Attributes:
10267 
   - order_ids
10268 
   - vendorId
10269 
  """
10270 
 
10271 
  thrift_spec = (
10272 
    None, # 0
10273 
    (1, TType.LIST, 'order_ids', (TType.I64,None), None, ), # 1
10274 
    (2, TType.I64, 'vendorId', None, None, ), # 2
10275 
  )
10276 
 
10277 
  def __init__(self, order_ids=None, vendorId=None,):
10278 
    self.order_ids = order_ids
10279 
    self.vendorId = vendorId
10280 
 
10281 
  def read(self, iprot):
10282 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10283 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10284 
      return
10285 
    iprot.readStructBegin()
10286 
    while True:
10287 
      (fname, ftype, fid) = iprot.readFieldBegin()
10288 
      if ftype == TType.STOP:
10289 
        break
10290 
      if fid == 1:
10291 
        if ftype == TType.LIST:
10292 
          self.order_ids = []
10293 
          (_etype185, _size182) = iprot.readListBegin()
10294 
          for _i186 in xrange(_size182):
10295 
            _elem187 = iprot.readI64();
10296 
            self.order_ids.append(_elem187)
10297 
          iprot.readListEnd()
10298 
        else:
10299 
          iprot.skip(ftype)
10300 
      elif fid == 2:
10301 
        if ftype == TType.I64:
10302 
          self.vendorId = iprot.readI64();
10303 
        else:
10304 
          iprot.skip(ftype)
10305 
      else:
10306 
        iprot.skip(ftype)
10307 
      iprot.readFieldEnd()
10308 
    iprot.readStructEnd()
10309 
 
10310 
  def write(self, oprot):
10311 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10312 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10313 
      return
10314 
    oprot.writeStructBegin('getOrderListForVendor_args')
10315 
    if self.order_ids is not None:
10316 
      oprot.writeFieldBegin('order_ids', TType.LIST, 1)
10317 
      oprot.writeListBegin(TType.I64, len(self.order_ids))
10318 
      for iter188 in self.order_ids:
10319 
        oprot.writeI64(iter188)
10320 
      oprot.writeListEnd()
10321 
      oprot.writeFieldEnd()
10322 
    if self.vendorId is not None:
10323 
      oprot.writeFieldBegin('vendorId', TType.I64, 2)
10324 
      oprot.writeI64(self.vendorId)
10325 
      oprot.writeFieldEnd()
10326 
    oprot.writeFieldStop()
10327 
    oprot.writeStructEnd()
10328 
 
10329 
  def validate(self):
10330 
    return
10331 
 
10332 
 
10333 
  def __repr__(self):
10334 
    L = ['%s=%r' % (key, value)
10335 
      for key, value in self.__dict__.iteritems()]
10336 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10337 
 
10338 
  def __eq__(self, other):
10339 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10340 
 
10341 
  def __ne__(self, other):
10342 
    return not (self == other)
10343 
 
10344 
class getOrderListForVendor_result:
10345 
  """
10346 
  Attributes:
10347 
   - success
10348 
  """
10349 
 
10350 
  thrift_spec = (
10351 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
10352 
  )
10353 
 
10354 
  def __init__(self, success=None,):
10355 
    self.success = success
10356 
 
10357 
  def read(self, iprot):
10358 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10359 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10360 
      return
10361 
    iprot.readStructBegin()
10362 
    while True:
10363 
      (fname, ftype, fid) = iprot.readFieldBegin()
10364 
      if ftype == TType.STOP:
10365 
        break
10366 
      if fid == 0:
10367 
        if ftype == TType.LIST:
10368 
          self.success = []
10369 
          (_etype192, _size189) = iprot.readListBegin()
10370 
          for _i193 in xrange(_size189):
10371 
            _elem194 = Order()
10372 
            _elem194.read(iprot)
10373 
            self.success.append(_elem194)
10374 
          iprot.readListEnd()
10375 
        else:
10376 
          iprot.skip(ftype)
10377 
      else:
10378 
        iprot.skip(ftype)
10379 
      iprot.readFieldEnd()
10380 
    iprot.readStructEnd()
10381 
 
10382 
  def write(self, oprot):
10383 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10384 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10385 
      return
10386 
    oprot.writeStructBegin('getOrderListForVendor_result')
10387 
    if self.success is not None:
10388 
      oprot.writeFieldBegin('success', TType.LIST, 0)
10389 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
10390 
      for iter195 in self.success:
10391 
        iter195.write(oprot)
10392 
      oprot.writeListEnd()
10393 
      oprot.writeFieldEnd()
10394 
    oprot.writeFieldStop()
10395 
    oprot.writeStructEnd()
10396 
 
10397 
  def validate(self):
10398 
    return
10399 
 
10400 
 
10401 
  def __repr__(self):
10402 
    L = ['%s=%r' % (key, value)
10403 
      for key, value in self.__dict__.iteritems()]
10404 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10405 
 
10406 
  def __eq__(self, other):
10407 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10408 
 
10409 
  def __ne__(self, other):
10410 
    return not (self == other)
10411 
 
3064 chandransh 10412 
class getOrderForCustomer_args:
94 ashish 10413 
  """
10414 
  Attributes:
3064 chandransh 10415 
   - orderId
483 rajveer 10416 
   - customerId
94 ashish 10417 
  """
10418 
 
10419 
  thrift_spec = (
10420 
    None, # 0
3064 chandransh 10421 
    (1, TType.I64, 'orderId', None, None, ), # 1
10422 
    (2, TType.I64, 'customerId', None, None, ), # 2
94 ashish 10423 
  )
10424 
 
3064 chandransh 10425 
  def __init__(self, orderId=None, customerId=None,):
10426 
    self.orderId = orderId
483 rajveer 10427 
    self.customerId = customerId
94 ashish 10428 
 
10429 
  def read(self, iprot):
10430 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10431 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10432 
      return
10433 
    iprot.readStructBegin()
10434 
    while True:
10435 
      (fname, ftype, fid) = iprot.readFieldBegin()
10436 
      if ftype == TType.STOP:
10437 
        break
10438 
      if fid == 1:
10439 
        if ftype == TType.I64:
3064 chandransh 10440 
          self.orderId = iprot.readI64();
94 ashish 10441 
        else:
10442 
          iprot.skip(ftype)
10443 
      elif fid == 2:
10444 
        if ftype == TType.I64:
3064 chandransh 10445 
          self.customerId = iprot.readI64();
94 ashish 10446 
        else:
10447 
          iprot.skip(ftype)
10448 
      else:
10449 
        iprot.skip(ftype)
10450 
      iprot.readFieldEnd()
10451 
    iprot.readStructEnd()
10452 
 
10453 
  def write(self, oprot):
10454 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10455 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10456 
      return
3064 chandransh 10457 
    oprot.writeStructBegin('getOrderForCustomer_args')
3431 rajveer 10458 
    if self.orderId is not None:
3064 chandransh 10459 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
10460 
      oprot.writeI64(self.orderId)
10461 
      oprot.writeFieldEnd()
3431 rajveer 10462 
    if self.customerId is not None:
3064 chandransh 10463 
      oprot.writeFieldBegin('customerId', TType.I64, 2)
483 rajveer 10464 
      oprot.writeI64(self.customerId)
94 ashish 10465 
      oprot.writeFieldEnd()
10466 
    oprot.writeFieldStop()
10467 
    oprot.writeStructEnd()
10468 
 
3431 rajveer 10469 
  def validate(self):
10470 
    return
10471 
 
10472 
 
94 ashish 10473 
  def __repr__(self):
10474 
    L = ['%s=%r' % (key, value)
10475 
      for key, value in self.__dict__.iteritems()]
10476 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10477 
 
10478 
  def __eq__(self, other):
10479 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10480 
 
10481 
  def __ne__(self, other):
10482 
    return not (self == other)
10483 
 
3064 chandransh 10484 
class getOrderForCustomer_result:
94 ashish 10485 
  """
10486 
  Attributes:
10487 
   - success
10488 
   - ex
10489 
  """
10490 
 
10491 
  thrift_spec = (
3064 chandransh 10492 
    (0, TType.STRUCT, 'success', (Order, Order.thrift_spec), None, ), # 0
94 ashish 10493 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
10494 
  )
10495 
 
10496 
  def __init__(self, success=None, ex=None,):
10497 
    self.success = success
10498 
    self.ex = ex
10499 
 
10500 
  def read(self, iprot):
10501 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10502 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10503 
      return
10504 
    iprot.readStructBegin()
10505 
    while True:
10506 
      (fname, ftype, fid) = iprot.readFieldBegin()
10507 
      if ftype == TType.STOP:
10508 
        break
10509 
      if fid == 0:
3064 chandransh 10510 
        if ftype == TType.STRUCT:
10511 
          self.success = Order()
10512 
          self.success.read(iprot)
94 ashish 10513 
        else:
10514 
          iprot.skip(ftype)
10515 
      elif fid == 1:
10516 
        if ftype == TType.STRUCT:
10517 
          self.ex = TransactionServiceException()
10518 
          self.ex.read(iprot)
10519 
        else:
10520 
          iprot.skip(ftype)
10521 
      else:
10522 
        iprot.skip(ftype)
10523 
      iprot.readFieldEnd()
10524 
    iprot.readStructEnd()
10525 
 
10526 
  def write(self, oprot):
10527 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10528 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10529 
      return
3064 chandransh 10530 
    oprot.writeStructBegin('getOrderForCustomer_result')
3431 rajveer 10531 
    if self.success is not None:
3064 chandransh 10532 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
10533 
      self.success.write(oprot)
94 ashish 10534 
      oprot.writeFieldEnd()
3431 rajveer 10535 
    if self.ex is not None:
94 ashish 10536 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
10537 
      self.ex.write(oprot)
10538 
      oprot.writeFieldEnd()
10539 
    oprot.writeFieldStop()
10540 
    oprot.writeStructEnd()
10541 
 
3431 rajveer 10542 
  def validate(self):
10543 
    return
10544 
 
10545 
 
94 ashish 10546 
  def __repr__(self):
10547 
    L = ['%s=%r' % (key, value)
10548 
      for key, value in self.__dict__.iteritems()]
10549 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10550 
 
10551 
  def __eq__(self, other):
10552 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10553 
 
10554 
  def __ne__(self, other):
10555 
    return not (self == other)
10556 
 
3064 chandransh 10557 
class getAlerts_args:
94 ashish 10558 
  """
10559 
  Attributes:
4394 rajveer 10560 
   - type
4444 rajveer 10561 
   - warehouseId
4394 rajveer 10562 
   - status
10563 
   - timestamp
94 ashish 10564 
  """
10565 
 
10566 
  thrift_spec = (
10567 
    None, # 0
4394 rajveer 10568 
    (1, TType.I64, 'type', None, None, ), # 1
4444 rajveer 10569 
    (2, TType.I64, 'warehouseId', None, None, ), # 2
10570 
    (3, TType.I64, 'status', None, None, ), # 3
10571 
    (4, TType.I64, 'timestamp', None, None, ), # 4
94 ashish 10572 
  )
10573 
 
4444 rajveer 10574 
  def __init__(self, type=None, warehouseId=None, status=None, timestamp=None,):
4394 rajveer 10575 
    self.type = type
4444 rajveer 10576 
    self.warehouseId = warehouseId
4394 rajveer 10577 
    self.status = status
10578 
    self.timestamp = timestamp
94 ashish 10579 
 
10580 
  def read(self, iprot):
10581 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10582 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10583 
      return
10584 
    iprot.readStructBegin()
10585 
    while True:
10586 
      (fname, ftype, fid) = iprot.readFieldBegin()
10587 
      if ftype == TType.STOP:
10588 
        break
10589 
      if fid == 1:
3064 chandransh 10590 
        if ftype == TType.I64:
4394 rajveer 10591 
          self.type = iprot.readI64();
94 ashish 10592 
        else:
10593 
          iprot.skip(ftype)
3064 chandransh 10594 
      elif fid == 2:
4394 rajveer 10595 
        if ftype == TType.I64:
4444 rajveer 10596 
          self.warehouseId = iprot.readI64();
3064 chandransh 10597 
        else:
10598 
          iprot.skip(ftype)
4394 rajveer 10599 
      elif fid == 3:
10600 
        if ftype == TType.I64:
4444 rajveer 10601 
          self.status = iprot.readI64();
10602 
        else:
10603 
          iprot.skip(ftype)
10604 
      elif fid == 4:
10605 
        if ftype == TType.I64:
4394 rajveer 10606 
          self.timestamp = iprot.readI64();
10607 
        else:
10608 
          iprot.skip(ftype)
94 ashish 10609 
      else:
10610 
        iprot.skip(ftype)
10611 
      iprot.readFieldEnd()
10612 
    iprot.readStructEnd()
10613 
 
10614 
  def write(self, oprot):
10615 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10616 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10617 
      return
3064 chandransh 10618 
    oprot.writeStructBegin('getAlerts_args')
4394 rajveer 10619 
    if self.type is not None:
10620 
      oprot.writeFieldBegin('type', TType.I64, 1)
10621 
      oprot.writeI64(self.type)
94 ashish 10622 
      oprot.writeFieldEnd()
4444 rajveer 10623 
    if self.warehouseId is not None:
10624 
      oprot.writeFieldBegin('warehouseId', TType.I64, 2)
10625 
      oprot.writeI64(self.warehouseId)
10626 
      oprot.writeFieldEnd()
4394 rajveer 10627 
    if self.status is not None:
4444 rajveer 10628 
      oprot.writeFieldBegin('status', TType.I64, 3)
4394 rajveer 10629 
      oprot.writeI64(self.status)
3064 chandransh 10630 
      oprot.writeFieldEnd()
4394 rajveer 10631 
    if self.timestamp is not None:
4444 rajveer 10632 
      oprot.writeFieldBegin('timestamp', TType.I64, 4)
4394 rajveer 10633 
      oprot.writeI64(self.timestamp)
10634 
      oprot.writeFieldEnd()
94 ashish 10635 
    oprot.writeFieldStop()
10636 
    oprot.writeStructEnd()
10637 
 
3431 rajveer 10638 
  def validate(self):
10639 
    return
10640 
 
10641 
 
94 ashish 10642 
  def __repr__(self):
10643 
    L = ['%s=%r' % (key, value)
10644 
      for key, value in self.__dict__.iteritems()]
10645 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10646 
 
10647 
  def __eq__(self, other):
10648 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10649 
 
10650 
  def __ne__(self, other):
10651 
    return not (self == other)
10652 
 
3064 chandransh 10653 
class getAlerts_result:
94 ashish 10654 
  """
10655 
  Attributes:
10656 
   - success
10657 
  """
10658 
 
10659 
  thrift_spec = (
3064 chandransh 10660 
    (0, TType.LIST, 'success', (TType.STRUCT,(Alert, Alert.thrift_spec)), None, ), # 0
94 ashish 10661 
  )
10662 
 
3064 chandransh 10663 
  def __init__(self, success=None,):
94 ashish 10664 
    self.success = success
10665 
 
10666 
  def read(self, iprot):
10667 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10668 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10669 
      return
10670 
    iprot.readStructBegin()
10671 
    while True:
10672 
      (fname, ftype, fid) = iprot.readFieldBegin()
10673 
      if ftype == TType.STOP:
10674 
        break
10675 
      if fid == 0:
3064 chandransh 10676 
        if ftype == TType.LIST:
10677 
          self.success = []
5386 phani.kuma 10678 
          (_etype199, _size196) = iprot.readListBegin()
10679 
          for _i200 in xrange(_size196):
10680 
            _elem201 = Alert()
10681 
            _elem201.read(iprot)
10682 
            self.success.append(_elem201)
3064 chandransh 10683 
          iprot.readListEnd()
94 ashish 10684 
        else:
10685 
          iprot.skip(ftype)
10686 
      else:
10687 
        iprot.skip(ftype)
10688 
      iprot.readFieldEnd()
10689 
    iprot.readStructEnd()
10690 
 
10691 
  def write(self, oprot):
10692 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10693 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10694 
      return
3064 chandransh 10695 
    oprot.writeStructBegin('getAlerts_result')
3431 rajveer 10696 
    if self.success is not None:
3064 chandransh 10697 
      oprot.writeFieldBegin('success', TType.LIST, 0)
10698 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
5386 phani.kuma 10699 
      for iter202 in self.success:
10700 
        iter202.write(oprot)
3064 chandransh 10701 
      oprot.writeListEnd()
94 ashish 10702 
      oprot.writeFieldEnd()
10703 
    oprot.writeFieldStop()
10704 
    oprot.writeStructEnd()
10705 
 
3431 rajveer 10706 
  def validate(self):
10707 
    return
10708 
 
10709 
 
94 ashish 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 
 
4394 rajveer 10721 
class addAlert_args:
94 ashish 10722 
  """
10723 
  Attributes:
3064 chandransh 10724 
   - type
4444 rajveer 10725 
   - warehouseId
4394 rajveer 10726 
   - description
94 ashish 10727 
  """
10728 
 
10729 
  thrift_spec = (
10730 
    None, # 0
4394 rajveer 10731 
    (1, TType.I64, 'type', None, None, ), # 1
4444 rajveer 10732 
    (2, TType.I64, 'warehouseId', None, None, ), # 2
10733 
    (3, TType.STRING, 'description', None, None, ), # 3
94 ashish 10734 
  )
10735 
 
4444 rajveer 10736 
  def __init__(self, type=None, warehouseId=None, description=None,):
3064 chandransh 10737 
    self.type = type
4444 rajveer 10738 
    self.warehouseId = warehouseId
4394 rajveer 10739 
    self.description = description
94 ashish 10740 
 
10741 
  def read(self, iprot):
10742 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10743 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10744 
      return
10745 
    iprot.readStructBegin()
10746 
    while True:
10747 
      (fname, ftype, fid) = iprot.readFieldBegin()
10748 
      if ftype == TType.STOP:
10749 
        break
10750 
      if fid == 1:
10751 
        if ftype == TType.I64:
4394 rajveer 10752 
          self.type = iprot.readI64();
94 ashish 10753 
        else:
10754 
          iprot.skip(ftype)
3064 chandransh 10755 
      elif fid == 2:
4444 rajveer 10756 
        if ftype == TType.I64:
10757 
          self.warehouseId = iprot.readI64();
10758 
        else:
10759 
          iprot.skip(ftype)
10760 
      elif fid == 3:
3064 chandransh 10761 
        if ftype == TType.STRING:
4394 rajveer 10762 
          self.description = iprot.readString();
3064 chandransh 10763 
        else:
10764 
          iprot.skip(ftype)
94 ashish 10765 
      else:
10766 
        iprot.skip(ftype)
10767 
      iprot.readFieldEnd()
10768 
    iprot.readStructEnd()
10769 
 
10770 
  def write(self, oprot):
10771 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10772 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10773 
      return
4394 rajveer 10774 
    oprot.writeStructBegin('addAlert_args')
3431 rajveer 10775 
    if self.type is not None:
4394 rajveer 10776 
      oprot.writeFieldBegin('type', TType.I64, 1)
3064 chandransh 10777 
      oprot.writeI64(self.type)
10778 
      oprot.writeFieldEnd()
4444 rajveer 10779 
    if self.warehouseId is not None:
10780 
      oprot.writeFieldBegin('warehouseId', TType.I64, 2)
10781 
      oprot.writeI64(self.warehouseId)
10782 
      oprot.writeFieldEnd()
4394 rajveer 10783 
    if self.description is not None:
4444 rajveer 10784 
      oprot.writeFieldBegin('description', TType.STRING, 3)
4394 rajveer 10785 
      oprot.writeString(self.description)
3064 chandransh 10786 
      oprot.writeFieldEnd()
94 ashish 10787 
    oprot.writeFieldStop()
10788 
    oprot.writeStructEnd()
10789 
 
3431 rajveer 10790 
  def validate(self):
10791 
    return
10792 
 
10793 
 
94 ashish 10794 
  def __repr__(self):
10795 
    L = ['%s=%r' % (key, value)
10796 
      for key, value in self.__dict__.iteritems()]
10797 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10798 
 
10799 
  def __eq__(self, other):
10800 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10801 
 
10802 
  def __ne__(self, other):
10803 
    return not (self == other)
10804 
 
4394 rajveer 10805 
class addAlert_result:
3064 chandransh 10806 
 
10807 
  thrift_spec = (
10808 
  )
10809 
 
10810 
  def read(self, iprot):
10811 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10812 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10813 
      return
10814 
    iprot.readStructBegin()
10815 
    while True:
10816 
      (fname, ftype, fid) = iprot.readFieldBegin()
10817 
      if ftype == TType.STOP:
10818 
        break
10819 
      else:
10820 
        iprot.skip(ftype)
10821 
      iprot.readFieldEnd()
10822 
    iprot.readStructEnd()
10823 
 
10824 
  def write(self, oprot):
10825 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10826 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10827 
      return
4394 rajveer 10828 
    oprot.writeStructBegin('addAlert_result')
3064 chandransh 10829 
    oprot.writeFieldStop()
10830 
    oprot.writeStructEnd()
10831 
 
3431 rajveer 10832 
  def validate(self):
10833 
    return
10834 
 
10835 
 
3064 chandransh 10836 
  def __repr__(self):
10837 
    L = ['%s=%r' % (key, value)
10838 
      for key, value in self.__dict__.iteritems()]
10839 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10840 
 
10841 
  def __eq__(self, other):
10842 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10843 
 
10844 
  def __ne__(self, other):
10845 
    return not (self == other)
10846 
 
4444 rajveer 10847 
class markAlertsAsSeen_args:
10848 
  """
10849 
  Attributes:
10850 
   - warehouseId
10851 
  """
10852 
 
10853 
  thrift_spec = (
10854 
    None, # 0
10855 
    (1, TType.I64, 'warehouseId', None, None, ), # 1
10856 
  )
10857 
 
10858 
  def __init__(self, warehouseId=None,):
10859 
    self.warehouseId = warehouseId
10860 
 
10861 
  def read(self, iprot):
10862 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10863 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10864 
      return
10865 
    iprot.readStructBegin()
10866 
    while True:
10867 
      (fname, ftype, fid) = iprot.readFieldBegin()
10868 
      if ftype == TType.STOP:
10869 
        break
10870 
      if fid == 1:
10871 
        if ftype == TType.I64:
10872 
          self.warehouseId = iprot.readI64();
10873 
        else:
10874 
          iprot.skip(ftype)
10875 
      else:
10876 
        iprot.skip(ftype)
10877 
      iprot.readFieldEnd()
10878 
    iprot.readStructEnd()
10879 
 
10880 
  def write(self, oprot):
10881 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10882 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10883 
      return
10884 
    oprot.writeStructBegin('markAlertsAsSeen_args')
10885 
    if self.warehouseId is not None:
10886 
      oprot.writeFieldBegin('warehouseId', TType.I64, 1)
10887 
      oprot.writeI64(self.warehouseId)
10888 
      oprot.writeFieldEnd()
10889 
    oprot.writeFieldStop()
10890 
    oprot.writeStructEnd()
10891 
 
10892 
  def validate(self):
10893 
    return
10894 
 
10895 
 
10896 
  def __repr__(self):
10897 
    L = ['%s=%r' % (key, value)
10898 
      for key, value in self.__dict__.iteritems()]
10899 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10900 
 
10901 
  def __eq__(self, other):
10902 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10903 
 
10904 
  def __ne__(self, other):
10905 
    return not (self == other)
10906 
 
10907 
class markAlertsAsSeen_result:
10908 
 
10909 
  thrift_spec = (
10910 
  )
10911 
 
10912 
  def read(self, iprot):
10913 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10914 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10915 
      return
10916 
    iprot.readStructBegin()
10917 
    while True:
10918 
      (fname, ftype, fid) = iprot.readFieldBegin()
10919 
      if ftype == TType.STOP:
10920 
        break
10921 
      else:
10922 
        iprot.skip(ftype)
10923 
      iprot.readFieldEnd()
10924 
    iprot.readStructEnd()
10925 
 
10926 
  def write(self, oprot):
10927 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10928 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10929 
      return
10930 
    oprot.writeStructBegin('markAlertsAsSeen_result')
10931 
    oprot.writeFieldStop()
10932 
    oprot.writeStructEnd()
10933 
 
10934 
  def validate(self):
10935 
    return
10936 
 
10937 
 
10938 
  def __repr__(self):
10939 
    L = ['%s=%r' % (key, value)
10940 
      for key, value in self.__dict__.iteritems()]
10941 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10942 
 
10943 
  def __eq__(self, other):
10944 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10945 
 
10946 
  def __ne__(self, other):
10947 
    return not (self == other)
10948 
 
3064 chandransh 10949 
class getValidOrderCount_args:
10950 
 
10951 
  thrift_spec = (
10952 
  )
10953 
 
10954 
  def read(self, iprot):
10955 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10956 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10957 
      return
10958 
    iprot.readStructBegin()
10959 
    while True:
10960 
      (fname, ftype, fid) = iprot.readFieldBegin()
10961 
      if ftype == TType.STOP:
10962 
        break
10963 
      else:
10964 
        iprot.skip(ftype)
10965 
      iprot.readFieldEnd()
10966 
    iprot.readStructEnd()
10967 
 
10968 
  def write(self, oprot):
10969 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10970 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10971 
      return
10972 
    oprot.writeStructBegin('getValidOrderCount_args')
10973 
    oprot.writeFieldStop()
10974 
    oprot.writeStructEnd()
10975 
 
3431 rajveer 10976 
  def validate(self):
10977 
    return
10978 
 
10979 
 
3064 chandransh 10980 
  def __repr__(self):
10981 
    L = ['%s=%r' % (key, value)
10982 
      for key, value in self.__dict__.iteritems()]
10983 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10984 
 
10985 
  def __eq__(self, other):
10986 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10987 
 
10988 
  def __ne__(self, other):
10989 
    return not (self == other)
10990 
 
10991 
class getValidOrderCount_result:
94 ashish 10992 
  """
10993 
  Attributes:
10994 
   - success
10995 
  """
10996 
 
10997 
  thrift_spec = (
3064 chandransh 10998 
    (0, TType.I64, 'success', None, None, ), # 0
94 ashish 10999 
  )
11000 
 
3064 chandransh 11001 
  def __init__(self, success=None,):
94 ashish 11002 
    self.success = success
11003 
 
11004 
  def read(self, iprot):
11005 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11006 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11007 
      return
11008 
    iprot.readStructBegin()
11009 
    while True:
11010 
      (fname, ftype, fid) = iprot.readFieldBegin()
11011 
      if ftype == TType.STOP:
11012 
        break
11013 
      if fid == 0:
3064 chandransh 11014 
        if ftype == TType.I64:
11015 
          self.success = iprot.readI64();
94 ashish 11016 
        else:
11017 
          iprot.skip(ftype)
11018 
      else:
11019 
        iprot.skip(ftype)
11020 
      iprot.readFieldEnd()
11021 
    iprot.readStructEnd()
11022 
 
11023 
  def write(self, oprot):
11024 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11025 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11026 
      return
3064 chandransh 11027 
    oprot.writeStructBegin('getValidOrderCount_result')
3431 rajveer 11028 
    if self.success is not None:
3064 chandransh 11029 
      oprot.writeFieldBegin('success', TType.I64, 0)
11030 
      oprot.writeI64(self.success)
94 ashish 11031 
      oprot.writeFieldEnd()
11032 
    oprot.writeFieldStop()
11033 
    oprot.writeStructEnd()
11034 
 
3431 rajveer 11035 
  def validate(self):
11036 
    return
11037 
 
11038 
 
94 ashish 11039 
  def __repr__(self):
11040 
    L = ['%s=%r' % (key, value)
11041 
      for key, value in self.__dict__.iteritems()]
11042 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11043 
 
11044 
  def __eq__(self, other):
11045 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11046 
 
11047 
  def __ne__(self, other):
11048 
    return not (self == other)
11049 
 
3064 chandransh 11050 
class getNoOfCustomersWithSuccessfulTransaction_args:
11051 
 
11052 
  thrift_spec = (
11053 
  )
11054 
 
11055 
  def read(self, iprot):
11056 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11057 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11058 
      return
11059 
    iprot.readStructBegin()
11060 
    while True:
11061 
      (fname, ftype, fid) = iprot.readFieldBegin()
11062 
      if ftype == TType.STOP:
11063 
        break
11064 
      else:
11065 
        iprot.skip(ftype)
11066 
      iprot.readFieldEnd()
11067 
    iprot.readStructEnd()
11068 
 
11069 
  def write(self, oprot):
11070 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11071 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11072 
      return
11073 
    oprot.writeStructBegin('getNoOfCustomersWithSuccessfulTransaction_args')
11074 
    oprot.writeFieldStop()
11075 
    oprot.writeStructEnd()
11076 
 
3431 rajveer 11077 
  def validate(self):
11078 
    return
11079 
 
11080 
 
3064 chandransh 11081 
  def __repr__(self):
11082 
    L = ['%s=%r' % (key, value)
11083 
      for key, value in self.__dict__.iteritems()]
11084 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11085 
 
11086 
  def __eq__(self, other):
11087 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11088 
 
11089 
  def __ne__(self, other):
11090 
    return not (self == other)
11091 
 
11092 
class getNoOfCustomersWithSuccessfulTransaction_result:
94 ashish 11093 
  """
11094 
  Attributes:
3064 chandransh 11095 
   - success
94 ashish 11096 
  """
11097 
 
11098 
  thrift_spec = (
3064 chandransh 11099 
    (0, TType.I64, 'success', None, None, ), # 0
94 ashish 11100 
  )
11101 
 
3064 chandransh 11102 
  def __init__(self, success=None,):
11103 
    self.success = success
94 ashish 11104 
 
11105 
  def read(self, iprot):
11106 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11107 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11108 
      return
11109 
    iprot.readStructBegin()
11110 
    while True:
11111 
      (fname, ftype, fid) = iprot.readFieldBegin()
11112 
      if ftype == TType.STOP:
11113 
        break
3064 chandransh 11114 
      if fid == 0:
94 ashish 11115 
        if ftype == TType.I64:
3064 chandransh 11116 
          self.success = iprot.readI64();
94 ashish 11117 
        else:
11118 
          iprot.skip(ftype)
11119 
      else:
11120 
        iprot.skip(ftype)
11121 
      iprot.readFieldEnd()
11122 
    iprot.readStructEnd()
11123 
 
11124 
  def write(self, oprot):
11125 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11126 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11127 
      return
3064 chandransh 11128 
    oprot.writeStructBegin('getNoOfCustomersWithSuccessfulTransaction_result')
3431 rajveer 11129 
    if self.success is not None:
3064 chandransh 11130 
      oprot.writeFieldBegin('success', TType.I64, 0)
11131 
      oprot.writeI64(self.success)
94 ashish 11132 
      oprot.writeFieldEnd()
11133 
    oprot.writeFieldStop()
11134 
    oprot.writeStructEnd()
11135 
 
3431 rajveer 11136 
  def validate(self):
11137 
    return
11138 
 
11139 
 
94 ashish 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 
 
3064 chandransh 11151 
class getValidOrdersAmountRange_args:
11152 
 
11153 
  thrift_spec = (
11154 
  )
11155 
 
11156 
  def read(self, iprot):
11157 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11158 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11159 
      return
11160 
    iprot.readStructBegin()
11161 
    while True:
11162 
      (fname, ftype, fid) = iprot.readFieldBegin()
11163 
      if ftype == TType.STOP:
11164 
        break
11165 
      else:
11166 
        iprot.skip(ftype)
11167 
      iprot.readFieldEnd()
11168 
    iprot.readStructEnd()
11169 
 
11170 
  def write(self, oprot):
11171 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11172 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11173 
      return
11174 
    oprot.writeStructBegin('getValidOrdersAmountRange_args')
11175 
    oprot.writeFieldStop()
11176 
    oprot.writeStructEnd()
11177 
 
3431 rajveer 11178 
  def validate(self):
11179 
    return
11180 
 
11181 
 
3064 chandransh 11182 
  def __repr__(self):
11183 
    L = ['%s=%r' % (key, value)
11184 
      for key, value in self.__dict__.iteritems()]
11185 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11186 
 
11187 
  def __eq__(self, other):
11188 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11189 
 
11190 
  def __ne__(self, other):
11191 
    return not (self == other)
11192 
 
11193 
class getValidOrdersAmountRange_result:
94 ashish 11194 
  """
11195 
  Attributes:
11196 
   - success
11197 
  """
11198 
 
11199 
  thrift_spec = (
3064 chandransh 11200 
    (0, TType.LIST, 'success', (TType.DOUBLE,None), None, ), # 0
94 ashish 11201 
  )
11202 
 
3064 chandransh 11203 
  def __init__(self, success=None,):
94 ashish 11204 
    self.success = success
11205 
 
11206 
  def read(self, iprot):
11207 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11208 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11209 
      return
11210 
    iprot.readStructBegin()
11211 
    while True:
11212 
      (fname, ftype, fid) = iprot.readFieldBegin()
11213 
      if ftype == TType.STOP:
11214 
        break
11215 
      if fid == 0:
483 rajveer 11216 
        if ftype == TType.LIST:
11217 
          self.success = []
5386 phani.kuma 11218 
          (_etype206, _size203) = iprot.readListBegin()
11219 
          for _i207 in xrange(_size203):
11220 
            _elem208 = iprot.readDouble();
11221 
            self.success.append(_elem208)
483 rajveer 11222 
          iprot.readListEnd()
94 ashish 11223 
        else:
11224 
          iprot.skip(ftype)
11225 
      else:
11226 
        iprot.skip(ftype)
11227 
      iprot.readFieldEnd()
11228 
    iprot.readStructEnd()
11229 
 
11230 
  def write(self, oprot):
11231 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11232 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11233 
      return
3064 chandransh 11234 
    oprot.writeStructBegin('getValidOrdersAmountRange_result')
3431 rajveer 11235 
    if self.success is not None:
483 rajveer 11236 
      oprot.writeFieldBegin('success', TType.LIST, 0)
3064 chandransh 11237 
      oprot.writeListBegin(TType.DOUBLE, len(self.success))
5386 phani.kuma 11238 
      for iter209 in self.success:
11239 
        oprot.writeDouble(iter209)
483 rajveer 11240 
      oprot.writeListEnd()
94 ashish 11241 
      oprot.writeFieldEnd()
11242 
    oprot.writeFieldStop()
11243 
    oprot.writeStructEnd()
11244 
 
3431 rajveer 11245 
  def validate(self):
11246 
    return
11247 
 
11248 
 
94 ashish 11249 
  def __repr__(self):
11250 
    L = ['%s=%r' % (key, value)
11251 
      for key, value in self.__dict__.iteritems()]
11252 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11253 
 
11254 
  def __eq__(self, other):
11255 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11256 
 
11257 
  def __ne__(self, other):
11258 
    return not (self == other)
11259 
 
3064 chandransh 11260 
class getValidOrders_args:
1528 ankur.sing 11261 
  """
11262 
  Attributes:
3064 chandransh 11263 
   - limit
1528 ankur.sing 11264 
  """
11265 
 
11266 
  thrift_spec = (
11267 
    None, # 0
3064 chandransh 11268 
    (1, TType.I64, 'limit', None, None, ), # 1
1528 ankur.sing 11269 
  )
11270 
 
3064 chandransh 11271 
  def __init__(self, limit=None,):
11272 
    self.limit = limit
1528 ankur.sing 11273 
 
11274 
  def read(self, iprot):
11275 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11276 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11277 
      return
11278 
    iprot.readStructBegin()
11279 
    while True:
11280 
      (fname, ftype, fid) = iprot.readFieldBegin()
11281 
      if ftype == TType.STOP:
11282 
        break
11283 
      if fid == 1:
11284 
        if ftype == TType.I64:
3064 chandransh 11285 
          self.limit = iprot.readI64();
1528 ankur.sing 11286 
        else:
11287 
          iprot.skip(ftype)
11288 
      else:
11289 
        iprot.skip(ftype)
11290 
      iprot.readFieldEnd()
11291 
    iprot.readStructEnd()
11292 
 
11293 
  def write(self, oprot):
11294 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11295 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11296 
      return
3064 chandransh 11297 
    oprot.writeStructBegin('getValidOrders_args')
3431 rajveer 11298 
    if self.limit is not None:
3064 chandransh 11299 
      oprot.writeFieldBegin('limit', TType.I64, 1)
11300 
      oprot.writeI64(self.limit)
1528 ankur.sing 11301 
      oprot.writeFieldEnd()
11302 
    oprot.writeFieldStop()
11303 
    oprot.writeStructEnd()
11304 
 
3431 rajveer 11305 
  def validate(self):
11306 
    return
11307 
 
11308 
 
1528 ankur.sing 11309 
  def __repr__(self):
11310 
    L = ['%s=%r' % (key, value)
11311 
      for key, value in self.__dict__.iteritems()]
11312 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11313 
 
11314 
  def __eq__(self, other):
11315 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11316 
 
11317 
  def __ne__(self, other):
11318 
    return not (self == other)
11319 
 
3064 chandransh 11320 
class getValidOrders_result:
1528 ankur.sing 11321 
  """
11322 
  Attributes:
11323 
   - success
11324 
  """
11325 
 
11326 
  thrift_spec = (
3064 chandransh 11327 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
1528 ankur.sing 11328 
  )
11329 
 
3064 chandransh 11330 
  def __init__(self, success=None,):
1528 ankur.sing 11331 
    self.success = success
11332 
 
11333 
  def read(self, iprot):
11334 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11335 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11336 
      return
11337 
    iprot.readStructBegin()
11338 
    while True:
11339 
      (fname, ftype, fid) = iprot.readFieldBegin()
11340 
      if ftype == TType.STOP:
11341 
        break
11342 
      if fid == 0:
3064 chandransh 11343 
        if ftype == TType.LIST:
11344 
          self.success = []
5386 phani.kuma 11345 
          (_etype213, _size210) = iprot.readListBegin()
11346 
          for _i214 in xrange(_size210):
11347 
            _elem215 = Order()
11348 
            _elem215.read(iprot)
11349 
            self.success.append(_elem215)
3064 chandransh 11350 
          iprot.readListEnd()
1528 ankur.sing 11351 
        else:
11352 
          iprot.skip(ftype)
11353 
      else:
11354 
        iprot.skip(ftype)
11355 
      iprot.readFieldEnd()
11356 
    iprot.readStructEnd()
11357 
 
11358 
  def write(self, oprot):
11359 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11360 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11361 
      return
3064 chandransh 11362 
    oprot.writeStructBegin('getValidOrders_result')
3431 rajveer 11363 
    if self.success is not None:
3064 chandransh 11364 
      oprot.writeFieldBegin('success', TType.LIST, 0)
11365 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
5386 phani.kuma 11366 
      for iter216 in self.success:
11367 
        iter216.write(oprot)
3064 chandransh 11368 
      oprot.writeListEnd()
1528 ankur.sing 11369 
      oprot.writeFieldEnd()
11370 
    oprot.writeFieldStop()
11371 
    oprot.writeStructEnd()
11372 
 
3431 rajveer 11373 
  def validate(self):
11374 
    return
11375 
 
11376 
 
1528 ankur.sing 11377 
  def __repr__(self):
11378 
    L = ['%s=%r' % (key, value)
11379 
      for key, value in self.__dict__.iteritems()]
11380 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11381 
 
11382 
  def __eq__(self, other):
11383 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11384 
 
11385 
  def __ne__(self, other):
11386 
    return not (self == other)
11387 
 
1220 chandransh 11388 
class batchOrders_args:
11389 
  """
11390 
  Attributes:
11391 
   - warehouseId
11392 
  """
11393 
 
11394 
  thrift_spec = (
11395 
    None, # 0
11396 
    (1, TType.I64, 'warehouseId', None, None, ), # 1
11397 
  )
11398 
 
11399 
  def __init__(self, warehouseId=None,):
11400 
    self.warehouseId = warehouseId
11401 
 
11402 
  def read(self, iprot):
11403 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11404 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11405 
      return
11406 
    iprot.readStructBegin()
11407 
    while True:
11408 
      (fname, ftype, fid) = iprot.readFieldBegin()
11409 
      if ftype == TType.STOP:
11410 
        break
11411 
      if fid == 1:
11412 
        if ftype == TType.I64:
11413 
          self.warehouseId = iprot.readI64();
11414 
        else:
11415 
          iprot.skip(ftype)
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
11425 
    oprot.writeStructBegin('batchOrders_args')
3431 rajveer 11426 
    if self.warehouseId is not None:
1220 chandransh 11427 
      oprot.writeFieldBegin('warehouseId', TType.I64, 1)
11428 
      oprot.writeI64(self.warehouseId)
11429 
      oprot.writeFieldEnd()
11430 
    oprot.writeFieldStop()
11431 
    oprot.writeStructEnd()
11432 
 
3431 rajveer 11433 
  def validate(self):
11434 
    return
11435 
 
11436 
 
1220 chandransh 11437 
  def __repr__(self):
11438 
    L = ['%s=%r' % (key, value)
11439 
      for key, value in self.__dict__.iteritems()]
11440 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11441 
 
11442 
  def __eq__(self, other):
11443 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11444 
 
11445 
  def __ne__(self, other):
11446 
    return not (self == other)
11447 
 
11448 
class batchOrders_result:
11449 
  """
11450 
  Attributes:
11451 
   - success
11452 
   - ex
11453 
  """
11454 
 
11455 
  thrift_spec = (
11456 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
11457 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
11458 
  )
11459 
 
11460 
  def __init__(self, success=None, ex=None,):
11461 
    self.success = success
11462 
    self.ex = ex
11463 
 
11464 
  def read(self, iprot):
11465 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11466 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11467 
      return
11468 
    iprot.readStructBegin()
11469 
    while True:
11470 
      (fname, ftype, fid) = iprot.readFieldBegin()
11471 
      if ftype == TType.STOP:
11472 
        break
11473 
      if fid == 0:
11474 
        if ftype == TType.LIST:
11475 
          self.success = []
5386 phani.kuma 11476 
          (_etype220, _size217) = iprot.readListBegin()
11477 
          for _i221 in xrange(_size217):
11478 
            _elem222 = Order()
11479 
            _elem222.read(iprot)
11480 
            self.success.append(_elem222)
1220 chandransh 11481 
          iprot.readListEnd()
11482 
        else:
11483 
          iprot.skip(ftype)
11484 
      elif fid == 1:
11485 
        if ftype == TType.STRUCT:
11486 
          self.ex = TransactionServiceException()
11487 
          self.ex.read(iprot)
11488 
        else:
11489 
          iprot.skip(ftype)
11490 
      else:
11491 
        iprot.skip(ftype)
11492 
      iprot.readFieldEnd()
11493 
    iprot.readStructEnd()
11494 
 
11495 
  def write(self, oprot):
11496 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11497 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11498 
      return
11499 
    oprot.writeStructBegin('batchOrders_result')
3431 rajveer 11500 
    if self.success is not None:
1220 chandransh 11501 
      oprot.writeFieldBegin('success', TType.LIST, 0)
11502 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
5386 phani.kuma 11503 
      for iter223 in self.success:
11504 
        iter223.write(oprot)
1220 chandransh 11505 
      oprot.writeListEnd()
11506 
      oprot.writeFieldEnd()
3431 rajveer 11507 
    if self.ex is not None:
1220 chandransh 11508 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
11509 
      self.ex.write(oprot)
11510 
      oprot.writeFieldEnd()
11511 
    oprot.writeFieldStop()
11512 
    oprot.writeStructEnd()
11513 
 
3431 rajveer 11514 
  def validate(self):
11515 
    return
11516 
 
11517 
 
1220 chandransh 11518 
  def __repr__(self):
11519 
    L = ['%s=%r' % (key, value)
11520 
      for key, value in self.__dict__.iteritems()]
11521 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11522 
 
11523 
  def __eq__(self, other):
11524 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11525 
 
11526 
  def __ne__(self, other):
11527 
    return not (self == other)
11528 
 
1208 chandransh 11529 
class markOrderAsOutOfStock_args:
11530 
  """
11531 
  Attributes:
11532 
   - orderId
11533 
  """
11534 
 
11535 
  thrift_spec = (
11536 
    None, # 0
11537 
    (1, TType.I64, 'orderId', None, None, ), # 1
11538 
  )
11539 
 
11540 
  def __init__(self, orderId=None,):
11541 
    self.orderId = orderId
11542 
 
11543 
  def read(self, iprot):
11544 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11545 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11546 
      return
11547 
    iprot.readStructBegin()
11548 
    while True:
11549 
      (fname, ftype, fid) = iprot.readFieldBegin()
11550 
      if ftype == TType.STOP:
11551 
        break
11552 
      if fid == 1:
11553 
        if ftype == TType.I64:
11554 
          self.orderId = iprot.readI64();
11555 
        else:
11556 
          iprot.skip(ftype)
11557 
      else:
11558 
        iprot.skip(ftype)
11559 
      iprot.readFieldEnd()
11560 
    iprot.readStructEnd()
11561 
 
11562 
  def write(self, oprot):
11563 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11564 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11565 
      return
11566 
    oprot.writeStructBegin('markOrderAsOutOfStock_args')
3431 rajveer 11567 
    if self.orderId is not None:
1208 chandransh 11568 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
11569 
      oprot.writeI64(self.orderId)
11570 
      oprot.writeFieldEnd()
11571 
    oprot.writeFieldStop()
11572 
    oprot.writeStructEnd()
11573 
 
3431 rajveer 11574 
  def validate(self):
11575 
    return
11576 
 
11577 
 
1208 chandransh 11578 
  def __repr__(self):
11579 
    L = ['%s=%r' % (key, value)
11580 
      for key, value in self.__dict__.iteritems()]
11581 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11582 
 
11583 
  def __eq__(self, other):
11584 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11585 
 
11586 
  def __ne__(self, other):
11587 
    return not (self == other)
11588 
 
11589 
class markOrderAsOutOfStock_result:
11590 
  """
11591 
  Attributes:
11592 
   - success
11593 
   - ex
11594 
  """
11595 
 
11596 
  thrift_spec = (
11597 
    (0, TType.BOOL, 'success', None, None, ), # 0
11598 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
11599 
  )
11600 
 
11601 
  def __init__(self, success=None, ex=None,):
11602 
    self.success = success
11603 
    self.ex = ex
11604 
 
11605 
  def read(self, iprot):
11606 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11607 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11608 
      return
11609 
    iprot.readStructBegin()
11610 
    while True:
11611 
      (fname, ftype, fid) = iprot.readFieldBegin()
11612 
      if ftype == TType.STOP:
11613 
        break
11614 
      if fid == 0:
11615 
        if ftype == TType.BOOL:
11616 
          self.success = iprot.readBool();
11617 
        else:
11618 
          iprot.skip(ftype)
11619 
      elif fid == 1:
11620 
        if ftype == TType.STRUCT:
11621 
          self.ex = TransactionServiceException()
11622 
          self.ex.read(iprot)
11623 
        else:
11624 
          iprot.skip(ftype)
11625 
      else:
11626 
        iprot.skip(ftype)
11627 
      iprot.readFieldEnd()
11628 
    iprot.readStructEnd()
11629 
 
11630 
  def write(self, oprot):
11631 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11632 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11633 
      return
11634 
    oprot.writeStructBegin('markOrderAsOutOfStock_result')
3431 rajveer 11635 
    if self.success is not None:
1208 chandransh 11636 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
11637 
      oprot.writeBool(self.success)
11638 
      oprot.writeFieldEnd()
3431 rajveer 11639 
    if self.ex is not None:
1208 chandransh 11640 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
11641 
      self.ex.write(oprot)
11642 
      oprot.writeFieldEnd()
11643 
    oprot.writeFieldStop()
11644 
    oprot.writeStructEnd()
11645 
 
3431 rajveer 11646 
  def validate(self):
11647 
    return
11648 
 
11649 
 
1208 chandransh 11650 
  def __repr__(self):
11651 
    L = ['%s=%r' % (key, value)
11652 
      for key, value in self.__dict__.iteritems()]
11653 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11654 
 
11655 
  def __eq__(self, other):
11656 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11657 
 
11658 
  def __ne__(self, other):
11659 
    return not (self == other)
11660 
 
3064 chandransh 11661 
class verifyOrder_args:
759 chandransh 11662 
  """
11663 
  Attributes:
3064 chandransh 11664 
   - orderId
759 chandransh 11665 
  """
11666 
 
11667 
  thrift_spec = (
11668 
    None, # 0
3064 chandransh 11669 
    (1, TType.I64, 'orderId', None, None, ), # 1
759 chandransh 11670 
  )
11671 
 
3064 chandransh 11672 
  def __init__(self, orderId=None,):
11673 
    self.orderId = orderId
759 chandransh 11674 
 
11675 
  def read(self, iprot):
11676 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11677 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11678 
      return
11679 
    iprot.readStructBegin()
11680 
    while True:
11681 
      (fname, ftype, fid) = iprot.readFieldBegin()
11682 
      if ftype == TType.STOP:
11683 
        break
11684 
      if fid == 1:
11685 
        if ftype == TType.I64:
3064 chandransh 11686 
          self.orderId = iprot.readI64();
759 chandransh 11687 
        else:
11688 
          iprot.skip(ftype)
11689 
      else:
11690 
        iprot.skip(ftype)
11691 
      iprot.readFieldEnd()
11692 
    iprot.readStructEnd()
11693 
 
11694 
  def write(self, oprot):
11695 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11696 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11697 
      return
3064 chandransh 11698 
    oprot.writeStructBegin('verifyOrder_args')
3431 rajveer 11699 
    if self.orderId is not None:
3064 chandransh 11700 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
11701 
      oprot.writeI64(self.orderId)
759 chandransh 11702 
      oprot.writeFieldEnd()
11703 
    oprot.writeFieldStop()
11704 
    oprot.writeStructEnd()
11705 
 
3431 rajveer 11706 
  def validate(self):
11707 
    return
11708 
 
11709 
 
759 chandransh 11710 
  def __repr__(self):
11711 
    L = ['%s=%r' % (key, value)
11712 
      for key, value in self.__dict__.iteritems()]
11713 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11714 
 
11715 
  def __eq__(self, other):
11716 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11717 
 
11718 
  def __ne__(self, other):
11719 
    return not (self == other)
11720 
 
3064 chandransh 11721 
class verifyOrder_result:
759 chandransh 11722 
  """
11723 
  Attributes:
11724 
   - success
11725 
   - ex
11726 
  """
11727 
 
11728 
  thrift_spec = (
11729 
    (0, TType.BOOL, 'success', None, None, ), # 0
11730 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
11731 
  )
11732 
 
11733 
  def __init__(self, success=None, ex=None,):
11734 
    self.success = success
11735 
    self.ex = ex
11736 
 
11737 
  def read(self, iprot):
11738 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11739 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11740 
      return
11741 
    iprot.readStructBegin()
11742 
    while True:
11743 
      (fname, ftype, fid) = iprot.readFieldBegin()
11744 
      if ftype == TType.STOP:
11745 
        break
11746 
      if fid == 0:
11747 
        if ftype == TType.BOOL:
11748 
          self.success = iprot.readBool();
11749 
        else:
11750 
          iprot.skip(ftype)
11751 
      elif fid == 1:
11752 
        if ftype == TType.STRUCT:
11753 
          self.ex = TransactionServiceException()
11754 
          self.ex.read(iprot)
11755 
        else:
11756 
          iprot.skip(ftype)
11757 
      else:
11758 
        iprot.skip(ftype)
11759 
      iprot.readFieldEnd()
11760 
    iprot.readStructEnd()
11761 
 
11762 
  def write(self, oprot):
11763 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11764 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11765 
      return
3064 chandransh 11766 
    oprot.writeStructBegin('verifyOrder_result')
3431 rajveer 11767 
    if self.success is not None:
759 chandransh 11768 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
11769 
      oprot.writeBool(self.success)
11770 
      oprot.writeFieldEnd()
3431 rajveer 11771 
    if self.ex is not None:
759 chandransh 11772 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
11773 
      self.ex.write(oprot)
11774 
      oprot.writeFieldEnd()
11775 
    oprot.writeFieldStop()
11776 
    oprot.writeStructEnd()
11777 
 
3431 rajveer 11778 
  def validate(self):
11779 
    return
11780 
 
11781 
 
759 chandransh 11782 
  def __repr__(self):
11783 
    L = ['%s=%r' % (key, value)
11784 
      for key, value in self.__dict__.iteritems()]
11785 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11786 
 
11787 
  def __eq__(self, other):
11788 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11789 
 
11790 
  def __ne__(self, other):
11791 
    return not (self == other)
11792 
 
3064 chandransh 11793 
class acceptOrder_args:
1113 chandransh 11794 
  """
11795 
  Attributes:
3064 chandransh 11796 
   - orderId
1113 chandransh 11797 
  """
11798 
 
11799 
  thrift_spec = (
11800 
    None, # 0
3064 chandransh 11801 
    (1, TType.I64, 'orderId', None, None, ), # 1
1113 chandransh 11802 
  )
11803 
 
3064 chandransh 11804 
  def __init__(self, orderId=None,):
11805 
    self.orderId = orderId
1113 chandransh 11806 
 
11807 
  def read(self, iprot):
11808 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11809 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11810 
      return
11811 
    iprot.readStructBegin()
11812 
    while True:
11813 
      (fname, ftype, fid) = iprot.readFieldBegin()
11814 
      if ftype == TType.STOP:
11815 
        break
11816 
      if fid == 1:
11817 
        if ftype == TType.I64:
3064 chandransh 11818 
          self.orderId = iprot.readI64();
1113 chandransh 11819 
        else:
11820 
          iprot.skip(ftype)
11821 
      else:
11822 
        iprot.skip(ftype)
11823 
      iprot.readFieldEnd()
11824 
    iprot.readStructEnd()
11825 
 
11826 
  def write(self, oprot):
11827 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11828 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11829 
      return
3064 chandransh 11830 
    oprot.writeStructBegin('acceptOrder_args')
3431 rajveer 11831 
    if self.orderId is not None:
3064 chandransh 11832 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
11833 
      oprot.writeI64(self.orderId)
1113 chandransh 11834 
      oprot.writeFieldEnd()
11835 
    oprot.writeFieldStop()
11836 
    oprot.writeStructEnd()
11837 
 
3431 rajveer 11838 
  def validate(self):
11839 
    return
11840 
 
11841 
 
1113 chandransh 11842 
  def __repr__(self):
11843 
    L = ['%s=%r' % (key, value)
11844 
      for key, value in self.__dict__.iteritems()]
11845 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11846 
 
11847 
  def __eq__(self, other):
11848 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11849 
 
11850 
  def __ne__(self, other):
11851 
    return not (self == other)
11852 
 
3064 chandransh 11853 
class acceptOrder_result:
1113 chandransh 11854 
  """
11855 
  Attributes:
11856 
   - success
11857 
   - ex
11858 
  """
11859 
 
11860 
  thrift_spec = (
3064 chandransh 11861 
    (0, TType.BOOL, 'success', None, None, ), # 0
1113 chandransh 11862 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
11863 
  )
11864 
 
11865 
  def __init__(self, success=None, ex=None,):
11866 
    self.success = success
11867 
    self.ex = ex
11868 
 
11869 
  def read(self, iprot):
11870 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11871 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11872 
      return
11873 
    iprot.readStructBegin()
11874 
    while True:
11875 
      (fname, ftype, fid) = iprot.readFieldBegin()
11876 
      if ftype == TType.STOP:
11877 
        break
11878 
      if fid == 0:
3064 chandransh 11879 
        if ftype == TType.BOOL:
11880 
          self.success = iprot.readBool();
1113 chandransh 11881 
        else:
11882 
          iprot.skip(ftype)
11883 
      elif fid == 1:
11884 
        if ftype == TType.STRUCT:
11885 
          self.ex = TransactionServiceException()
11886 
          self.ex.read(iprot)
11887 
        else:
11888 
          iprot.skip(ftype)
11889 
      else:
11890 
        iprot.skip(ftype)
11891 
      iprot.readFieldEnd()
11892 
    iprot.readStructEnd()
11893 
 
11894 
  def write(self, oprot):
11895 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11896 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11897 
      return
3064 chandransh 11898 
    oprot.writeStructBegin('acceptOrder_result')
3431 rajveer 11899 
    if self.success is not None:
3064 chandransh 11900 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
11901 
      oprot.writeBool(self.success)
1113 chandransh 11902 
      oprot.writeFieldEnd()
3431 rajveer 11903 
    if self.ex is not None:
1113 chandransh 11904 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
11905 
      self.ex.write(oprot)
11906 
      oprot.writeFieldEnd()
11907 
    oprot.writeFieldStop()
11908 
    oprot.writeStructEnd()
11909 
 
3431 rajveer 11910 
  def validate(self):
11911 
    return
11912 
 
11913 
 
1113 chandransh 11914 
  def __repr__(self):
11915 
    L = ['%s=%r' % (key, value)
11916 
      for key, value in self.__dict__.iteritems()]
11917 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11918 
 
11919 
  def __eq__(self, other):
11920 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11921 
 
11922 
  def __ne__(self, other):
11923 
    return not (self == other)
11924 
 
3064 chandransh 11925 
class addBillingDetails_args:
1135 chandransh 11926 
  """
11927 
  Attributes:
3064 chandransh 11928 
   - orderId
11929 
   - invoice_number
4658 mandeep.dh 11930 
   - serialNumber
4283 anupam.sin 11931 
   - itemNumber
3064 chandransh 11932 
   - billed_by
4264 rajveer 11933 
   - jacketNumber
4283 anupam.sin 11934 
   - billingType
5110 mandeep.dh 11935 
   - fulfilmentWarehouseId
4763 rajveer 11936 
   - authorize
1135 chandransh 11937 
  """
11938 
 
11939 
  thrift_spec = (
11940 
    None, # 0
3064 chandransh 11941 
    (1, TType.I64, 'orderId', None, None, ), # 1
11942 
    (2, TType.STRING, 'invoice_number', None, None, ), # 2
5411 rajveer 11943 
    (3, TType.LIST, 'serialNumber', (TType.STRING,None), None, ), # 3
11944 
    (4, TType.LIST, 'itemNumber', (TType.STRING,None), None, ), # 4
4283 anupam.sin 11945 
    (5, TType.STRING, 'billed_by', None, None, ), # 5
11946 
    (6, TType.I64, 'jacketNumber', None, None, ), # 6
11947 
    (7, TType.I64, 'billingType', None, None, ), # 7
5110 mandeep.dh 11948 
    (8, TType.I64, 'fulfilmentWarehouseId', None, None, ), # 8
4763 rajveer 11949 
    (9, TType.BOOL, 'authorize', None, None, ), # 9
1135 chandransh 11950 
  )
11951 
 
5110 mandeep.dh 11952 
  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 11953 
    self.orderId = orderId
11954 
    self.invoice_number = invoice_number
4658 mandeep.dh 11955 
    self.serialNumber = serialNumber
4283 anupam.sin 11956 
    self.itemNumber = itemNumber
3064 chandransh 11957 
    self.billed_by = billed_by
4264 rajveer 11958 
    self.jacketNumber = jacketNumber
4283 anupam.sin 11959 
    self.billingType = billingType
5110 mandeep.dh 11960 
    self.fulfilmentWarehouseId = fulfilmentWarehouseId
4763 rajveer 11961 
    self.authorize = authorize
1135 chandransh 11962 
 
11963 
  def read(self, iprot):
11964 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11965 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11966 
      return
11967 
    iprot.readStructBegin()
11968 
    while True:
11969 
      (fname, ftype, fid) = iprot.readFieldBegin()
11970 
      if ftype == TType.STOP:
11971 
        break
11972 
      if fid == 1:
11973 
        if ftype == TType.I64:
3064 chandransh 11974 
          self.orderId = iprot.readI64();
1135 chandransh 11975 
        else:
11976 
          iprot.skip(ftype)
11977 
      elif fid == 2:
3064 chandransh 11978 
        if ftype == TType.STRING:
11979 
          self.invoice_number = iprot.readString();
1135 chandransh 11980 
        else:
11981 
          iprot.skip(ftype)
3064 chandransh 11982 
      elif fid == 3:
5411 rajveer 11983 
        if ftype == TType.LIST:
11984 
          self.serialNumber = []
11985 
          (_etype227, _size224) = iprot.readListBegin()
11986 
          for _i228 in xrange(_size224):
11987 
            _elem229 = iprot.readString();
11988 
            self.serialNumber.append(_elem229)
11989 
          iprot.readListEnd()
3064 chandransh 11990 
        else:
11991 
          iprot.skip(ftype)
11992 
      elif fid == 4:
5411 rajveer 11993 
        if ftype == TType.LIST:
11994 
          self.itemNumber = []
11995 
          (_etype233, _size230) = iprot.readListBegin()
11996 
          for _i234 in xrange(_size230):
11997 
            _elem235 = iprot.readString();
11998 
            self.itemNumber.append(_elem235)
11999 
          iprot.readListEnd()
3064 chandransh 12000 
        else:
12001 
          iprot.skip(ftype)
12002 
      elif fid == 5:
12003 
        if ftype == TType.STRING:
4283 anupam.sin 12004 
          self.billed_by = iprot.readString();
3064 chandransh 12005 
        else:
12006 
          iprot.skip(ftype)
12007 
      elif fid == 6:
12008 
        if ftype == TType.I64:
4283 anupam.sin 12009 
          self.jacketNumber = iprot.readI64();
12010 
        else:
12011 
          iprot.skip(ftype)
12012 
      elif fid == 7:
12013 
        if ftype == TType.I64:
3064 chandransh 12014 
          self.billingType = iprot.readI64();
12015 
        else:
12016 
          iprot.skip(ftype)
4283 anupam.sin 12017 
      elif fid == 8:
12018 
        if ftype == TType.I64:
5110 mandeep.dh 12019 
          self.fulfilmentWarehouseId = iprot.readI64();
4283 anupam.sin 12020 
        else:
12021 
          iprot.skip(ftype)
4763 rajveer 12022 
      elif fid == 9:
12023 
        if ftype == TType.BOOL:
12024 
          self.authorize = iprot.readBool();
12025 
        else:
12026 
          iprot.skip(ftype)
1246 chandransh 12027 
      else:
12028 
        iprot.skip(ftype)
12029 
      iprot.readFieldEnd()
12030 
    iprot.readStructEnd()
12031 
 
12032 
  def write(self, oprot):
12033 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12034 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12035 
      return
4283 anupam.sin 12036 
    oprot.writeStructBegin('addBillingDetails_args')
3431 rajveer 12037 
    if self.orderId is not None:
3064 chandransh 12038 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
12039 
      oprot.writeI64(self.orderId)
1246 chandransh 12040 
      oprot.writeFieldEnd()
4283 anupam.sin 12041 
    if self.invoice_number is not None:
12042 
      oprot.writeFieldBegin('invoice_number', TType.STRING, 2)
12043 
      oprot.writeString(self.invoice_number)
1246 chandransh 12044 
      oprot.writeFieldEnd()
4658 mandeep.dh 12045 
    if self.serialNumber is not None:
5411 rajveer 12046 
      oprot.writeFieldBegin('serialNumber', TType.LIST, 3)
12047 
      oprot.writeListBegin(TType.STRING, len(self.serialNumber))
12048 
      for iter236 in self.serialNumber:
12049 
        oprot.writeString(iter236)
12050 
      oprot.writeListEnd()
3064 chandransh 12051 
      oprot.writeFieldEnd()
3431 rajveer 12052 
    if self.itemNumber is not None:
5411 rajveer 12053 
      oprot.writeFieldBegin('itemNumber', TType.LIST, 4)
12054 
      oprot.writeListBegin(TType.STRING, len(self.itemNumber))
12055 
      for iter237 in self.itemNumber:
12056 
        oprot.writeString(iter237)
12057 
      oprot.writeListEnd()
3064 chandransh 12058 
      oprot.writeFieldEnd()
4283 anupam.sin 12059 
    if self.billed_by is not None:
12060 
      oprot.writeFieldBegin('billed_by', TType.STRING, 5)
12061 
      oprot.writeString(self.billed_by)
3064 chandransh 12062 
      oprot.writeFieldEnd()
4283 anupam.sin 12063 
    if self.jacketNumber is not None:
12064 
      oprot.writeFieldBegin('jacketNumber', TType.I64, 6)
12065 
      oprot.writeI64(self.jacketNumber)
12066 
      oprot.writeFieldEnd()
3431 rajveer 12067 
    if self.billingType is not None:
4283 anupam.sin 12068 
      oprot.writeFieldBegin('billingType', TType.I64, 7)
3064 chandransh 12069 
      oprot.writeI64(self.billingType)
12070 
      oprot.writeFieldEnd()
5110 mandeep.dh 12071 
    if self.fulfilmentWarehouseId is not None:
12072 
      oprot.writeFieldBegin('fulfilmentWarehouseId', TType.I64, 8)
12073 
      oprot.writeI64(self.fulfilmentWarehouseId)
4283 anupam.sin 12074 
      oprot.writeFieldEnd()
4763 rajveer 12075 
    if self.authorize is not None:
12076 
      oprot.writeFieldBegin('authorize', TType.BOOL, 9)
12077 
      oprot.writeBool(self.authorize)
12078 
      oprot.writeFieldEnd()
1246 chandransh 12079 
    oprot.writeFieldStop()
12080 
    oprot.writeStructEnd()
12081 
 
3431 rajveer 12082 
  def validate(self):
12083 
    return
12084 
 
12085 
 
1246 chandransh 12086 
  def __repr__(self):
12087 
    L = ['%s=%r' % (key, value)
12088 
      for key, value in self.__dict__.iteritems()]
12089 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12090 
 
12091 
  def __eq__(self, other):
12092 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12093 
 
12094 
  def __ne__(self, other):
12095 
    return not (self == other)
12096 
 
4283 anupam.sin 12097 
class addBillingDetails_result:
1246 chandransh 12098 
  """
12099 
  Attributes:
3064 chandransh 12100 
   - success
1246 chandransh 12101 
   - ex
12102 
  """
12103 
 
12104 
  thrift_spec = (
3064 chandransh 12105 
    (0, TType.BOOL, 'success', None, None, ), # 0
1246 chandransh 12106 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
12107 
  )
12108 
 
3064 chandransh 12109 
  def __init__(self, success=None, ex=None,):
12110 
    self.success = success
1246 chandransh 12111 
    self.ex = ex
12112 
 
12113 
  def read(self, iprot):
12114 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12115 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12116 
      return
12117 
    iprot.readStructBegin()
12118 
    while True:
12119 
      (fname, ftype, fid) = iprot.readFieldBegin()
12120 
      if ftype == TType.STOP:
12121 
        break
3064 chandransh 12122 
      if fid == 0:
12123 
        if ftype == TType.BOOL:
12124 
          self.success = iprot.readBool();
12125 
        else:
12126 
          iprot.skip(ftype)
12127 
      elif fid == 1:
1246 chandransh 12128 
        if ftype == TType.STRUCT:
12129 
          self.ex = TransactionServiceException()
12130 
          self.ex.read(iprot)
12131 
        else:
12132 
          iprot.skip(ftype)
12133 
      else:
12134 
        iprot.skip(ftype)
12135 
      iprot.readFieldEnd()
12136 
    iprot.readStructEnd()
12137 
 
12138 
  def write(self, oprot):
12139 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12140 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12141 
      return
4283 anupam.sin 12142 
    oprot.writeStructBegin('addBillingDetails_result')
3431 rajveer 12143 
    if self.success is not None:
3064 chandransh 12144 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
12145 
      oprot.writeBool(self.success)
12146 
      oprot.writeFieldEnd()
3431 rajveer 12147 
    if self.ex is not None:
1246 chandransh 12148 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
12149 
      self.ex.write(oprot)
12150 
      oprot.writeFieldEnd()
12151 
    oprot.writeFieldStop()
12152 
    oprot.writeStructEnd()
12153 
 
3431 rajveer 12154 
  def validate(self):
12155 
    return
12156 
 
12157 
 
1246 chandransh 12158 
  def __repr__(self):
12159 
    L = ['%s=%r' % (key, value)
12160 
      for key, value in self.__dict__.iteritems()]
12161 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12162 
 
12163 
  def __eq__(self, other):
12164 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12165 
 
12166 
  def __ne__(self, other):
12167 
    return not (self == other)
12168 
 
4579 rajveer 12169 
class addInvoiceNumber_args:
12170 
  """
12171 
  Attributes:
12172 
   - orderId
12173 
   - invoiceNumber
4763 rajveer 12174 
   - color
4579 rajveer 12175 
  """
12176 
 
12177 
  thrift_spec = (
12178 
    None, # 0
12179 
    (1, TType.I64, 'orderId', None, None, ), # 1
12180 
    (2, TType.STRING, 'invoiceNumber', None, None, ), # 2
4763 rajveer 12181 
    (3, TType.STRING, 'color', None, None, ), # 3
4579 rajveer 12182 
  )
12183 
 
4763 rajveer 12184 
  def __init__(self, orderId=None, invoiceNumber=None, color=None,):
4579 rajveer 12185 
    self.orderId = orderId
12186 
    self.invoiceNumber = invoiceNumber
4763 rajveer 12187 
    self.color = color
4579 rajveer 12188 
 
12189 
  def read(self, iprot):
12190 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12191 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12192 
      return
12193 
    iprot.readStructBegin()
12194 
    while True:
12195 
      (fname, ftype, fid) = iprot.readFieldBegin()
12196 
      if ftype == TType.STOP:
12197 
        break
12198 
      if fid == 1:
12199 
        if ftype == TType.I64:
12200 
          self.orderId = iprot.readI64();
12201 
        else:
12202 
          iprot.skip(ftype)
12203 
      elif fid == 2:
12204 
        if ftype == TType.STRING:
12205 
          self.invoiceNumber = iprot.readString();
12206 
        else:
12207 
          iprot.skip(ftype)
4763 rajveer 12208 
      elif fid == 3:
12209 
        if ftype == TType.STRING:
12210 
          self.color = iprot.readString();
12211 
        else:
12212 
          iprot.skip(ftype)
4579 rajveer 12213 
      else:
12214 
        iprot.skip(ftype)
12215 
      iprot.readFieldEnd()
12216 
    iprot.readStructEnd()
12217 
 
12218 
  def write(self, oprot):
12219 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12220 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12221 
      return
12222 
    oprot.writeStructBegin('addInvoiceNumber_args')
12223 
    if self.orderId is not None:
12224 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
12225 
      oprot.writeI64(self.orderId)
12226 
      oprot.writeFieldEnd()
12227 
    if self.invoiceNumber is not None:
12228 
      oprot.writeFieldBegin('invoiceNumber', TType.STRING, 2)
12229 
      oprot.writeString(self.invoiceNumber)
12230 
      oprot.writeFieldEnd()
4763 rajveer 12231 
    if self.color is not None:
12232 
      oprot.writeFieldBegin('color', TType.STRING, 3)
12233 
      oprot.writeString(self.color)
12234 
      oprot.writeFieldEnd()
4579 rajveer 12235 
    oprot.writeFieldStop()
12236 
    oprot.writeStructEnd()
12237 
 
12238 
  def validate(self):
12239 
    return
12240 
 
12241 
 
12242 
  def __repr__(self):
12243 
    L = ['%s=%r' % (key, value)
12244 
      for key, value in self.__dict__.iteritems()]
12245 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12246 
 
12247 
  def __eq__(self, other):
12248 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12249 
 
12250 
  def __ne__(self, other):
12251 
    return not (self == other)
12252 
 
12253 
class addInvoiceNumber_result:
12254 
  """
12255 
  Attributes:
12256 
   - ex
12257 
  """
12258 
 
12259 
  thrift_spec = (
12260 
    None, # 0
12261 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
12262 
  )
12263 
 
12264 
  def __init__(self, ex=None,):
12265 
    self.ex = ex
12266 
 
12267 
  def read(self, iprot):
12268 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12269 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12270 
      return
12271 
    iprot.readStructBegin()
12272 
    while True:
12273 
      (fname, ftype, fid) = iprot.readFieldBegin()
12274 
      if ftype == TType.STOP:
12275 
        break
12276 
      if fid == 1:
12277 
        if ftype == TType.STRUCT:
12278 
          self.ex = TransactionServiceException()
12279 
          self.ex.read(iprot)
12280 
        else:
12281 
          iprot.skip(ftype)
12282 
      else:
12283 
        iprot.skip(ftype)
12284 
      iprot.readFieldEnd()
12285 
    iprot.readStructEnd()
12286 
 
12287 
  def write(self, oprot):
12288 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12289 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12290 
      return
12291 
    oprot.writeStructBegin('addInvoiceNumber_result')
12292 
    if self.ex is not None:
12293 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
12294 
      self.ex.write(oprot)
12295 
      oprot.writeFieldEnd()
12296 
    oprot.writeFieldStop()
12297 
    oprot.writeStructEnd()
12298 
 
12299 
  def validate(self):
12300 
    return
12301 
 
12302 
 
12303 
  def __repr__(self):
12304 
    L = ['%s=%r' % (key, value)
12305 
      for key, value in self.__dict__.iteritems()]
12306 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12307 
 
12308 
  def __eq__(self, other):
12309 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12310 
 
12311 
  def __ne__(self, other):
12312 
    return not (self == other)
12313 
 
4910 phani.kuma 12314 
class markOrdersAsShippedFromWarehouse_args:
1408 ankur.sing 12315 
  """
12316 
  Attributes:
3064 chandransh 12317 
   - warehouseId
1408 ankur.sing 12318 
   - providerId
3064 chandransh 12319 
   - cod
4910 phani.kuma 12320 
   - orderIds
1408 ankur.sing 12321 
  """
12322 
 
12323 
  thrift_spec = (
12324 
    None, # 0
3064 chandransh 12325 
    (1, TType.I64, 'warehouseId', None, None, ), # 1
12326 
    (2, TType.I64, 'providerId', None, None, ), # 2
12327 
    (3, TType.BOOL, 'cod', None, None, ), # 3
4910 phani.kuma 12328 
    (4, TType.LIST, 'orderIds', (TType.I64,None), None, ), # 4
1408 ankur.sing 12329 
  )
12330 
 
4910 phani.kuma 12331 
  def __init__(self, warehouseId=None, providerId=None, cod=None, orderIds=None,):
3064 chandransh 12332 
    self.warehouseId = warehouseId
1408 ankur.sing 12333 
    self.providerId = providerId
3064 chandransh 12334 
    self.cod = cod
4910 phani.kuma 12335 
    self.orderIds = orderIds
1408 ankur.sing 12336 
 
12337 
  def read(self, iprot):
12338 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12339 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12340 
      return
12341 
    iprot.readStructBegin()
12342 
    while True:
12343 
      (fname, ftype, fid) = iprot.readFieldBegin()
12344 
      if ftype == TType.STOP:
12345 
        break
12346 
      if fid == 1:
12347 
        if ftype == TType.I64:
3064 chandransh 12348 
          self.warehouseId = iprot.readI64();
1408 ankur.sing 12349 
        else:
12350 
          iprot.skip(ftype)
12351 
      elif fid == 2:
12352 
        if ftype == TType.I64:
3064 chandransh 12353 
          self.providerId = iprot.readI64();
1408 ankur.sing 12354 
        else:
12355 
          iprot.skip(ftype)
3064 chandransh 12356 
      elif fid == 3:
12357 
        if ftype == TType.BOOL:
12358 
          self.cod = iprot.readBool();
12359 
        else:
12360 
          iprot.skip(ftype)
4910 phani.kuma 12361 
      elif fid == 4:
12362 
        if ftype == TType.LIST:
12363 
          self.orderIds = []
5411 rajveer 12364 
          (_etype241, _size238) = iprot.readListBegin()
12365 
          for _i242 in xrange(_size238):
12366 
            _elem243 = iprot.readI64();
12367 
            self.orderIds.append(_elem243)
4910 phani.kuma 12368 
          iprot.readListEnd()
12369 
        else:
12370 
          iprot.skip(ftype)
1408 ankur.sing 12371 
      else:
12372 
        iprot.skip(ftype)
12373 
      iprot.readFieldEnd()
12374 
    iprot.readStructEnd()
12375 
 
12376 
  def write(self, oprot):
12377 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12378 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12379 
      return
4910 phani.kuma 12380 
    oprot.writeStructBegin('markOrdersAsShippedFromWarehouse_args')
3431 rajveer 12381 
    if self.warehouseId is not None:
3064 chandransh 12382 
      oprot.writeFieldBegin('warehouseId', TType.I64, 1)
12383 
      oprot.writeI64(self.warehouseId)
12384 
      oprot.writeFieldEnd()
3431 rajveer 12385 
    if self.providerId is not None:
3064 chandransh 12386 
      oprot.writeFieldBegin('providerId', TType.I64, 2)
1408 ankur.sing 12387 
      oprot.writeI64(self.providerId)
12388 
      oprot.writeFieldEnd()
3431 rajveer 12389 
    if self.cod is not None:
3064 chandransh 12390 
      oprot.writeFieldBegin('cod', TType.BOOL, 3)
12391 
      oprot.writeBool(self.cod)
1408 ankur.sing 12392 
      oprot.writeFieldEnd()
4910 phani.kuma 12393 
    if self.orderIds is not None:
12394 
      oprot.writeFieldBegin('orderIds', TType.LIST, 4)
12395 
      oprot.writeListBegin(TType.I64, len(self.orderIds))
5411 rajveer 12396 
      for iter244 in self.orderIds:
12397 
        oprot.writeI64(iter244)
4910 phani.kuma 12398 
      oprot.writeListEnd()
12399 
      oprot.writeFieldEnd()
1408 ankur.sing 12400 
    oprot.writeFieldStop()
12401 
    oprot.writeStructEnd()
12402 
 
3431 rajveer 12403 
  def validate(self):
12404 
    return
12405 
 
12406 
 
1408 ankur.sing 12407 
  def __repr__(self):
12408 
    L = ['%s=%r' % (key, value)
12409 
      for key, value in self.__dict__.iteritems()]
12410 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12411 
 
12412 
  def __eq__(self, other):
12413 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12414 
 
12415 
  def __ne__(self, other):
12416 
    return not (self == other)
12417 
 
4910 phani.kuma 12418 
class markOrdersAsShippedFromWarehouse_result:
1408 ankur.sing 12419 
  """
12420 
  Attributes:
12421 
   - success
3064 chandransh 12422 
   - ex
1408 ankur.sing 12423 
  """
12424 
 
12425 
  thrift_spec = (
3064 chandransh 12426 
    (0, TType.BOOL, 'success', None, None, ), # 0
12427 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
1408 ankur.sing 12428 
  )
12429 
 
3064 chandransh 12430 
  def __init__(self, success=None, ex=None,):
1408 ankur.sing 12431 
    self.success = success
3064 chandransh 12432 
    self.ex = ex
1408 ankur.sing 12433 
 
12434 
  def read(self, iprot):
12435 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12436 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12437 
      return
12438 
    iprot.readStructBegin()
12439 
    while True:
12440 
      (fname, ftype, fid) = iprot.readFieldBegin()
12441 
      if ftype == TType.STOP:
12442 
        break
12443 
      if fid == 0:
3064 chandransh 12444 
        if ftype == TType.BOOL:
12445 
          self.success = iprot.readBool();
1408 ankur.sing 12446 
        else:
12447 
          iprot.skip(ftype)
3064 chandransh 12448 
      elif fid == 1:
12449 
        if ftype == TType.STRUCT:
12450 
          self.ex = TransactionServiceException()
12451 
          self.ex.read(iprot)
12452 
        else:
12453 
          iprot.skip(ftype)
1408 ankur.sing 12454 
      else:
12455 
        iprot.skip(ftype)
12456 
      iprot.readFieldEnd()
12457 
    iprot.readStructEnd()
12458 
 
12459 
  def write(self, oprot):
12460 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12461 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12462 
      return
4910 phani.kuma 12463 
    oprot.writeStructBegin('markOrdersAsShippedFromWarehouse_result')
3431 rajveer 12464 
    if self.success is not None:
3064 chandransh 12465 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
12466 
      oprot.writeBool(self.success)
1408 ankur.sing 12467 
      oprot.writeFieldEnd()
3431 rajveer 12468 
    if self.ex is not None:
3064 chandransh 12469 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
12470 
      self.ex.write(oprot)
12471 
      oprot.writeFieldEnd()
1408 ankur.sing 12472 
    oprot.writeFieldStop()
12473 
    oprot.writeStructEnd()
12474 
 
3431 rajveer 12475 
  def validate(self):
12476 
    return
12477 
 
12478 
 
1408 ankur.sing 12479 
  def __repr__(self):
12480 
    L = ['%s=%r' % (key, value)
12481 
      for key, value in self.__dict__.iteritems()]
12482 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12483 
 
12484 
  def __eq__(self, other):
12485 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12486 
 
12487 
  def __ne__(self, other):
12488 
    return not (self == other)
12489 
 
4910 phani.kuma 12490 
class markOrdersAsPickedUp_args:
4410 rajveer 12491 
  """
12492 
  Attributes:
12493 
   - providerId
4910 phani.kuma 12494 
   - pickupDetails
4410 rajveer 12495 
  """
12496 
 
12497 
  thrift_spec = (
12498 
    None, # 0
4910 phani.kuma 12499 
    (1, TType.I64, 'providerId', None, None, ), # 1
12500 
    (2, TType.MAP, 'pickupDetails', (TType.STRING,None,TType.STRING,None), None, ), # 2
4410 rajveer 12501 
  )
12502 
 
4910 phani.kuma 12503 
  def __init__(self, providerId=None, pickupDetails=None,):
4410 rajveer 12504 
    self.providerId = providerId
4910 phani.kuma 12505 
    self.pickupDetails = pickupDetails
4410 rajveer 12506 
 
12507 
  def read(self, iprot):
12508 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12509 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12510 
      return
12511 
    iprot.readStructBegin()
12512 
    while True:
12513 
      (fname, ftype, fid) = iprot.readFieldBegin()
12514 
      if ftype == TType.STOP:
12515 
        break
12516 
      if fid == 1:
12517 
        if ftype == TType.I64:
4910 phani.kuma 12518 
          self.providerId = iprot.readI64();
4410 rajveer 12519 
        else:
12520 
          iprot.skip(ftype)
12521 
      elif fid == 2:
4910 phani.kuma 12522 
        if ftype == TType.MAP:
12523 
          self.pickupDetails = {}
5411 rajveer 12524 
          (_ktype246, _vtype247, _size245 ) = iprot.readMapBegin()
12525 
          for _i249 in xrange(_size245):
12526 
            _key250 = iprot.readString();
12527 
            _val251 = iprot.readString();
12528 
            self.pickupDetails[_key250] = _val251
4910 phani.kuma 12529 
          iprot.readMapEnd()
4410 rajveer 12530 
        else:
12531 
          iprot.skip(ftype)
12532 
      else:
12533 
        iprot.skip(ftype)
12534 
      iprot.readFieldEnd()
12535 
    iprot.readStructEnd()
12536 
 
12537 
  def write(self, oprot):
12538 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12539 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12540 
      return
4910 phani.kuma 12541 
    oprot.writeStructBegin('markOrdersAsPickedUp_args')
4410 rajveer 12542 
    if self.providerId is not None:
4910 phani.kuma 12543 
      oprot.writeFieldBegin('providerId', TType.I64, 1)
4410 rajveer 12544 
      oprot.writeI64(self.providerId)
12545 
      oprot.writeFieldEnd()
4910 phani.kuma 12546 
    if self.pickupDetails is not None:
12547 
      oprot.writeFieldBegin('pickupDetails', TType.MAP, 2)
12548 
      oprot.writeMapBegin(TType.STRING, TType.STRING, len(self.pickupDetails))
5411 rajveer 12549 
      for kiter252,viter253 in self.pickupDetails.items():
12550 
        oprot.writeString(kiter252)
12551 
        oprot.writeString(viter253)
4910 phani.kuma 12552 
      oprot.writeMapEnd()
4410 rajveer 12553 
      oprot.writeFieldEnd()
12554 
    oprot.writeFieldStop()
12555 
    oprot.writeStructEnd()
12556 
 
12557 
  def validate(self):
12558 
    return
12559 
 
12560 
 
12561 
  def __repr__(self):
12562 
    L = ['%s=%r' % (key, value)
12563 
      for key, value in self.__dict__.iteritems()]
12564 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12565 
 
12566 
  def __eq__(self, other):
12567 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12568 
 
12569 
  def __ne__(self, other):
12570 
    return not (self == other)
12571 
 
4910 phani.kuma 12572 
class markOrdersAsPickedUp_result:
4410 rajveer 12573 
  """
12574 
  Attributes:
12575 
   - ex
12576 
  """
12577 
 
12578 
  thrift_spec = (
4910 phani.kuma 12579 
    None, # 0
4410 rajveer 12580 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
12581 
  )
12582 
 
4910 phani.kuma 12583 
  def __init__(self, ex=None,):
4410 rajveer 12584 
    self.ex = ex
12585 
 
12586 
  def read(self, iprot):
12587 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12588 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12589 
      return
12590 
    iprot.readStructBegin()
12591 
    while True:
12592 
      (fname, ftype, fid) = iprot.readFieldBegin()
12593 
      if ftype == TType.STOP:
12594 
        break
4910 phani.kuma 12595 
      if fid == 1:
4410 rajveer 12596 
        if ftype == TType.STRUCT:
12597 
          self.ex = TransactionServiceException()
12598 
          self.ex.read(iprot)
12599 
        else:
12600 
          iprot.skip(ftype)
12601 
      else:
12602 
        iprot.skip(ftype)
12603 
      iprot.readFieldEnd()
12604 
    iprot.readStructEnd()
12605 
 
12606 
  def write(self, oprot):
12607 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12608 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12609 
      return
4910 phani.kuma 12610 
    oprot.writeStructBegin('markOrdersAsPickedUp_result')
4410 rajveer 12611 
    if self.ex is not None:
12612 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
12613 
      self.ex.write(oprot)
12614 
      oprot.writeFieldEnd()
12615 
    oprot.writeFieldStop()
12616 
    oprot.writeStructEnd()
12617 
 
12618 
  def validate(self):
12619 
    return
12620 
 
12621 
 
12622 
  def __repr__(self):
12623 
    L = ['%s=%r' % (key, value)
12624 
      for key, value in self.__dict__.iteritems()]
12625 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12626 
 
12627 
  def __eq__(self, other):
12628 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12629 
 
12630 
  def __ne__(self, other):
12631 
    return not (self == other)
12632 
 
4910 phani.kuma 12633 
class getOrdersNotPickedUp_args:
304 ashish 12634 
  """
12635 
  Attributes:
3064 chandransh 12636 
   - providerId
304 ashish 12637 
  """
94 ashish 12638 
 
304 ashish 12639 
  thrift_spec = (
12640 
    None, # 0
3064 chandransh 12641 
    (1, TType.I64, 'providerId', None, None, ), # 1
304 ashish 12642 
  )
12643 
 
4910 phani.kuma 12644 
  def __init__(self, providerId=None,):
3064 chandransh 12645 
    self.providerId = providerId
304 ashish 12646 
 
12647 
  def read(self, iprot):
12648 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12649 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12650 
      return
12651 
    iprot.readStructBegin()
12652 
    while True:
12653 
      (fname, ftype, fid) = iprot.readFieldBegin()
12654 
      if ftype == TType.STOP:
12655 
        break
12656 
      if fid == 1:
12657 
        if ftype == TType.I64:
3064 chandransh 12658 
          self.providerId = iprot.readI64();
304 ashish 12659 
        else:
12660 
          iprot.skip(ftype)
12661 
      else:
12662 
        iprot.skip(ftype)
12663 
      iprot.readFieldEnd()
12664 
    iprot.readStructEnd()
12665 
 
12666 
  def write(self, oprot):
12667 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12668 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12669 
      return
4910 phani.kuma 12670 
    oprot.writeStructBegin('getOrdersNotPickedUp_args')
3431 rajveer 12671 
    if self.providerId is not None:
3064 chandransh 12672 
      oprot.writeFieldBegin('providerId', TType.I64, 1)
12673 
      oprot.writeI64(self.providerId)
304 ashish 12674 
      oprot.writeFieldEnd()
12675 
    oprot.writeFieldStop()
12676 
    oprot.writeStructEnd()
12677 
 
3431 rajveer 12678 
  def validate(self):
12679 
    return
12680 
 
12681 
 
304 ashish 12682 
  def __repr__(self):
12683 
    L = ['%s=%r' % (key, value)
12684 
      for key, value in self.__dict__.iteritems()]
12685 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12686 
 
12687 
  def __eq__(self, other):
12688 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12689 
 
12690 
  def __ne__(self, other):
12691 
    return not (self == other)
12692 
 
4910 phani.kuma 12693 
class getOrdersNotPickedUp_result:
304 ashish 12694 
  """
12695 
  Attributes:
12696 
   - success
12697 
  """
12698 
 
12699 
  thrift_spec = (
3064 chandransh 12700 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
304 ashish 12701 
  )
12702 
 
4910 phani.kuma 12703 
  def __init__(self, success=None,):
304 ashish 12704 
    self.success = success
12705 
 
12706 
  def read(self, iprot):
12707 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12708 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12709 
      return
12710 
    iprot.readStructBegin()
12711 
    while True:
12712 
      (fname, ftype, fid) = iprot.readFieldBegin()
12713 
      if ftype == TType.STOP:
12714 
        break
12715 
      if fid == 0:
12716 
        if ftype == TType.LIST:
12717 
          self.success = []
5411 rajveer 12718 
          (_etype257, _size254) = iprot.readListBegin()
12719 
          for _i258 in xrange(_size254):
12720 
            _elem259 = Order()
12721 
            _elem259.read(iprot)
12722 
            self.success.append(_elem259)
304 ashish 12723 
          iprot.readListEnd()
12724 
        else:
12725 
          iprot.skip(ftype)
12726 
      else:
12727 
        iprot.skip(ftype)
12728 
      iprot.readFieldEnd()
12729 
    iprot.readStructEnd()
12730 
 
12731 
  def write(self, oprot):
12732 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12733 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12734 
      return
4910 phani.kuma 12735 
    oprot.writeStructBegin('getOrdersNotPickedUp_result')
3431 rajveer 12736 
    if self.success is not None:
304 ashish 12737 
      oprot.writeFieldBegin('success', TType.LIST, 0)
12738 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
5411 rajveer 12739 
      for iter260 in self.success:
12740 
        iter260.write(oprot)
304 ashish 12741 
      oprot.writeListEnd()
12742 
      oprot.writeFieldEnd()
12743 
    oprot.writeFieldStop()
12744 
    oprot.writeStructEnd()
12745 
 
3431 rajveer 12746 
  def validate(self):
12747 
    return
12748 
 
12749 
 
304 ashish 12750 
  def __repr__(self):
12751 
    L = ['%s=%r' % (key, value)
12752 
      for key, value in self.__dict__.iteritems()]
12753 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12754 
 
12755 
  def __eq__(self, other):
12756 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12757 
 
12758 
  def __ne__(self, other):
12759 
    return not (self == other)
12760 
 
3064 chandransh 12761 
class markOrdersAsDelivered_args:
304 ashish 12762 
  """
12763 
  Attributes:
3064 chandransh 12764 
   - providerId
12765 
   - deliveredOrders
304 ashish 12766 
  """
12767 
 
12768 
  thrift_spec = (
12769 
    None, # 0
3064 chandransh 12770 
    (1, TType.I64, 'providerId', None, None, ), # 1
12771 
    (2, TType.MAP, 'deliveredOrders', (TType.STRING,None,TType.STRING,None), None, ), # 2
304 ashish 12772 
  )
12773 
 
3064 chandransh 12774 
  def __init__(self, providerId=None, deliveredOrders=None,):
12775 
    self.providerId = providerId
12776 
    self.deliveredOrders = deliveredOrders
304 ashish 12777 
 
12778 
  def read(self, iprot):
12779 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12780 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12781 
      return
12782 
    iprot.readStructBegin()
12783 
    while True:
12784 
      (fname, ftype, fid) = iprot.readFieldBegin()
12785 
      if ftype == TType.STOP:
12786 
        break
12787 
      if fid == 1:
12788 
        if ftype == TType.I64:
3064 chandransh 12789 
          self.providerId = iprot.readI64();
304 ashish 12790 
        else:
12791 
          iprot.skip(ftype)
12792 
      elif fid == 2:
3064 chandransh 12793 
        if ftype == TType.MAP:
12794 
          self.deliveredOrders = {}
5411 rajveer 12795 
          (_ktype262, _vtype263, _size261 ) = iprot.readMapBegin()
12796 
          for _i265 in xrange(_size261):
12797 
            _key266 = iprot.readString();
12798 
            _val267 = iprot.readString();
12799 
            self.deliveredOrders[_key266] = _val267
3064 chandransh 12800 
          iprot.readMapEnd()
304 ashish 12801 
        else:
12802 
          iprot.skip(ftype)
12803 
      else:
12804 
        iprot.skip(ftype)
12805 
      iprot.readFieldEnd()
12806 
    iprot.readStructEnd()
12807 
 
12808 
  def write(self, oprot):
12809 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12810 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12811 
      return
3064 chandransh 12812 
    oprot.writeStructBegin('markOrdersAsDelivered_args')
3431 rajveer 12813 
    if self.providerId is not None:
3064 chandransh 12814 
      oprot.writeFieldBegin('providerId', TType.I64, 1)
12815 
      oprot.writeI64(self.providerId)
304 ashish 12816 
      oprot.writeFieldEnd()
3431 rajveer 12817 
    if self.deliveredOrders is not None:
3064 chandransh 12818 
      oprot.writeFieldBegin('deliveredOrders', TType.MAP, 2)
12819 
      oprot.writeMapBegin(TType.STRING, TType.STRING, len(self.deliveredOrders))
5411 rajveer 12820 
      for kiter268,viter269 in self.deliveredOrders.items():
12821 
        oprot.writeString(kiter268)
12822 
        oprot.writeString(viter269)
3064 chandransh 12823 
      oprot.writeMapEnd()
304 ashish 12824 
      oprot.writeFieldEnd()
12825 
    oprot.writeFieldStop()
12826 
    oprot.writeStructEnd()
12827 
 
3431 rajveer 12828 
  def validate(self):
12829 
    return
12830 
 
12831 
 
304 ashish 12832 
  def __repr__(self):
12833 
    L = ['%s=%r' % (key, value)
12834 
      for key, value in self.__dict__.iteritems()]
12835 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12836 
 
12837 
  def __eq__(self, other):
12838 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12839 
 
12840 
  def __ne__(self, other):
12841 
    return not (self == other)
12842 
 
3064 chandransh 12843 
class markOrdersAsDelivered_result:
12844 
  """
12845 
  Attributes:
12846 
   - ex
12847 
  """
304 ashish 12848 
 
12849 
  thrift_spec = (
3064 chandransh 12850 
    None, # 0
12851 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
304 ashish 12852 
  )
12853 
 
3064 chandransh 12854 
  def __init__(self, ex=None,):
12855 
    self.ex = ex
304 ashish 12856 
 
1596 ankur.sing 12857 
  def read(self, iprot):
12858 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12859 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12860 
      return
12861 
    iprot.readStructBegin()
12862 
    while True:
12863 
      (fname, ftype, fid) = iprot.readFieldBegin()
12864 
      if ftype == TType.STOP:
12865 
        break
3064 chandransh 12866 
      if fid == 1:
12867 
        if ftype == TType.STRUCT:
12868 
          self.ex = TransactionServiceException()
12869 
          self.ex.read(iprot)
12870 
        else:
12871 
          iprot.skip(ftype)
1596 ankur.sing 12872 
      else:
12873 
        iprot.skip(ftype)
12874 
      iprot.readFieldEnd()
12875 
    iprot.readStructEnd()
12876 
 
12877 
  def write(self, oprot):
12878 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12879 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12880 
      return
3064 chandransh 12881 
    oprot.writeStructBegin('markOrdersAsDelivered_result')
3431 rajveer 12882 
    if self.ex is not None:
3064 chandransh 12883 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
12884 
      self.ex.write(oprot)
12885 
      oprot.writeFieldEnd()
1596 ankur.sing 12886 
    oprot.writeFieldStop()
12887 
    oprot.writeStructEnd()
12888 
 
3431 rajveer 12889 
  def validate(self):
12890 
    return
12891 
 
12892 
 
1596 ankur.sing 12893 
  def __repr__(self):
12894 
    L = ['%s=%r' % (key, value)
12895 
      for key, value in self.__dict__.iteritems()]
12896 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12897 
 
12898 
  def __eq__(self, other):
12899 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12900 
 
12901 
  def __ne__(self, other):
12902 
    return not (self == other)
12903 
 
4910 phani.kuma 12904 
class markAsRTOrders_args:
1596 ankur.sing 12905 
  """
12906 
  Attributes:
3064 chandransh 12907 
   - providerId
12908 
   - returnedOrders
1596 ankur.sing 12909 
  """
12910 
 
12911 
  thrift_spec = (
3064 chandransh 12912 
    None, # 0
12913 
    (1, TType.I64, 'providerId', None, None, ), # 1
12914 
    (2, TType.MAP, 'returnedOrders', (TType.STRING,None,TType.STRING,None), None, ), # 2
1596 ankur.sing 12915 
  )
12916 
 
3064 chandransh 12917 
  def __init__(self, providerId=None, returnedOrders=None,):
12918 
    self.providerId = providerId
12919 
    self.returnedOrders = returnedOrders
1596 ankur.sing 12920 
 
12921 
  def read(self, iprot):
12922 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12923 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12924 
      return
12925 
    iprot.readStructBegin()
12926 
    while True:
12927 
      (fname, ftype, fid) = iprot.readFieldBegin()
12928 
      if ftype == TType.STOP:
12929 
        break
3064 chandransh 12930 
      if fid == 1:
1596 ankur.sing 12931 
        if ftype == TType.I64:
3064 chandransh 12932 
          self.providerId = iprot.readI64();
1596 ankur.sing 12933 
        else:
12934 
          iprot.skip(ftype)
3064 chandransh 12935 
      elif fid == 2:
12936 
        if ftype == TType.MAP:
12937 
          self.returnedOrders = {}
5411 rajveer 12938 
          (_ktype271, _vtype272, _size270 ) = iprot.readMapBegin()
12939 
          for _i274 in xrange(_size270):
12940 
            _key275 = iprot.readString();
12941 
            _val276 = iprot.readString();
12942 
            self.returnedOrders[_key275] = _val276
3064 chandransh 12943 
          iprot.readMapEnd()
12944 
        else:
12945 
          iprot.skip(ftype)
1596 ankur.sing 12946 
      else:
12947 
        iprot.skip(ftype)
12948 
      iprot.readFieldEnd()
12949 
    iprot.readStructEnd()
12950 
 
12951 
  def write(self, oprot):
12952 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12953 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12954 
      return
4910 phani.kuma 12955 
    oprot.writeStructBegin('markAsRTOrders_args')
3431 rajveer 12956 
    if self.providerId is not None:
3064 chandransh 12957 
      oprot.writeFieldBegin('providerId', TType.I64, 1)
12958 
      oprot.writeI64(self.providerId)
1596 ankur.sing 12959 
      oprot.writeFieldEnd()
3431 rajveer 12960 
    if self.returnedOrders is not None:
3064 chandransh 12961 
      oprot.writeFieldBegin('returnedOrders', TType.MAP, 2)
12962 
      oprot.writeMapBegin(TType.STRING, TType.STRING, len(self.returnedOrders))
5411 rajveer 12963 
      for kiter277,viter278 in self.returnedOrders.items():
12964 
        oprot.writeString(kiter277)
12965 
        oprot.writeString(viter278)
3064 chandransh 12966 
      oprot.writeMapEnd()
12967 
      oprot.writeFieldEnd()
1596 ankur.sing 12968 
    oprot.writeFieldStop()
12969 
    oprot.writeStructEnd()
12970 
 
3431 rajveer 12971 
  def validate(self):
12972 
    return
12973 
 
12974 
 
1596 ankur.sing 12975 
  def __repr__(self):
12976 
    L = ['%s=%r' % (key, value)
12977 
      for key, value in self.__dict__.iteritems()]
12978 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12979 
 
12980 
  def __eq__(self, other):
12981 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12982 
 
12983 
  def __ne__(self, other):
12984 
    return not (self == other)
12985 
 
4910 phani.kuma 12986 
class markAsRTOrders_result:
3064 chandransh 12987 
  """
12988 
  Attributes:
12989 
   - ex
12990 
  """
1596 ankur.sing 12991 
 
1627 ankur.sing 12992 
  thrift_spec = (
3064 chandransh 12993 
    None, # 0
12994 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
1627 ankur.sing 12995 
  )
12996 
 
3064 chandransh 12997 
  def __init__(self, ex=None,):
12998 
    self.ex = ex
12999 
 
1627 ankur.sing 13000 
  def read(self, iprot):
13001 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13002 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13003 
      return
13004 
    iprot.readStructBegin()
13005 
    while True:
13006 
      (fname, ftype, fid) = iprot.readFieldBegin()
13007 
      if ftype == TType.STOP:
13008 
        break
3064 chandransh 13009 
      if fid == 1:
13010 
        if ftype == TType.STRUCT:
13011 
          self.ex = TransactionServiceException()
13012 
          self.ex.read(iprot)
13013 
        else:
13014 
          iprot.skip(ftype)
1627 ankur.sing 13015 
      else:
13016 
        iprot.skip(ftype)
13017 
      iprot.readFieldEnd()
13018 
    iprot.readStructEnd()
13019 
 
13020 
  def write(self, oprot):
13021 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13022 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13023 
      return
4910 phani.kuma 13024 
    oprot.writeStructBegin('markAsRTOrders_result')
3431 rajveer 13025 
    if self.ex is not None:
3064 chandransh 13026 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
13027 
      self.ex.write(oprot)
13028 
      oprot.writeFieldEnd()
1627 ankur.sing 13029 
    oprot.writeFieldStop()
13030 
    oprot.writeStructEnd()
13031 
 
3431 rajveer 13032 
  def validate(self):
13033 
    return
13034 
 
13035 
 
1627 ankur.sing 13036 
  def __repr__(self):
13037 
    L = ['%s=%r' % (key, value)
13038 
      for key, value in self.__dict__.iteritems()]
13039 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13040 
 
13041 
  def __eq__(self, other):
13042 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13043 
 
13044 
  def __ne__(self, other):
13045 
    return not (self == other)
13046 
 
4910 phani.kuma 13047 
class getRTOrders_args:
13048 
  """
13049 
  Attributes:
13050 
   - providerId
13051 
  """
13052 
 
13053 
  thrift_spec = (
13054 
    None, # 0
13055 
    (1, TType.I64, 'providerId', None, None, ), # 1
13056 
  )
13057 
 
13058 
  def __init__(self, providerId=None,):
13059 
    self.providerId = providerId
13060 
 
13061 
  def read(self, iprot):
13062 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13063 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13064 
      return
13065 
    iprot.readStructBegin()
13066 
    while True:
13067 
      (fname, ftype, fid) = iprot.readFieldBegin()
13068 
      if ftype == TType.STOP:
13069 
        break
13070 
      if fid == 1:
13071 
        if ftype == TType.I64:
13072 
          self.providerId = iprot.readI64();
13073 
        else:
13074 
          iprot.skip(ftype)
13075 
      else:
13076 
        iprot.skip(ftype)
13077 
      iprot.readFieldEnd()
13078 
    iprot.readStructEnd()
13079 
 
13080 
  def write(self, oprot):
13081 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13082 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13083 
      return
13084 
    oprot.writeStructBegin('getRTOrders_args')
13085 
    if self.providerId is not None:
13086 
      oprot.writeFieldBegin('providerId', TType.I64, 1)
13087 
      oprot.writeI64(self.providerId)
13088 
      oprot.writeFieldEnd()
13089 
    oprot.writeFieldStop()
13090 
    oprot.writeStructEnd()
13091 
 
13092 
  def validate(self):
13093 
    return
13094 
 
13095 
 
13096 
  def __repr__(self):
13097 
    L = ['%s=%r' % (key, value)
13098 
      for key, value in self.__dict__.iteritems()]
13099 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13100 
 
13101 
  def __eq__(self, other):
13102 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13103 
 
13104 
  def __ne__(self, other):
13105 
    return not (self == other)
13106 
 
13107 
class getRTOrders_result:
13108 
  """
13109 
  Attributes:
13110 
   - success
13111 
  """
13112 
 
13113 
  thrift_spec = (
13114 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
13115 
  )
13116 
 
13117 
  def __init__(self, success=None,):
13118 
    self.success = success
13119 
 
13120 
  def read(self, iprot):
13121 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13122 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13123 
      return
13124 
    iprot.readStructBegin()
13125 
    while True:
13126 
      (fname, ftype, fid) = iprot.readFieldBegin()
13127 
      if ftype == TType.STOP:
13128 
        break
13129 
      if fid == 0:
13130 
        if ftype == TType.LIST:
13131 
          self.success = []
5411 rajveer 13132 
          (_etype282, _size279) = iprot.readListBegin()
13133 
          for _i283 in xrange(_size279):
13134 
            _elem284 = Order()
13135 
            _elem284.read(iprot)
13136 
            self.success.append(_elem284)
4910 phani.kuma 13137 
          iprot.readListEnd()
13138 
        else:
13139 
          iprot.skip(ftype)
13140 
      else:
13141 
        iprot.skip(ftype)
13142 
      iprot.readFieldEnd()
13143 
    iprot.readStructEnd()
13144 
 
13145 
  def write(self, oprot):
13146 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13147 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13148 
      return
13149 
    oprot.writeStructBegin('getRTOrders_result')
13150 
    if self.success is not None:
13151 
      oprot.writeFieldBegin('success', TType.LIST, 0)
13152 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
5411 rajveer 13153 
      for iter285 in self.success:
13154 
        iter285.write(oprot)
4910 phani.kuma 13155 
      oprot.writeListEnd()
13156 
      oprot.writeFieldEnd()
13157 
    oprot.writeFieldStop()
13158 
    oprot.writeStructEnd()
13159 
 
13160 
  def validate(self):
13161 
    return
13162 
 
13163 
 
13164 
  def __repr__(self):
13165 
    L = ['%s=%r' % (key, value)
13166 
      for key, value in self.__dict__.iteritems()]
13167 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13168 
 
13169 
  def __eq__(self, other):
13170 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13171 
 
13172 
  def __ne__(self, other):
13173 
    return not (self == other)
13174 
 
3064 chandransh 13175 
class updateNonDeliveryReason_args:
1627 ankur.sing 13176 
  """
13177 
  Attributes:
3064 chandransh 13178 
   - providerId
13179 
   - undeliveredOrders
1627 ankur.sing 13180 
  """
13181 
 
13182 
  thrift_spec = (
3064 chandransh 13183 
    None, # 0
13184 
    (1, TType.I64, 'providerId', None, None, ), # 1
13185 
    (2, TType.MAP, 'undeliveredOrders', (TType.STRING,None,TType.STRING,None), None, ), # 2
1627 ankur.sing 13186 
  )
13187 
 
3064 chandransh 13188 
  def __init__(self, providerId=None, undeliveredOrders=None,):
13189 
    self.providerId = providerId
13190 
    self.undeliveredOrders = undeliveredOrders
1627 ankur.sing 13191 
 
13192 
  def read(self, iprot):
13193 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13194 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13195 
      return
13196 
    iprot.readStructBegin()
13197 
    while True:
13198 
      (fname, ftype, fid) = iprot.readFieldBegin()
13199 
      if ftype == TType.STOP:
13200 
        break
3064 chandransh 13201 
      if fid == 1:
1627 ankur.sing 13202 
        if ftype == TType.I64:
3064 chandransh 13203 
          self.providerId = iprot.readI64();
1627 ankur.sing 13204 
        else:
13205 
          iprot.skip(ftype)
3064 chandransh 13206 
      elif fid == 2:
13207 
        if ftype == TType.MAP:
13208 
          self.undeliveredOrders = {}
5411 rajveer 13209 
          (_ktype287, _vtype288, _size286 ) = iprot.readMapBegin()
13210 
          for _i290 in xrange(_size286):
13211 
            _key291 = iprot.readString();
13212 
            _val292 = iprot.readString();
13213 
            self.undeliveredOrders[_key291] = _val292
3064 chandransh 13214 
          iprot.readMapEnd()
13215 
        else:
13216 
          iprot.skip(ftype)
1627 ankur.sing 13217 
      else:
13218 
        iprot.skip(ftype)
13219 
      iprot.readFieldEnd()
13220 
    iprot.readStructEnd()
13221 
 
13222 
  def write(self, oprot):
13223 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13224 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13225 
      return
3064 chandransh 13226 
    oprot.writeStructBegin('updateNonDeliveryReason_args')
3431 rajveer 13227 
    if self.providerId is not None:
3064 chandransh 13228 
      oprot.writeFieldBegin('providerId', TType.I64, 1)
13229 
      oprot.writeI64(self.providerId)
1627 ankur.sing 13230 
      oprot.writeFieldEnd()
3431 rajveer 13231 
    if self.undeliveredOrders is not None:
3064 chandransh 13232 
      oprot.writeFieldBegin('undeliveredOrders', TType.MAP, 2)
13233 
      oprot.writeMapBegin(TType.STRING, TType.STRING, len(self.undeliveredOrders))
5411 rajveer 13234 
      for kiter293,viter294 in self.undeliveredOrders.items():
13235 
        oprot.writeString(kiter293)
13236 
        oprot.writeString(viter294)
3064 chandransh 13237 
      oprot.writeMapEnd()
13238 
      oprot.writeFieldEnd()
1627 ankur.sing 13239 
    oprot.writeFieldStop()
13240 
    oprot.writeStructEnd()
13241 
 
3431 rajveer 13242 
  def validate(self):
13243 
    return
13244 
 
13245 
 
1627 ankur.sing 13246 
  def __repr__(self):
13247 
    L = ['%s=%r' % (key, value)
13248 
      for key, value in self.__dict__.iteritems()]
13249 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13250 
 
13251 
  def __eq__(self, other):
13252 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13253 
 
13254 
  def __ne__(self, other):
13255 
    return not (self == other)
13256 
 
3064 chandransh 13257 
class updateNonDeliveryReason_result:
1627 ankur.sing 13258 
  """
13259 
  Attributes:
3064 chandransh 13260 
   - ex
1627 ankur.sing 13261 
  """
13262 
 
13263 
  thrift_spec = (
4910 phani.kuma 13264 
    None, # 0
3064 chandransh 13265 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
1627 ankur.sing 13266 
  )
13267 
 
4910 phani.kuma 13268 
  def __init__(self, ex=None,):
3064 chandransh 13269 
    self.ex = ex
1627 ankur.sing 13270 
 
13271 
  def read(self, iprot):
13272 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13273 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13274 
      return
13275 
    iprot.readStructBegin()
13276 
    while True:
13277 
      (fname, ftype, fid) = iprot.readFieldBegin()
13278 
      if ftype == TType.STOP:
13279 
        break
4910 phani.kuma 13280 
      if fid == 1:
13281 
        if ftype == TType.STRUCT:
13282 
          self.ex = TransactionServiceException()
13283 
          self.ex.read(iprot)
13284 
        else:
13285 
          iprot.skip(ftype)
13286 
      else:
13287 
        iprot.skip(ftype)
13288 
      iprot.readFieldEnd()
13289 
    iprot.readStructEnd()
13290 
 
13291 
  def write(self, oprot):
13292 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13293 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13294 
      return
13295 
    oprot.writeStructBegin('updateNonDeliveryReason_result')
13296 
    if self.ex is not None:
13297 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
13298 
      self.ex.write(oprot)
13299 
      oprot.writeFieldEnd()
13300 
    oprot.writeFieldStop()
13301 
    oprot.writeStructEnd()
13302 
 
13303 
  def validate(self):
13304 
    return
13305 
 
13306 
 
13307 
  def __repr__(self):
13308 
    L = ['%s=%r' % (key, value)
13309 
      for key, value in self.__dict__.iteritems()]
13310 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13311 
 
13312 
  def __eq__(self, other):
13313 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13314 
 
13315 
  def __ne__(self, other):
13316 
    return not (self == other)
13317 
 
13318 
class getNonDeliveredOrdersbyCourier_args:
13319 
  """
13320 
  Attributes:
13321 
   - providerId
13322 
  """
13323 
 
13324 
  thrift_spec = (
13325 
    None, # 0
13326 
    (1, TType.I64, 'providerId', None, None, ), # 1
13327 
  )
13328 
 
13329 
  def __init__(self, providerId=None,):
13330 
    self.providerId = providerId
13331 
 
13332 
  def read(self, iprot):
13333 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13334 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13335 
      return
13336 
    iprot.readStructBegin()
13337 
    while True:
13338 
      (fname, ftype, fid) = iprot.readFieldBegin()
13339 
      if ftype == TType.STOP:
13340 
        break
13341 
      if fid == 1:
13342 
        if ftype == TType.I64:
13343 
          self.providerId = iprot.readI64();
13344 
        else:
13345 
          iprot.skip(ftype)
13346 
      else:
13347 
        iprot.skip(ftype)
13348 
      iprot.readFieldEnd()
13349 
    iprot.readStructEnd()
13350 
 
13351 
  def write(self, oprot):
13352 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13353 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13354 
      return
13355 
    oprot.writeStructBegin('getNonDeliveredOrdersbyCourier_args')
13356 
    if self.providerId is not None:
13357 
      oprot.writeFieldBegin('providerId', TType.I64, 1)
13358 
      oprot.writeI64(self.providerId)
13359 
      oprot.writeFieldEnd()
13360 
    oprot.writeFieldStop()
13361 
    oprot.writeStructEnd()
13362 
 
13363 
  def validate(self):
13364 
    return
13365 
 
13366 
 
13367 
  def __repr__(self):
13368 
    L = ['%s=%r' % (key, value)
13369 
      for key, value in self.__dict__.iteritems()]
13370 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13371 
 
13372 
  def __eq__(self, other):
13373 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13374 
 
13375 
  def __ne__(self, other):
13376 
    return not (self == other)
13377 
 
13378 
class getNonDeliveredOrdersbyCourier_result:
13379 
  """
13380 
  Attributes:
13381 
   - success
13382 
  """
13383 
 
13384 
  thrift_spec = (
13385 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
13386 
  )
13387 
 
13388 
  def __init__(self, success=None,):
13389 
    self.success = success
13390 
 
13391 
  def read(self, iprot):
13392 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13393 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13394 
      return
13395 
    iprot.readStructBegin()
13396 
    while True:
13397 
      (fname, ftype, fid) = iprot.readFieldBegin()
13398 
      if ftype == TType.STOP:
13399 
        break
4581 phani.kuma 13400 
      if fid == 0:
13401 
        if ftype == TType.LIST:
13402 
          self.success = []
5411 rajveer 13403 
          (_etype298, _size295) = iprot.readListBegin()
13404 
          for _i299 in xrange(_size295):
13405 
            _elem300 = Order()
13406 
            _elem300.read(iprot)
13407 
            self.success.append(_elem300)
4581 phani.kuma 13408 
          iprot.readListEnd()
13409 
        else:
13410 
          iprot.skip(ftype)
4910 phani.kuma 13411 
      else:
13412 
        iprot.skip(ftype)
13413 
      iprot.readFieldEnd()
13414 
    iprot.readStructEnd()
13415 
 
13416 
  def write(self, oprot):
13417 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13418 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13419 
      return
13420 
    oprot.writeStructBegin('getNonDeliveredOrdersbyCourier_result')
13421 
    if self.success is not None:
13422 
      oprot.writeFieldBegin('success', TType.LIST, 0)
13423 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
5411 rajveer 13424 
      for iter301 in self.success:
13425 
        iter301.write(oprot)
4910 phani.kuma 13426 
      oprot.writeListEnd()
13427 
      oprot.writeFieldEnd()
13428 
    oprot.writeFieldStop()
13429 
    oprot.writeStructEnd()
13430 
 
13431 
  def validate(self):
13432 
    return
13433 
 
13434 
 
13435 
  def __repr__(self):
13436 
    L = ['%s=%r' % (key, value)
13437 
      for key, value in self.__dict__.iteritems()]
13438 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13439 
 
13440 
  def __eq__(self, other):
13441 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13442 
 
13443 
  def __ne__(self, other):
13444 
    return not (self == other)
13445 
 
13446 
class markOrdersAsLocalConnected_args:
13447 
  """
13448 
  Attributes:
13449 
   - providerId
13450 
   - local_connected_orders
13451 
  """
13452 
 
13453 
  thrift_spec = (
13454 
    None, # 0
13455 
    (1, TType.I64, 'providerId', None, None, ), # 1
13456 
    (2, TType.MAP, 'local_connected_orders', (TType.STRING,None,TType.STRING,None), None, ), # 2
13457 
  )
13458 
 
13459 
  def __init__(self, providerId=None, local_connected_orders=None,):
13460 
    self.providerId = providerId
13461 
    self.local_connected_orders = local_connected_orders
13462 
 
13463 
  def read(self, iprot):
13464 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13465 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13466 
      return
13467 
    iprot.readStructBegin()
13468 
    while True:
13469 
      (fname, ftype, fid) = iprot.readFieldBegin()
13470 
      if ftype == TType.STOP:
13471 
        break
13472 
      if fid == 1:
13473 
        if ftype == TType.I64:
13474 
          self.providerId = iprot.readI64();
13475 
        else:
13476 
          iprot.skip(ftype)
13477 
      elif fid == 2:
13478 
        if ftype == TType.MAP:
13479 
          self.local_connected_orders = {}
5411 rajveer 13480 
          (_ktype303, _vtype304, _size302 ) = iprot.readMapBegin()
13481 
          for _i306 in xrange(_size302):
13482 
            _key307 = iprot.readString();
13483 
            _val308 = iprot.readString();
13484 
            self.local_connected_orders[_key307] = _val308
4910 phani.kuma 13485 
          iprot.readMapEnd()
13486 
        else:
13487 
          iprot.skip(ftype)
13488 
      else:
13489 
        iprot.skip(ftype)
13490 
      iprot.readFieldEnd()
13491 
    iprot.readStructEnd()
13492 
 
13493 
  def write(self, oprot):
13494 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13495 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13496 
      return
13497 
    oprot.writeStructBegin('markOrdersAsLocalConnected_args')
13498 
    if self.providerId is not None:
13499 
      oprot.writeFieldBegin('providerId', TType.I64, 1)
13500 
      oprot.writeI64(self.providerId)
13501 
      oprot.writeFieldEnd()
13502 
    if self.local_connected_orders is not None:
13503 
      oprot.writeFieldBegin('local_connected_orders', TType.MAP, 2)
13504 
      oprot.writeMapBegin(TType.STRING, TType.STRING, len(self.local_connected_orders))
5411 rajveer 13505 
      for kiter309,viter310 in self.local_connected_orders.items():
13506 
        oprot.writeString(kiter309)
13507 
        oprot.writeString(viter310)
4910 phani.kuma 13508 
      oprot.writeMapEnd()
13509 
      oprot.writeFieldEnd()
13510 
    oprot.writeFieldStop()
13511 
    oprot.writeStructEnd()
13512 
 
13513 
  def validate(self):
13514 
    return
13515 
 
13516 
 
13517 
  def __repr__(self):
13518 
    L = ['%s=%r' % (key, value)
13519 
      for key, value in self.__dict__.iteritems()]
13520 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13521 
 
13522 
  def __eq__(self, other):
13523 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13524 
 
13525 
  def __ne__(self, other):
13526 
    return not (self == other)
13527 
 
13528 
class markOrdersAsLocalConnected_result:
13529 
  """
13530 
  Attributes:
13531 
   - ex
13532 
  """
13533 
 
13534 
  thrift_spec = (
13535 
    None, # 0
13536 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
13537 
  )
13538 
 
13539 
  def __init__(self, ex=None,):
13540 
    self.ex = ex
13541 
 
13542 
  def read(self, iprot):
13543 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13544 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13545 
      return
13546 
    iprot.readStructBegin()
13547 
    while True:
13548 
      (fname, ftype, fid) = iprot.readFieldBegin()
13549 
      if ftype == TType.STOP:
13550 
        break
13551 
      if fid == 1:
3064 chandransh 13552 
        if ftype == TType.STRUCT:
13553 
          self.ex = TransactionServiceException()
13554 
          self.ex.read(iprot)
1627 ankur.sing 13555 
        else:
13556 
          iprot.skip(ftype)
13557 
      else:
13558 
        iprot.skip(ftype)
13559 
      iprot.readFieldEnd()
13560 
    iprot.readStructEnd()
13561 
 
13562 
  def write(self, oprot):
13563 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13564 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13565 
      return
4910 phani.kuma 13566 
    oprot.writeStructBegin('markOrdersAsLocalConnected_result')
13567 
    if self.ex is not None:
13568 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
13569 
      self.ex.write(oprot)
13570 
      oprot.writeFieldEnd()
13571 
    oprot.writeFieldStop()
13572 
    oprot.writeStructEnd()
13573 
 
13574 
  def validate(self):
13575 
    return
13576 
 
13577 
 
13578 
  def __repr__(self):
13579 
    L = ['%s=%r' % (key, value)
13580 
      for key, value in self.__dict__.iteritems()]
13581 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13582 
 
13583 
  def __eq__(self, other):
13584 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13585 
 
13586 
  def __ne__(self, other):
13587 
    return not (self == other)
13588 
 
13589 
class getOrdersNotLocalConnected_args:
13590 
  """
13591 
  Attributes:
13592 
   - providerId
13593 
  """
13594 
 
13595 
  thrift_spec = (
13596 
    None, # 0
13597 
    (1, TType.I64, 'providerId', None, None, ), # 1
13598 
  )
13599 
 
13600 
  def __init__(self, providerId=None,):
13601 
    self.providerId = providerId
13602 
 
13603 
  def read(self, iprot):
13604 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13605 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13606 
      return
13607 
    iprot.readStructBegin()
13608 
    while True:
13609 
      (fname, ftype, fid) = iprot.readFieldBegin()
13610 
      if ftype == TType.STOP:
13611 
        break
13612 
      if fid == 1:
13613 
        if ftype == TType.I64:
13614 
          self.providerId = iprot.readI64();
13615 
        else:
13616 
          iprot.skip(ftype)
13617 
      else:
13618 
        iprot.skip(ftype)
13619 
      iprot.readFieldEnd()
13620 
    iprot.readStructEnd()
13621 
 
13622 
  def write(self, oprot):
13623 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13624 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13625 
      return
13626 
    oprot.writeStructBegin('getOrdersNotLocalConnected_args')
13627 
    if self.providerId is not None:
13628 
      oprot.writeFieldBegin('providerId', TType.I64, 1)
13629 
      oprot.writeI64(self.providerId)
13630 
      oprot.writeFieldEnd()
13631 
    oprot.writeFieldStop()
13632 
    oprot.writeStructEnd()
13633 
 
13634 
  def validate(self):
13635 
    return
13636 
 
13637 
 
13638 
  def __repr__(self):
13639 
    L = ['%s=%r' % (key, value)
13640 
      for key, value in self.__dict__.iteritems()]
13641 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13642 
 
13643 
  def __eq__(self, other):
13644 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13645 
 
13646 
  def __ne__(self, other):
13647 
    return not (self == other)
13648 
 
13649 
class getOrdersNotLocalConnected_result:
13650 
  """
13651 
  Attributes:
13652 
   - success
13653 
  """
13654 
 
13655 
  thrift_spec = (
13656 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
13657 
  )
13658 
 
13659 
  def __init__(self, success=None,):
13660 
    self.success = success
13661 
 
13662 
  def read(self, iprot):
13663 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13664 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13665 
      return
13666 
    iprot.readStructBegin()
13667 
    while True:
13668 
      (fname, ftype, fid) = iprot.readFieldBegin()
13669 
      if ftype == TType.STOP:
13670 
        break
13671 
      if fid == 0:
13672 
        if ftype == TType.LIST:
13673 
          self.success = []
5411 rajveer 13674 
          (_etype314, _size311) = iprot.readListBegin()
13675 
          for _i315 in xrange(_size311):
13676 
            _elem316 = Order()
13677 
            _elem316.read(iprot)
13678 
            self.success.append(_elem316)
4910 phani.kuma 13679 
          iprot.readListEnd()
13680 
        else:
13681 
          iprot.skip(ftype)
13682 
      else:
13683 
        iprot.skip(ftype)
13684 
      iprot.readFieldEnd()
13685 
    iprot.readStructEnd()
13686 
 
13687 
  def write(self, oprot):
13688 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13689 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13690 
      return
13691 
    oprot.writeStructBegin('getOrdersNotLocalConnected_result')
4581 phani.kuma 13692 
    if self.success is not None:
13693 
      oprot.writeFieldBegin('success', TType.LIST, 0)
13694 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
5411 rajveer 13695 
      for iter317 in self.success:
13696 
        iter317.write(oprot)
4581 phani.kuma 13697 
      oprot.writeListEnd()
13698 
      oprot.writeFieldEnd()
4910 phani.kuma 13699 
    oprot.writeFieldStop()
13700 
    oprot.writeStructEnd()
13701 
 
13702 
  def validate(self):
13703 
    return
13704 
 
13705 
 
13706 
  def __repr__(self):
13707 
    L = ['%s=%r' % (key, value)
13708 
      for key, value in self.__dict__.iteritems()]
13709 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13710 
 
13711 
  def __eq__(self, other):
13712 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13713 
 
13714 
  def __ne__(self, other):
13715 
    return not (self == other)
13716 
 
13717 
class markOrdersAsDestinationCityReached_args:
13718 
  """
13719 
  Attributes:
13720 
   - providerId
13721 
   - destination_city_reached_orders
13722 
  """
13723 
 
13724 
  thrift_spec = (
13725 
    None, # 0
13726 
    (1, TType.I64, 'providerId', None, None, ), # 1
13727 
    (2, TType.MAP, 'destination_city_reached_orders', (TType.STRING,None,TType.STRING,None), None, ), # 2
13728 
  )
13729 
 
13730 
  def __init__(self, providerId=None, destination_city_reached_orders=None,):
13731 
    self.providerId = providerId
13732 
    self.destination_city_reached_orders = destination_city_reached_orders
13733 
 
13734 
  def read(self, iprot):
13735 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13736 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13737 
      return
13738 
    iprot.readStructBegin()
13739 
    while True:
13740 
      (fname, ftype, fid) = iprot.readFieldBegin()
13741 
      if ftype == TType.STOP:
13742 
        break
13743 
      if fid == 1:
13744 
        if ftype == TType.I64:
13745 
          self.providerId = iprot.readI64();
13746 
        else:
13747 
          iprot.skip(ftype)
13748 
      elif fid == 2:
13749 
        if ftype == TType.MAP:
13750 
          self.destination_city_reached_orders = {}
5411 rajveer 13751 
          (_ktype319, _vtype320, _size318 ) = iprot.readMapBegin()
13752 
          for _i322 in xrange(_size318):
13753 
            _key323 = iprot.readString();
13754 
            _val324 = iprot.readString();
13755 
            self.destination_city_reached_orders[_key323] = _val324
4910 phani.kuma 13756 
          iprot.readMapEnd()
13757 
        else:
13758 
          iprot.skip(ftype)
13759 
      else:
13760 
        iprot.skip(ftype)
13761 
      iprot.readFieldEnd()
13762 
    iprot.readStructEnd()
13763 
 
13764 
  def write(self, oprot):
13765 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13766 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13767 
      return
13768 
    oprot.writeStructBegin('markOrdersAsDestinationCityReached_args')
13769 
    if self.providerId is not None:
13770 
      oprot.writeFieldBegin('providerId', TType.I64, 1)
13771 
      oprot.writeI64(self.providerId)
13772 
      oprot.writeFieldEnd()
13773 
    if self.destination_city_reached_orders is not None:
13774 
      oprot.writeFieldBegin('destination_city_reached_orders', TType.MAP, 2)
13775 
      oprot.writeMapBegin(TType.STRING, TType.STRING, len(self.destination_city_reached_orders))
5411 rajveer 13776 
      for kiter325,viter326 in self.destination_city_reached_orders.items():
13777 
        oprot.writeString(kiter325)
13778 
        oprot.writeString(viter326)
4910 phani.kuma 13779 
      oprot.writeMapEnd()
13780 
      oprot.writeFieldEnd()
13781 
    oprot.writeFieldStop()
13782 
    oprot.writeStructEnd()
13783 
 
13784 
  def validate(self):
13785 
    return
13786 
 
13787 
 
13788 
  def __repr__(self):
13789 
    L = ['%s=%r' % (key, value)
13790 
      for key, value in self.__dict__.iteritems()]
13791 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13792 
 
13793 
  def __eq__(self, other):
13794 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13795 
 
13796 
  def __ne__(self, other):
13797 
    return not (self == other)
13798 
 
13799 
class markOrdersAsDestinationCityReached_result:
13800 
  """
13801 
  Attributes:
13802 
   - ex
13803 
  """
13804 
 
13805 
  thrift_spec = (
13806 
    None, # 0
13807 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
13808 
  )
13809 
 
13810 
  def __init__(self, ex=None,):
13811 
    self.ex = ex
13812 
 
13813 
  def read(self, iprot):
13814 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13815 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13816 
      return
13817 
    iprot.readStructBegin()
13818 
    while True:
13819 
      (fname, ftype, fid) = iprot.readFieldBegin()
13820 
      if ftype == TType.STOP:
13821 
        break
13822 
      if fid == 1:
13823 
        if ftype == TType.STRUCT:
13824 
          self.ex = TransactionServiceException()
13825 
          self.ex.read(iprot)
13826 
        else:
13827 
          iprot.skip(ftype)
13828 
      else:
13829 
        iprot.skip(ftype)
13830 
      iprot.readFieldEnd()
13831 
    iprot.readStructEnd()
13832 
 
13833 
  def write(self, oprot):
13834 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13835 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13836 
      return
13837 
    oprot.writeStructBegin('markOrdersAsDestinationCityReached_result')
3431 rajveer 13838 
    if self.ex is not None:
3064 chandransh 13839 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
13840 
      self.ex.write(oprot)
1627 ankur.sing 13841 
      oprot.writeFieldEnd()
13842 
    oprot.writeFieldStop()
13843 
    oprot.writeStructEnd()
13844 
 
3431 rajveer 13845 
  def validate(self):
13846 
    return
13847 
 
13848 
 
1627 ankur.sing 13849 
  def __repr__(self):
13850 
    L = ['%s=%r' % (key, value)
13851 
      for key, value in self.__dict__.iteritems()]
13852 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13853 
 
13854 
  def __eq__(self, other):
13855 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13856 
 
13857 
  def __ne__(self, other):
13858 
    return not (self == other)
13859 
 
4910 phani.kuma 13860 
class markOrdersAsFirstDeliveryAttempted_args:
13861 
  """
13862 
  Attributes:
13863 
   - providerId
13864 
   - first_atdl_orders
13865 
  """
13866 
 
13867 
  thrift_spec = (
13868 
    None, # 0
13869 
    (1, TType.I64, 'providerId', None, None, ), # 1
13870 
    (2, TType.MAP, 'first_atdl_orders', (TType.STRING,None,TType.STRING,None), None, ), # 2
13871 
  )
13872 
 
13873 
  def __init__(self, providerId=None, first_atdl_orders=None,):
13874 
    self.providerId = providerId
13875 
    self.first_atdl_orders = first_atdl_orders
13876 
 
13877 
  def read(self, iprot):
13878 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13879 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13880 
      return
13881 
    iprot.readStructBegin()
13882 
    while True:
13883 
      (fname, ftype, fid) = iprot.readFieldBegin()
13884 
      if ftype == TType.STOP:
13885 
        break
13886 
      if fid == 1:
13887 
        if ftype == TType.I64:
13888 
          self.providerId = iprot.readI64();
13889 
        else:
13890 
          iprot.skip(ftype)
13891 
      elif fid == 2:
13892 
        if ftype == TType.MAP:
13893 
          self.first_atdl_orders = {}
5411 rajveer 13894 
          (_ktype328, _vtype329, _size327 ) = iprot.readMapBegin()
13895 
          for _i331 in xrange(_size327):
13896 
            _key332 = iprot.readString();
13897 
            _val333 = iprot.readString();
13898 
            self.first_atdl_orders[_key332] = _val333
4910 phani.kuma 13899 
          iprot.readMapEnd()
13900 
        else:
13901 
          iprot.skip(ftype)
13902 
      else:
13903 
        iprot.skip(ftype)
13904 
      iprot.readFieldEnd()
13905 
    iprot.readStructEnd()
13906 
 
13907 
  def write(self, oprot):
13908 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13909 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13910 
      return
13911 
    oprot.writeStructBegin('markOrdersAsFirstDeliveryAttempted_args')
13912 
    if self.providerId is not None:
13913 
      oprot.writeFieldBegin('providerId', TType.I64, 1)
13914 
      oprot.writeI64(self.providerId)
13915 
      oprot.writeFieldEnd()
13916 
    if self.first_atdl_orders is not None:
13917 
      oprot.writeFieldBegin('first_atdl_orders', TType.MAP, 2)
13918 
      oprot.writeMapBegin(TType.STRING, TType.STRING, len(self.first_atdl_orders))
5411 rajveer 13919 
      for kiter334,viter335 in self.first_atdl_orders.items():
13920 
        oprot.writeString(kiter334)
13921 
        oprot.writeString(viter335)
4910 phani.kuma 13922 
      oprot.writeMapEnd()
13923 
      oprot.writeFieldEnd()
13924 
    oprot.writeFieldStop()
13925 
    oprot.writeStructEnd()
13926 
 
13927 
  def validate(self):
13928 
    return
13929 
 
13930 
 
13931 
  def __repr__(self):
13932 
    L = ['%s=%r' % (key, value)
13933 
      for key, value in self.__dict__.iteritems()]
13934 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13935 
 
13936 
  def __eq__(self, other):
13937 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13938 
 
13939 
  def __ne__(self, other):
13940 
    return not (self == other)
13941 
 
13942 
class markOrdersAsFirstDeliveryAttempted_result:
13943 
  """
13944 
  Attributes:
13945 
   - ex
13946 
  """
13947 
 
13948 
  thrift_spec = (
13949 
    None, # 0
13950 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
13951 
  )
13952 
 
13953 
  def __init__(self, ex=None,):
13954 
    self.ex = ex
13955 
 
13956 
  def read(self, iprot):
13957 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13958 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13959 
      return
13960 
    iprot.readStructBegin()
13961 
    while True:
13962 
      (fname, ftype, fid) = iprot.readFieldBegin()
13963 
      if ftype == TType.STOP:
13964 
        break
13965 
      if fid == 1:
13966 
        if ftype == TType.STRUCT:
13967 
          self.ex = TransactionServiceException()
13968 
          self.ex.read(iprot)
13969 
        else:
13970 
          iprot.skip(ftype)
13971 
      else:
13972 
        iprot.skip(ftype)
13973 
      iprot.readFieldEnd()
13974 
    iprot.readStructEnd()
13975 
 
13976 
  def write(self, oprot):
13977 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13978 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13979 
      return
13980 
    oprot.writeStructBegin('markOrdersAsFirstDeliveryAttempted_result')
13981 
    if self.ex is not None:
13982 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
13983 
      self.ex.write(oprot)
13984 
      oprot.writeFieldEnd()
13985 
    oprot.writeFieldStop()
13986 
    oprot.writeStructEnd()
13987 
 
13988 
  def validate(self):
13989 
    return
13990 
 
13991 
 
13992 
  def __repr__(self):
13993 
    L = ['%s=%r' % (key, value)
13994 
      for key, value in self.__dict__.iteritems()]
13995 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13996 
 
13997 
  def __eq__(self, other):
13998 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13999 
 
14000 
  def __ne__(self, other):
14001 
    return not (self == other)
14002 
 
3064 chandransh 14003 
class getUndeliveredOrders_args:
1886 ankur.sing 14004 
  """
14005 
  Attributes:
3064 chandransh 14006 
   - providerId
14007 
   - warehouseId
1886 ankur.sing 14008 
  """
1627 ankur.sing 14009 
 
1886 ankur.sing 14010 
  thrift_spec = (
14011 
    None, # 0
3064 chandransh 14012 
    (1, TType.I64, 'providerId', None, None, ), # 1
14013 
    (2, TType.I64, 'warehouseId', None, None, ), # 2
1886 ankur.sing 14014 
  )
14015 
 
3064 chandransh 14016 
  def __init__(self, providerId=None, warehouseId=None,):
14017 
    self.providerId = providerId
14018 
    self.warehouseId = warehouseId
1886 ankur.sing 14019 
 
14020 
  def read(self, iprot):
14021 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14022 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14023 
      return
14024 
    iprot.readStructBegin()
14025 
    while True:
14026 
      (fname, ftype, fid) = iprot.readFieldBegin()
14027 
      if ftype == TType.STOP:
14028 
        break
14029 
      if fid == 1:
14030 
        if ftype == TType.I64:
3064 chandransh 14031 
          self.providerId = iprot.readI64();
1886 ankur.sing 14032 
        else:
14033 
          iprot.skip(ftype)
3064 chandransh 14034 
      elif fid == 2:
14035 
        if ftype == TType.I64:
14036 
          self.warehouseId = iprot.readI64();
14037 
        else:
14038 
          iprot.skip(ftype)
1886 ankur.sing 14039 
      else:
14040 
        iprot.skip(ftype)
14041 
      iprot.readFieldEnd()
14042 
    iprot.readStructEnd()
14043 
 
14044 
  def write(self, oprot):
14045 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14046 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14047 
      return
3064 chandransh 14048 
    oprot.writeStructBegin('getUndeliveredOrders_args')
3431 rajveer 14049 
    if self.providerId is not None:
3064 chandransh 14050 
      oprot.writeFieldBegin('providerId', TType.I64, 1)
14051 
      oprot.writeI64(self.providerId)
1886 ankur.sing 14052 
      oprot.writeFieldEnd()
3431 rajveer 14053 
    if self.warehouseId is not None:
3064 chandransh 14054 
      oprot.writeFieldBegin('warehouseId', TType.I64, 2)
14055 
      oprot.writeI64(self.warehouseId)
14056 
      oprot.writeFieldEnd()
1886 ankur.sing 14057 
    oprot.writeFieldStop()
14058 
    oprot.writeStructEnd()
14059 
 
3431 rajveer 14060 
  def validate(self):
14061 
    return
14062 
 
14063 
 
1886 ankur.sing 14064 
  def __repr__(self):
14065 
    L = ['%s=%r' % (key, value)
14066 
      for key, value in self.__dict__.iteritems()]
14067 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14068 
 
14069 
  def __eq__(self, other):
14070 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14071 
 
14072 
  def __ne__(self, other):
14073 
    return not (self == other)
14074 
 
3064 chandransh 14075 
class getUndeliveredOrders_result:
1886 ankur.sing 14076 
  """
14077 
  Attributes:
14078 
   - success
14079 
  """
14080 
 
14081 
  thrift_spec = (
14082 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
14083 
  )
14084 
 
14085 
  def __init__(self, success=None,):
14086 
    self.success = success
14087 
 
14088 
  def read(self, iprot):
14089 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14090 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14091 
      return
14092 
    iprot.readStructBegin()
14093 
    while True:
14094 
      (fname, ftype, fid) = iprot.readFieldBegin()
14095 
      if ftype == TType.STOP:
14096 
        break
14097 
      if fid == 0:
14098 
        if ftype == TType.LIST:
14099 
          self.success = []
5411 rajveer 14100 
          (_etype339, _size336) = iprot.readListBegin()
14101 
          for _i340 in xrange(_size336):
14102 
            _elem341 = Order()
14103 
            _elem341.read(iprot)
14104 
            self.success.append(_elem341)
1886 ankur.sing 14105 
          iprot.readListEnd()
14106 
        else:
14107 
          iprot.skip(ftype)
14108 
      else:
14109 
        iprot.skip(ftype)
14110 
      iprot.readFieldEnd()
14111 
    iprot.readStructEnd()
14112 
 
14113 
  def write(self, oprot):
14114 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14115 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14116 
      return
3064 chandransh 14117 
    oprot.writeStructBegin('getUndeliveredOrders_result')
3431 rajveer 14118 
    if self.success is not None:
1886 ankur.sing 14119 
      oprot.writeFieldBegin('success', TType.LIST, 0)
14120 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
5411 rajveer 14121 
      for iter342 in self.success:
14122 
        iter342.write(oprot)
1886 ankur.sing 14123 
      oprot.writeListEnd()
14124 
      oprot.writeFieldEnd()
14125 
    oprot.writeFieldStop()
14126 
    oprot.writeStructEnd()
14127 
 
3431 rajveer 14128 
  def validate(self):
14129 
    return
14130 
 
14131 
 
1886 ankur.sing 14132 
  def __repr__(self):
14133 
    L = ['%s=%r' % (key, value)
14134 
      for key, value in self.__dict__.iteritems()]
14135 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14136 
 
14137 
  def __eq__(self, other):
14138 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14139 
 
14140 
  def __ne__(self, other):
14141 
    return not (self == other)
14142 
 
4783 phani.kuma 14143 
class getUndeliveredOrdersExpectedDeliveryDateNotMet_args:
14144 
 
14145 
  thrift_spec = (
14146 
  )
14147 
 
14148 
  def read(self, iprot):
14149 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14150 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14151 
      return
14152 
    iprot.readStructBegin()
14153 
    while True:
14154 
      (fname, ftype, fid) = iprot.readFieldBegin()
14155 
      if ftype == TType.STOP:
14156 
        break
14157 
      else:
14158 
        iprot.skip(ftype)
14159 
      iprot.readFieldEnd()
14160 
    iprot.readStructEnd()
14161 
 
14162 
  def write(self, oprot):
14163 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14164 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14165 
      return
14166 
    oprot.writeStructBegin('getUndeliveredOrdersExpectedDeliveryDateNotMet_args')
14167 
    oprot.writeFieldStop()
14168 
    oprot.writeStructEnd()
14169 
 
14170 
  def validate(self):
14171 
    return
14172 
 
14173 
 
14174 
  def __repr__(self):
14175 
    L = ['%s=%r' % (key, value)
14176 
      for key, value in self.__dict__.iteritems()]
14177 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14178 
 
14179 
  def __eq__(self, other):
14180 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14181 
 
14182 
  def __ne__(self, other):
14183 
    return not (self == other)
14184 
 
14185 
class getUndeliveredOrdersExpectedDeliveryDateNotMet_result:
14186 
  """
14187 
  Attributes:
14188 
   - success
14189 
  """
14190 
 
14191 
  thrift_spec = (
14192 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
14193 
  )
14194 
 
14195 
  def __init__(self, success=None,):
14196 
    self.success = success
14197 
 
14198 
  def read(self, iprot):
14199 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14200 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14201 
      return
14202 
    iprot.readStructBegin()
14203 
    while True:
14204 
      (fname, ftype, fid) = iprot.readFieldBegin()
14205 
      if ftype == TType.STOP:
14206 
        break
14207 
      if fid == 0:
14208 
        if ftype == TType.LIST:
14209 
          self.success = []
5411 rajveer 14210 
          (_etype346, _size343) = iprot.readListBegin()
14211 
          for _i347 in xrange(_size343):
14212 
            _elem348 = Order()
14213 
            _elem348.read(iprot)
14214 
            self.success.append(_elem348)
4783 phani.kuma 14215 
          iprot.readListEnd()
14216 
        else:
14217 
          iprot.skip(ftype)
14218 
      else:
14219 
        iprot.skip(ftype)
14220 
      iprot.readFieldEnd()
14221 
    iprot.readStructEnd()
14222 
 
14223 
  def write(self, oprot):
14224 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14225 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14226 
      return
14227 
    oprot.writeStructBegin('getUndeliveredOrdersExpectedDeliveryDateNotMet_result')
14228 
    if self.success is not None:
14229 
      oprot.writeFieldBegin('success', TType.LIST, 0)
14230 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
5411 rajveer 14231 
      for iter349 in self.success:
14232 
        iter349.write(oprot)
4783 phani.kuma 14233 
      oprot.writeListEnd()
14234 
      oprot.writeFieldEnd()
14235 
    oprot.writeFieldStop()
14236 
    oprot.writeStructEnd()
14237 
 
14238 
  def validate(self):
14239 
    return
14240 
 
14241 
 
14242 
  def __repr__(self):
14243 
    L = ['%s=%r' % (key, value)
14244 
      for key, value in self.__dict__.iteritems()]
14245 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14246 
 
14247 
  def __eq__(self, other):
14248 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14249 
 
14250 
  def __ne__(self, other):
14251 
    return not (self == other)
14252 
 
2536 chandransh 14253 
class toggleDOAFlag_args:
14254 
  """
14255 
  Attributes:
14256 
   - orderId
14257 
  """
1886 ankur.sing 14258 
 
2536 chandransh 14259 
  thrift_spec = (
14260 
    None, # 0
14261 
    (1, TType.I64, 'orderId', None, None, ), # 1
14262 
  )
14263 
 
14264 
  def __init__(self, orderId=None,):
14265 
    self.orderId = orderId
14266 
 
14267 
  def read(self, iprot):
14268 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14269 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14270 
      return
14271 
    iprot.readStructBegin()
14272 
    while True:
14273 
      (fname, ftype, fid) = iprot.readFieldBegin()
14274 
      if ftype == TType.STOP:
14275 
        break
14276 
      if fid == 1:
14277 
        if ftype == TType.I64:
14278 
          self.orderId = iprot.readI64();
14279 
        else:
14280 
          iprot.skip(ftype)
14281 
      else:
14282 
        iprot.skip(ftype)
14283 
      iprot.readFieldEnd()
14284 
    iprot.readStructEnd()
14285 
 
14286 
  def write(self, oprot):
14287 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14288 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14289 
      return
14290 
    oprot.writeStructBegin('toggleDOAFlag_args')
3431 rajveer 14291 
    if self.orderId is not None:
2536 chandransh 14292 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
14293 
      oprot.writeI64(self.orderId)
14294 
      oprot.writeFieldEnd()
14295 
    oprot.writeFieldStop()
14296 
    oprot.writeStructEnd()
14297 
 
3431 rajveer 14298 
  def validate(self):
14299 
    return
14300 
 
14301 
 
2536 chandransh 14302 
  def __repr__(self):
14303 
    L = ['%s=%r' % (key, value)
14304 
      for key, value in self.__dict__.iteritems()]
14305 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14306 
 
14307 
  def __eq__(self, other):
14308 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14309 
 
14310 
  def __ne__(self, other):
14311 
    return not (self == other)
14312 
 
14313 
class toggleDOAFlag_result:
14314 
  """
14315 
  Attributes:
14316 
   - success
14317 
   - ex
14318 
  """
14319 
 
14320 
  thrift_spec = (
14321 
    (0, TType.BOOL, 'success', None, None, ), # 0
14322 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
14323 
  )
14324 
 
14325 
  def __init__(self, success=None, ex=None,):
14326 
    self.success = success
14327 
    self.ex = ex
14328 
 
14329 
  def read(self, iprot):
14330 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14331 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14332 
      return
14333 
    iprot.readStructBegin()
14334 
    while True:
14335 
      (fname, ftype, fid) = iprot.readFieldBegin()
14336 
      if ftype == TType.STOP:
14337 
        break
14338 
      if fid == 0:
14339 
        if ftype == TType.BOOL:
14340 
          self.success = iprot.readBool();
14341 
        else:
14342 
          iprot.skip(ftype)
14343 
      elif fid == 1:
14344 
        if ftype == TType.STRUCT:
14345 
          self.ex = TransactionServiceException()
14346 
          self.ex.read(iprot)
14347 
        else:
14348 
          iprot.skip(ftype)
14349 
      else:
14350 
        iprot.skip(ftype)
14351 
      iprot.readFieldEnd()
14352 
    iprot.readStructEnd()
14353 
 
14354 
  def write(self, oprot):
14355 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14356 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14357 
      return
14358 
    oprot.writeStructBegin('toggleDOAFlag_result')
3431 rajveer 14359 
    if self.success is not None:
2536 chandransh 14360 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
14361 
      oprot.writeBool(self.success)
14362 
      oprot.writeFieldEnd()
3431 rajveer 14363 
    if self.ex is not None:
2536 chandransh 14364 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
14365 
      self.ex.write(oprot)
14366 
      oprot.writeFieldEnd()
14367 
    oprot.writeFieldStop()
14368 
    oprot.writeStructEnd()
14369 
 
3431 rajveer 14370 
  def validate(self):
14371 
    return
14372 
 
14373 
 
2536 chandransh 14374 
  def __repr__(self):
14375 
    L = ['%s=%r' % (key, value)
14376 
      for key, value in self.__dict__.iteritems()]
14377 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14378 
 
14379 
  def __eq__(self, other):
14380 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14381 
 
14382 
  def __ne__(self, other):
14383 
    return not (self == other)
14384 
 
4712 rajveer 14385 
class markOrderAsDelivered_args:
14386 
  """
14387 
  Attributes:
14388 
   - orderId
14389 
   - deliveryTimestamp
14390 
   - receiver
14391 
  """
14392 
 
14393 
  thrift_spec = None
14394 
  def __init__(self, orderId=None, deliveryTimestamp=None, receiver=None,):
14395 
    self.orderId = orderId
14396 
    self.deliveryTimestamp = deliveryTimestamp
14397 
    self.receiver = receiver
14398 
 
14399 
  def read(self, iprot):
14400 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14401 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14402 
      return
14403 
    iprot.readStructBegin()
14404 
    while True:
14405 
      (fname, ftype, fid) = iprot.readFieldBegin()
14406 
      if ftype == TType.STOP:
14407 
        break
14408 
      if fid == 1:
14409 
        if ftype == TType.I64:
14410 
          self.orderId = iprot.readI64();
14411 
        else:
14412 
          iprot.skip(ftype)
14413 
      elif fid == 2:
14414 
        if ftype == TType.I64:
14415 
          self.deliveryTimestamp = iprot.readI64();
14416 
        else:
14417 
          iprot.skip(ftype)
14418 
      elif fid == -1:
14419 
        if ftype == TType.STRING:
14420 
          self.receiver = iprot.readString();
14421 
        else:
14422 
          iprot.skip(ftype)
14423 
      else:
14424 
        iprot.skip(ftype)
14425 
      iprot.readFieldEnd()
14426 
    iprot.readStructEnd()
14427 
 
14428 
  def write(self, oprot):
14429 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14430 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14431 
      return
14432 
    oprot.writeStructBegin('markOrderAsDelivered_args')
14433 
    if self.receiver is not None:
14434 
      oprot.writeFieldBegin('receiver', TType.STRING, -1)
14435 
      oprot.writeString(self.receiver)
14436 
      oprot.writeFieldEnd()
14437 
    if self.orderId is not None:
14438 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
14439 
      oprot.writeI64(self.orderId)
14440 
      oprot.writeFieldEnd()
14441 
    if self.deliveryTimestamp is not None:
14442 
      oprot.writeFieldBegin('deliveryTimestamp', TType.I64, 2)
14443 
      oprot.writeI64(self.deliveryTimestamp)
14444 
      oprot.writeFieldEnd()
14445 
    oprot.writeFieldStop()
14446 
    oprot.writeStructEnd()
14447 
 
14448 
  def validate(self):
14449 
    return
14450 
 
14451 
 
14452 
  def __repr__(self):
14453 
    L = ['%s=%r' % (key, value)
14454 
      for key, value in self.__dict__.iteritems()]
14455 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14456 
 
14457 
  def __eq__(self, other):
14458 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14459 
 
14460 
  def __ne__(self, other):
14461 
    return not (self == other)
14462 
 
14463 
class markOrderAsDelivered_result:
14464 
  """
14465 
  Attributes:
14466 
   - ex
14467 
  """
14468 
 
14469 
  thrift_spec = (
14470 
    None, # 0
14471 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
14472 
  )
14473 
 
14474 
  def __init__(self, ex=None,):
14475 
    self.ex = ex
14476 
 
14477 
  def read(self, iprot):
14478 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14479 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14480 
      return
14481 
    iprot.readStructBegin()
14482 
    while True:
14483 
      (fname, ftype, fid) = iprot.readFieldBegin()
14484 
      if ftype == TType.STOP:
14485 
        break
14486 
      if fid == 1:
14487 
        if ftype == TType.STRUCT:
14488 
          self.ex = TransactionServiceException()
14489 
          self.ex.read(iprot)
14490 
        else:
14491 
          iprot.skip(ftype)
14492 
      else:
14493 
        iprot.skip(ftype)
14494 
      iprot.readFieldEnd()
14495 
    iprot.readStructEnd()
14496 
 
14497 
  def write(self, oprot):
14498 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14499 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14500 
      return
14501 
    oprot.writeStructBegin('markOrderAsDelivered_result')
14502 
    if self.ex is not None:
14503 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
14504 
      self.ex.write(oprot)
14505 
      oprot.writeFieldEnd()
14506 
    oprot.writeFieldStop()
14507 
    oprot.writeStructEnd()
14508 
 
14509 
  def validate(self):
14510 
    return
14511 
 
14512 
 
14513 
  def __repr__(self):
14514 
    L = ['%s=%r' % (key, value)
14515 
      for key, value in self.__dict__.iteritems()]
14516 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14517 
 
14518 
  def __eq__(self, other):
14519 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14520 
 
14521 
  def __ne__(self, other):
14522 
    return not (self == other)
14523 
 
4454 rajveer 14524 
class markOrderDoaRequestReceived_args:
14525 
  """
14526 
  Attributes:
14527 
   - orderId
14528 
  """
14529 
 
14530 
  thrift_spec = (
14531 
    None, # 0
14532 
    (1, TType.I64, 'orderId', None, None, ), # 1
14533 
  )
14534 
 
14535 
  def __init__(self, orderId=None,):
14536 
    self.orderId = orderId
14537 
 
14538 
  def read(self, iprot):
14539 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14540 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14541 
      return
14542 
    iprot.readStructBegin()
14543 
    while True:
14544 
      (fname, ftype, fid) = iprot.readFieldBegin()
14545 
      if ftype == TType.STOP:
14546 
        break
14547 
      if fid == 1:
14548 
        if ftype == TType.I64:
14549 
          self.orderId = iprot.readI64();
14550 
        else:
14551 
          iprot.skip(ftype)
14552 
      else:
14553 
        iprot.skip(ftype)
14554 
      iprot.readFieldEnd()
14555 
    iprot.readStructEnd()
14556 
 
14557 
  def write(self, oprot):
14558 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14559 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14560 
      return
14561 
    oprot.writeStructBegin('markOrderDoaRequestReceived_args')
14562 
    if self.orderId is not None:
14563 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
14564 
      oprot.writeI64(self.orderId)
14565 
      oprot.writeFieldEnd()
14566 
    oprot.writeFieldStop()
14567 
    oprot.writeStructEnd()
14568 
 
14569 
  def validate(self):
14570 
    return
14571 
 
14572 
 
14573 
  def __repr__(self):
14574 
    L = ['%s=%r' % (key, value)
14575 
      for key, value in self.__dict__.iteritems()]
14576 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14577 
 
14578 
  def __eq__(self, other):
14579 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14580 
 
14581 
  def __ne__(self, other):
14582 
    return not (self == other)
14583 
 
14584 
class markOrderDoaRequestReceived_result:
14585 
  """
14586 
  Attributes:
14587 
   - success
14588 
   - ex
14589 
  """
14590 
 
14591 
  thrift_spec = (
14592 
    (0, TType.BOOL, 'success', None, None, ), # 0
14593 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
14594 
  )
14595 
 
14596 
  def __init__(self, success=None, ex=None,):
14597 
    self.success = success
14598 
    self.ex = ex
14599 
 
14600 
  def read(self, iprot):
14601 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14602 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14603 
      return
14604 
    iprot.readStructBegin()
14605 
    while True:
14606 
      (fname, ftype, fid) = iprot.readFieldBegin()
14607 
      if ftype == TType.STOP:
14608 
        break
14609 
      if fid == 0:
14610 
        if ftype == TType.BOOL:
14611 
          self.success = iprot.readBool();
14612 
        else:
14613 
          iprot.skip(ftype)
14614 
      elif fid == 1:
14615 
        if ftype == TType.STRUCT:
14616 
          self.ex = TransactionServiceException()
14617 
          self.ex.read(iprot)
14618 
        else:
14619 
          iprot.skip(ftype)
14620 
      else:
14621 
        iprot.skip(ftype)
14622 
      iprot.readFieldEnd()
14623 
    iprot.readStructEnd()
14624 
 
14625 
  def write(self, oprot):
14626 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14627 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14628 
      return
14629 
    oprot.writeStructBegin('markOrderDoaRequestReceived_result')
14630 
    if self.success is not None:
14631 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
14632 
      oprot.writeBool(self.success)
14633 
      oprot.writeFieldEnd()
14634 
    if self.ex is not None:
14635 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
14636 
      self.ex.write(oprot)
14637 
      oprot.writeFieldEnd()
14638 
    oprot.writeFieldStop()
14639 
    oprot.writeStructEnd()
14640 
 
14641 
  def validate(self):
14642 
    return
14643 
 
14644 
 
14645 
  def __repr__(self):
14646 
    L = ['%s=%r' % (key, value)
14647 
      for key, value in self.__dict__.iteritems()]
14648 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14649 
 
14650 
  def __eq__(self, other):
14651 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14652 
 
14653 
  def __ne__(self, other):
14654 
    return not (self == other)
14655 
 
14656 
class markOrderDoaRequestAuthorized_args:
14657 
  """
14658 
  Attributes:
14659 
   - orderId
14660 
   - isAuthorized
14661 
  """
14662 
 
14663 
  thrift_spec = (
14664 
    None, # 0
14665 
    (1, TType.I64, 'orderId', None, None, ), # 1
14666 
    (2, TType.BOOL, 'isAuthorized', None, None, ), # 2
14667 
  )
14668 
 
14669 
  def __init__(self, orderId=None, isAuthorized=None,):
14670 
    self.orderId = orderId
14671 
    self.isAuthorized = isAuthorized
14672 
 
14673 
  def read(self, iprot):
14674 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14675 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14676 
      return
14677 
    iprot.readStructBegin()
14678 
    while True:
14679 
      (fname, ftype, fid) = iprot.readFieldBegin()
14680 
      if ftype == TType.STOP:
14681 
        break
14682 
      if fid == 1:
14683 
        if ftype == TType.I64:
14684 
          self.orderId = iprot.readI64();
14685 
        else:
14686 
          iprot.skip(ftype)
14687 
      elif fid == 2:
14688 
        if ftype == TType.BOOL:
14689 
          self.isAuthorized = iprot.readBool();
14690 
        else:
14691 
          iprot.skip(ftype)
14692 
      else:
14693 
        iprot.skip(ftype)
14694 
      iprot.readFieldEnd()
14695 
    iprot.readStructEnd()
14696 
 
14697 
  def write(self, oprot):
14698 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14699 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14700 
      return
14701 
    oprot.writeStructBegin('markOrderDoaRequestAuthorized_args')
14702 
    if self.orderId is not None:
14703 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
14704 
      oprot.writeI64(self.orderId)
14705 
      oprot.writeFieldEnd()
14706 
    if self.isAuthorized is not None:
14707 
      oprot.writeFieldBegin('isAuthorized', TType.BOOL, 2)
14708 
      oprot.writeBool(self.isAuthorized)
14709 
      oprot.writeFieldEnd()
14710 
    oprot.writeFieldStop()
14711 
    oprot.writeStructEnd()
14712 
 
14713 
  def validate(self):
14714 
    return
14715 
 
14716 
 
14717 
  def __repr__(self):
14718 
    L = ['%s=%r' % (key, value)
14719 
      for key, value in self.__dict__.iteritems()]
14720 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14721 
 
14722 
  def __eq__(self, other):
14723 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14724 
 
14725 
  def __ne__(self, other):
14726 
    return not (self == other)
14727 
 
14728 
class markOrderDoaRequestAuthorized_result:
14729 
  """
14730 
  Attributes:
14731 
   - success
14732 
   - ex
14733 
  """
14734 
 
14735 
  thrift_spec = (
14736 
    (0, TType.BOOL, 'success', None, None, ), # 0
14737 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
14738 
  )
14739 
 
14740 
  def __init__(self, success=None, ex=None,):
14741 
    self.success = success
14742 
    self.ex = ex
14743 
 
14744 
  def read(self, iprot):
14745 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14746 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14747 
      return
14748 
    iprot.readStructBegin()
14749 
    while True:
14750 
      (fname, ftype, fid) = iprot.readFieldBegin()
14751 
      if ftype == TType.STOP:
14752 
        break
14753 
      if fid == 0:
14754 
        if ftype == TType.BOOL:
14755 
          self.success = iprot.readBool();
14756 
        else:
14757 
          iprot.skip(ftype)
14758 
      elif fid == 1:
14759 
        if ftype == TType.STRUCT:
14760 
          self.ex = TransactionServiceException()
14761 
          self.ex.read(iprot)
14762 
        else:
14763 
          iprot.skip(ftype)
14764 
      else:
14765 
        iprot.skip(ftype)
14766 
      iprot.readFieldEnd()
14767 
    iprot.readStructEnd()
14768 
 
14769 
  def write(self, oprot):
14770 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14771 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14772 
      return
14773 
    oprot.writeStructBegin('markOrderDoaRequestAuthorized_result')
14774 
    if self.success is not None:
14775 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
14776 
      oprot.writeBool(self.success)
14777 
      oprot.writeFieldEnd()
14778 
    if self.ex is not None:
14779 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
14780 
      self.ex.write(oprot)
14781 
      oprot.writeFieldEnd()
14782 
    oprot.writeFieldStop()
14783 
    oprot.writeStructEnd()
14784 
 
14785 
  def validate(self):
14786 
    return
14787 
 
14788 
 
14789 
  def __repr__(self):
14790 
    L = ['%s=%r' % (key, value)
14791 
      for key, value in self.__dict__.iteritems()]
14792 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14793 
 
14794 
  def __eq__(self, other):
14795 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14796 
 
14797 
  def __ne__(self, other):
14798 
    return not (self == other)
14799 
 
4488 rajveer 14800 
class markOrderReturnRequestReceived_args:
14801 
  """
14802 
  Attributes:
14803 
   - orderId
14804 
  """
14805 
 
14806 
  thrift_spec = (
14807 
    None, # 0
14808 
    (1, TType.I64, 'orderId', None, None, ), # 1
14809 
  )
14810 
 
14811 
  def __init__(self, orderId=None,):
14812 
    self.orderId = orderId
14813 
 
14814 
  def read(self, iprot):
14815 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14816 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14817 
      return
14818 
    iprot.readStructBegin()
14819 
    while True:
14820 
      (fname, ftype, fid) = iprot.readFieldBegin()
14821 
      if ftype == TType.STOP:
14822 
        break
14823 
      if fid == 1:
14824 
        if ftype == TType.I64:
14825 
          self.orderId = iprot.readI64();
14826 
        else:
14827 
          iprot.skip(ftype)
14828 
      else:
14829 
        iprot.skip(ftype)
14830 
      iprot.readFieldEnd()
14831 
    iprot.readStructEnd()
14832 
 
14833 
  def write(self, oprot):
14834 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14835 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14836 
      return
14837 
    oprot.writeStructBegin('markOrderReturnRequestReceived_args')
14838 
    if self.orderId is not None:
14839 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
14840 
      oprot.writeI64(self.orderId)
14841 
      oprot.writeFieldEnd()
14842 
    oprot.writeFieldStop()
14843 
    oprot.writeStructEnd()
14844 
 
14845 
  def validate(self):
14846 
    return
14847 
 
14848 
 
14849 
  def __repr__(self):
14850 
    L = ['%s=%r' % (key, value)
14851 
      for key, value in self.__dict__.iteritems()]
14852 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14853 
 
14854 
  def __eq__(self, other):
14855 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14856 
 
14857 
  def __ne__(self, other):
14858 
    return not (self == other)
14859 
 
14860 
class markOrderReturnRequestReceived_result:
14861 
  """
14862 
  Attributes:
14863 
   - success
14864 
   - ex
14865 
  """
14866 
 
14867 
  thrift_spec = (
14868 
    (0, TType.BOOL, 'success', None, None, ), # 0
14869 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
14870 
  )
14871 
 
14872 
  def __init__(self, success=None, ex=None,):
14873 
    self.success = success
14874 
    self.ex = ex
14875 
 
14876 
  def read(self, iprot):
14877 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14878 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14879 
      return
14880 
    iprot.readStructBegin()
14881 
    while True:
14882 
      (fname, ftype, fid) = iprot.readFieldBegin()
14883 
      if ftype == TType.STOP:
14884 
        break
14885 
      if fid == 0:
14886 
        if ftype == TType.BOOL:
14887 
          self.success = iprot.readBool();
14888 
        else:
14889 
          iprot.skip(ftype)
14890 
      elif fid == 1:
14891 
        if ftype == TType.STRUCT:
14892 
          self.ex = TransactionServiceException()
14893 
          self.ex.read(iprot)
14894 
        else:
14895 
          iprot.skip(ftype)
14896 
      else:
14897 
        iprot.skip(ftype)
14898 
      iprot.readFieldEnd()
14899 
    iprot.readStructEnd()
14900 
 
14901 
  def write(self, oprot):
14902 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14903 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14904 
      return
14905 
    oprot.writeStructBegin('markOrderReturnRequestReceived_result')
14906 
    if self.success is not None:
14907 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
14908 
      oprot.writeBool(self.success)
14909 
      oprot.writeFieldEnd()
14910 
    if self.ex is not None:
14911 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
14912 
      self.ex.write(oprot)
14913 
      oprot.writeFieldEnd()
14914 
    oprot.writeFieldStop()
14915 
    oprot.writeStructEnd()
14916 
 
14917 
  def validate(self):
14918 
    return
14919 
 
14920 
 
14921 
  def __repr__(self):
14922 
    L = ['%s=%r' % (key, value)
14923 
      for key, value in self.__dict__.iteritems()]
14924 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14925 
 
14926 
  def __eq__(self, other):
14927 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14928 
 
14929 
  def __ne__(self, other):
14930 
    return not (self == other)
14931 
 
14932 
class markOrderReturnRequestAuthorized_args:
14933 
  """
14934 
  Attributes:
14935 
   - orderId
14936 
   - isAuthorized
14937 
  """
14938 
 
14939 
  thrift_spec = (
14940 
    None, # 0
14941 
    (1, TType.I64, 'orderId', None, None, ), # 1
14942 
    (2, TType.BOOL, 'isAuthorized', None, None, ), # 2
14943 
  )
14944 
 
14945 
  def __init__(self, orderId=None, isAuthorized=None,):
14946 
    self.orderId = orderId
14947 
    self.isAuthorized = isAuthorized
14948 
 
14949 
  def read(self, iprot):
14950 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14951 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14952 
      return
14953 
    iprot.readStructBegin()
14954 
    while True:
14955 
      (fname, ftype, fid) = iprot.readFieldBegin()
14956 
      if ftype == TType.STOP:
14957 
        break
14958 
      if fid == 1:
14959 
        if ftype == TType.I64:
14960 
          self.orderId = iprot.readI64();
14961 
        else:
14962 
          iprot.skip(ftype)
14963 
      elif fid == 2:
14964 
        if ftype == TType.BOOL:
14965 
          self.isAuthorized = iprot.readBool();
14966 
        else:
14967 
          iprot.skip(ftype)
14968 
      else:
14969 
        iprot.skip(ftype)
14970 
      iprot.readFieldEnd()
14971 
    iprot.readStructEnd()
14972 
 
14973 
  def write(self, oprot):
14974 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14975 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14976 
      return
14977 
    oprot.writeStructBegin('markOrderReturnRequestAuthorized_args')
14978 
    if self.orderId is not None:
14979 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
14980 
      oprot.writeI64(self.orderId)
14981 
      oprot.writeFieldEnd()
14982 
    if self.isAuthorized is not None:
14983 
      oprot.writeFieldBegin('isAuthorized', TType.BOOL, 2)
14984 
      oprot.writeBool(self.isAuthorized)
14985 
      oprot.writeFieldEnd()
14986 
    oprot.writeFieldStop()
14987 
    oprot.writeStructEnd()
14988 
 
14989 
  def validate(self):
14990 
    return
14991 
 
14992 
 
14993 
  def __repr__(self):
14994 
    L = ['%s=%r' % (key, value)
14995 
      for key, value in self.__dict__.iteritems()]
14996 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14997 
 
14998 
  def __eq__(self, other):
14999 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15000 
 
15001 
  def __ne__(self, other):
15002 
    return not (self == other)
15003 
 
15004 
class markOrderReturnRequestAuthorized_result:
15005 
  """
15006 
  Attributes:
15007 
   - success
15008 
   - ex
15009 
  """
15010 
 
15011 
  thrift_spec = (
15012 
    (0, TType.BOOL, 'success', None, None, ), # 0
15013 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
15014 
  )
15015 
 
15016 
  def __init__(self, success=None, ex=None,):
15017 
    self.success = success
15018 
    self.ex = ex
15019 
 
15020 
  def read(self, iprot):
15021 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15022 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15023 
      return
15024 
    iprot.readStructBegin()
15025 
    while True:
15026 
      (fname, ftype, fid) = iprot.readFieldBegin()
15027 
      if ftype == TType.STOP:
15028 
        break
15029 
      if fid == 0:
15030 
        if ftype == TType.BOOL:
15031 
          self.success = iprot.readBool();
15032 
        else:
15033 
          iprot.skip(ftype)
15034 
      elif fid == 1:
15035 
        if ftype == TType.STRUCT:
15036 
          self.ex = TransactionServiceException()
15037 
          self.ex.read(iprot)
15038 
        else:
15039 
          iprot.skip(ftype)
15040 
      else:
15041 
        iprot.skip(ftype)
15042 
      iprot.readFieldEnd()
15043 
    iprot.readStructEnd()
15044 
 
15045 
  def write(self, oprot):
15046 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15047 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15048 
      return
15049 
    oprot.writeStructBegin('markOrderReturnRequestAuthorized_result')
15050 
    if self.success is not None:
15051 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
15052 
      oprot.writeBool(self.success)
15053 
      oprot.writeFieldEnd()
15054 
    if self.ex is not None:
15055 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
15056 
      self.ex.write(oprot)
15057 
      oprot.writeFieldEnd()
15058 
    oprot.writeFieldStop()
15059 
    oprot.writeStructEnd()
15060 
 
15061 
  def validate(self):
15062 
    return
15063 
 
15064 
 
15065 
  def __repr__(self):
15066 
    L = ['%s=%r' % (key, value)
15067 
      for key, value in self.__dict__.iteritems()]
15068 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15069 
 
15070 
  def __eq__(self, other):
15071 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15072 
 
15073 
  def __ne__(self, other):
15074 
    return not (self == other)
15075 
 
2536 chandransh 15076 
class requestPickupNumber_args:
15077 
  """
15078 
  Attributes:
15079 
   - orderId
4579 rajveer 15080 
   - providerId
2536 chandransh 15081 
  """
15082 
 
15083 
  thrift_spec = (
15084 
    None, # 0
15085 
    (1, TType.I64, 'orderId', None, None, ), # 1
4579 rajveer 15086 
    (2, TType.I64, 'providerId', None, None, ), # 2
2536 chandransh 15087 
  )
15088 
 
4579 rajveer 15089 
  def __init__(self, orderId=None, providerId=None,):
2536 chandransh 15090 
    self.orderId = orderId
4579 rajveer 15091 
    self.providerId = providerId
2536 chandransh 15092 
 
15093 
  def read(self, iprot):
15094 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15095 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15096 
      return
15097 
    iprot.readStructBegin()
15098 
    while True:
15099 
      (fname, ftype, fid) = iprot.readFieldBegin()
15100 
      if ftype == TType.STOP:
15101 
        break
15102 
      if fid == 1:
15103 
        if ftype == TType.I64:
15104 
          self.orderId = iprot.readI64();
15105 
        else:
15106 
          iprot.skip(ftype)
4579 rajveer 15107 
      elif fid == 2:
15108 
        if ftype == TType.I64:
15109 
          self.providerId = iprot.readI64();
15110 
        else:
15111 
          iprot.skip(ftype)
2536 chandransh 15112 
      else:
15113 
        iprot.skip(ftype)
15114 
      iprot.readFieldEnd()
15115 
    iprot.readStructEnd()
15116 
 
15117 
  def write(self, oprot):
15118 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15119 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15120 
      return
15121 
    oprot.writeStructBegin('requestPickupNumber_args')
3431 rajveer 15122 
    if self.orderId is not None:
2536 chandransh 15123 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
15124 
      oprot.writeI64(self.orderId)
15125 
      oprot.writeFieldEnd()
4579 rajveer 15126 
    if self.providerId is not None:
15127 
      oprot.writeFieldBegin('providerId', TType.I64, 2)
15128 
      oprot.writeI64(self.providerId)
15129 
      oprot.writeFieldEnd()
2536 chandransh 15130 
    oprot.writeFieldStop()
15131 
    oprot.writeStructEnd()
15132 
 
3431 rajveer 15133 
  def validate(self):
15134 
    return
15135 
 
15136 
 
2536 chandransh 15137 
  def __repr__(self):
15138 
    L = ['%s=%r' % (key, value)
15139 
      for key, value in self.__dict__.iteritems()]
15140 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15141 
 
15142 
  def __eq__(self, other):
15143 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15144 
 
15145 
  def __ne__(self, other):
15146 
    return not (self == other)
15147 
 
15148 
class requestPickupNumber_result:
15149 
  """
15150 
  Attributes:
15151 
   - success
15152 
   - ex
15153 
  """
15154 
 
15155 
  thrift_spec = (
15156 
    (0, TType.BOOL, 'success', None, None, ), # 0
15157 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
15158 
  )
15159 
 
15160 
  def __init__(self, success=None, ex=None,):
15161 
    self.success = success
15162 
    self.ex = ex
15163 
 
15164 
  def read(self, iprot):
15165 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15166 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15167 
      return
15168 
    iprot.readStructBegin()
15169 
    while True:
15170 
      (fname, ftype, fid) = iprot.readFieldBegin()
15171 
      if ftype == TType.STOP:
15172 
        break
15173 
      if fid == 0:
15174 
        if ftype == TType.BOOL:
15175 
          self.success = iprot.readBool();
15176 
        else:
15177 
          iprot.skip(ftype)
15178 
      elif fid == 1:
15179 
        if ftype == TType.STRUCT:
15180 
          self.ex = TransactionServiceException()
15181 
          self.ex.read(iprot)
15182 
        else:
15183 
          iprot.skip(ftype)
15184 
      else:
15185 
        iprot.skip(ftype)
15186 
      iprot.readFieldEnd()
15187 
    iprot.readStructEnd()
15188 
 
15189 
  def write(self, oprot):
15190 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15191 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15192 
      return
15193 
    oprot.writeStructBegin('requestPickupNumber_result')
3431 rajveer 15194 
    if self.success is not None:
2536 chandransh 15195 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
15196 
      oprot.writeBool(self.success)
15197 
      oprot.writeFieldEnd()
3431 rajveer 15198 
    if self.ex is not None:
2536 chandransh 15199 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
15200 
      self.ex.write(oprot)
15201 
      oprot.writeFieldEnd()
15202 
    oprot.writeFieldStop()
15203 
    oprot.writeStructEnd()
15204 
 
3431 rajveer 15205 
  def validate(self):
15206 
    return
15207 
 
15208 
 
2536 chandransh 15209 
  def __repr__(self):
15210 
    L = ['%s=%r' % (key, value)
15211 
      for key, value in self.__dict__.iteritems()]
15212 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15213 
 
15214 
  def __eq__(self, other):
15215 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15216 
 
15217 
  def __ne__(self, other):
15218 
    return not (self == other)
15219 
 
15220 
class authorizePickup_args:
15221 
  """
15222 
  Attributes:
15223 
   - orderId
15224 
   - pickupNumber
4602 rajveer 15225 
   - providerId
2536 chandransh 15226 
  """
15227 
 
15228 
  thrift_spec = (
15229 
    None, # 0
15230 
    (1, TType.I64, 'orderId', None, None, ), # 1
15231 
    (2, TType.STRING, 'pickupNumber', None, None, ), # 2
4602 rajveer 15232 
    (3, TType.I64, 'providerId', None, None, ), # 3
2536 chandransh 15233 
  )
15234 
 
4602 rajveer 15235 
  def __init__(self, orderId=None, pickupNumber=None, providerId=None,):
2536 chandransh 15236 
    self.orderId = orderId
15237 
    self.pickupNumber = pickupNumber
4602 rajveer 15238 
    self.providerId = providerId
2536 chandransh 15239 
 
15240 
  def read(self, iprot):
15241 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15242 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15243 
      return
15244 
    iprot.readStructBegin()
15245 
    while True:
15246 
      (fname, ftype, fid) = iprot.readFieldBegin()
15247 
      if ftype == TType.STOP:
15248 
        break
15249 
      if fid == 1:
15250 
        if ftype == TType.I64:
15251 
          self.orderId = iprot.readI64();
15252 
        else:
15253 
          iprot.skip(ftype)
15254 
      elif fid == 2:
15255 
        if ftype == TType.STRING:
15256 
          self.pickupNumber = iprot.readString();
15257 
        else:
15258 
          iprot.skip(ftype)
4602 rajveer 15259 
      elif fid == 3:
15260 
        if ftype == TType.I64:
15261 
          self.providerId = iprot.readI64();
15262 
        else:
15263 
          iprot.skip(ftype)
2536 chandransh 15264 
      else:
15265 
        iprot.skip(ftype)
15266 
      iprot.readFieldEnd()
15267 
    iprot.readStructEnd()
15268 
 
15269 
  def write(self, oprot):
15270 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15271 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15272 
      return
15273 
    oprot.writeStructBegin('authorizePickup_args')
3431 rajveer 15274 
    if self.orderId is not None:
2536 chandransh 15275 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
15276 
      oprot.writeI64(self.orderId)
15277 
      oprot.writeFieldEnd()
3431 rajveer 15278 
    if self.pickupNumber is not None:
2536 chandransh 15279 
      oprot.writeFieldBegin('pickupNumber', TType.STRING, 2)
15280 
      oprot.writeString(self.pickupNumber)
15281 
      oprot.writeFieldEnd()
4602 rajveer 15282 
    if self.providerId is not None:
15283 
      oprot.writeFieldBegin('providerId', TType.I64, 3)
15284 
      oprot.writeI64(self.providerId)
15285 
      oprot.writeFieldEnd()
2536 chandransh 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 authorizePickup_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('authorizePickup_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 
 
2764 chandransh 15376 
class markDoasAsPickedUp_args:
15377 
  """
15378 
  Attributes:
15379 
   - providerId
15380 
   - pickupDetails
15381 
  """
15382 
 
15383 
  thrift_spec = (
15384 
    None, # 0
15385 
    (1, TType.I64, 'providerId', None, None, ), # 1
15386 
    (2, TType.MAP, 'pickupDetails', (TType.STRING,None,TType.STRING,None), None, ), # 2
15387 
  )
15388 
 
15389 
  def __init__(self, providerId=None, pickupDetails=None,):
15390 
    self.providerId = providerId
15391 
    self.pickupDetails = pickupDetails
15392 
 
15393 
  def read(self, iprot):
15394 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15395 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15396 
      return
15397 
    iprot.readStructBegin()
15398 
    while True:
15399 
      (fname, ftype, fid) = iprot.readFieldBegin()
15400 
      if ftype == TType.STOP:
15401 
        break
15402 
      if fid == 1:
15403 
        if ftype == TType.I64:
15404 
          self.providerId = iprot.readI64();
15405 
        else:
15406 
          iprot.skip(ftype)
15407 
      elif fid == 2:
15408 
        if ftype == TType.MAP:
15409 
          self.pickupDetails = {}
5411 rajveer 15410 
          (_ktype351, _vtype352, _size350 ) = iprot.readMapBegin()
15411 
          for _i354 in xrange(_size350):
15412 
            _key355 = iprot.readString();
15413 
            _val356 = iprot.readString();
15414 
            self.pickupDetails[_key355] = _val356
2764 chandransh 15415 
          iprot.readMapEnd()
15416 
        else:
15417 
          iprot.skip(ftype)
15418 
      else:
15419 
        iprot.skip(ftype)
15420 
      iprot.readFieldEnd()
15421 
    iprot.readStructEnd()
15422 
 
15423 
  def write(self, oprot):
15424 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15425 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15426 
      return
15427 
    oprot.writeStructBegin('markDoasAsPickedUp_args')
3431 rajveer 15428 
    if self.providerId is not None:
2764 chandransh 15429 
      oprot.writeFieldBegin('providerId', TType.I64, 1)
15430 
      oprot.writeI64(self.providerId)
15431 
      oprot.writeFieldEnd()
3431 rajveer 15432 
    if self.pickupDetails is not None:
2764 chandransh 15433 
      oprot.writeFieldBegin('pickupDetails', TType.MAP, 2)
15434 
      oprot.writeMapBegin(TType.STRING, TType.STRING, len(self.pickupDetails))
5411 rajveer 15435 
      for kiter357,viter358 in self.pickupDetails.items():
15436 
        oprot.writeString(kiter357)
15437 
        oprot.writeString(viter358)
2764 chandransh 15438 
      oprot.writeMapEnd()
15439 
      oprot.writeFieldEnd()
15440 
    oprot.writeFieldStop()
15441 
    oprot.writeStructEnd()
15442 
 
3431 rajveer 15443 
  def validate(self):
15444 
    return
15445 
 
15446 
 
2764 chandransh 15447 
  def __repr__(self):
15448 
    L = ['%s=%r' % (key, value)
15449 
      for key, value in self.__dict__.iteritems()]
15450 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15451 
 
15452 
  def __eq__(self, other):
15453 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15454 
 
15455 
  def __ne__(self, other):
15456 
    return not (self == other)
15457 
 
15458 
class markDoasAsPickedUp_result:
4910 phani.kuma 15459 
 
15460 
  thrift_spec = (
15461 
  )
15462 
 
15463 
  def read(self, iprot):
15464 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15465 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15466 
      return
15467 
    iprot.readStructBegin()
15468 
    while True:
15469 
      (fname, ftype, fid) = iprot.readFieldBegin()
15470 
      if ftype == TType.STOP:
15471 
        break
15472 
      else:
15473 
        iprot.skip(ftype)
15474 
      iprot.readFieldEnd()
15475 
    iprot.readStructEnd()
15476 
 
15477 
  def write(self, oprot):
15478 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15479 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15480 
      return
15481 
    oprot.writeStructBegin('markDoasAsPickedUp_result')
15482 
    oprot.writeFieldStop()
15483 
    oprot.writeStructEnd()
15484 
 
15485 
  def validate(self):
15486 
    return
15487 
 
15488 
 
15489 
  def __repr__(self):
15490 
    L = ['%s=%r' % (key, value)
15491 
      for key, value in self.__dict__.iteritems()]
15492 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15493 
 
15494 
  def __eq__(self, other):
15495 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15496 
 
15497 
  def __ne__(self, other):
15498 
    return not (self == other)
15499 
 
15500 
class getDoasNotPickedUp_args:
2764 chandransh 15501 
  """
15502 
  Attributes:
4910 phani.kuma 15503 
   - providerId
15504 
  """
15505 
 
15506 
  thrift_spec = (
15507 
    None, # 0
15508 
    (1, TType.I64, 'providerId', None, None, ), # 1
15509 
  )
15510 
 
15511 
  def __init__(self, providerId=None,):
15512 
    self.providerId = providerId
15513 
 
15514 
  def read(self, iprot):
15515 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15516 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15517 
      return
15518 
    iprot.readStructBegin()
15519 
    while True:
15520 
      (fname, ftype, fid) = iprot.readFieldBegin()
15521 
      if ftype == TType.STOP:
15522 
        break
15523 
      if fid == 1:
15524 
        if ftype == TType.I64:
15525 
          self.providerId = iprot.readI64();
15526 
        else:
15527 
          iprot.skip(ftype)
15528 
      else:
15529 
        iprot.skip(ftype)
15530 
      iprot.readFieldEnd()
15531 
    iprot.readStructEnd()
15532 
 
15533 
  def write(self, oprot):
15534 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15535 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15536 
      return
15537 
    oprot.writeStructBegin('getDoasNotPickedUp_args')
15538 
    if self.providerId is not None:
15539 
      oprot.writeFieldBegin('providerId', TType.I64, 1)
15540 
      oprot.writeI64(self.providerId)
15541 
      oprot.writeFieldEnd()
15542 
    oprot.writeFieldStop()
15543 
    oprot.writeStructEnd()
15544 
 
15545 
  def validate(self):
15546 
    return
15547 
 
15548 
 
15549 
  def __repr__(self):
15550 
    L = ['%s=%r' % (key, value)
15551 
      for key, value in self.__dict__.iteritems()]
15552 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15553 
 
15554 
  def __eq__(self, other):
15555 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15556 
 
15557 
  def __ne__(self, other):
15558 
    return not (self == other)
15559 
 
15560 
class getDoasNotPickedUp_result:
15561 
  """
15562 
  Attributes:
2764 chandransh 15563 
   - success
15564 
  """
15565 
 
15566 
  thrift_spec = (
15567 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
15568 
  )
15569 
 
15570 
  def __init__(self, success=None,):
15571 
    self.success = success
15572 
 
15573 
  def read(self, iprot):
15574 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15575 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15576 
      return
15577 
    iprot.readStructBegin()
15578 
    while True:
15579 
      (fname, ftype, fid) = iprot.readFieldBegin()
15580 
      if ftype == TType.STOP:
15581 
        break
15582 
      if fid == 0:
15583 
        if ftype == TType.LIST:
15584 
          self.success = []
5411 rajveer 15585 
          (_etype362, _size359) = iprot.readListBegin()
15586 
          for _i363 in xrange(_size359):
15587 
            _elem364 = Order()
15588 
            _elem364.read(iprot)
15589 
            self.success.append(_elem364)
2764 chandransh 15590 
          iprot.readListEnd()
15591 
        else:
15592 
          iprot.skip(ftype)
15593 
      else:
15594 
        iprot.skip(ftype)
15595 
      iprot.readFieldEnd()
15596 
    iprot.readStructEnd()
15597 
 
15598 
  def write(self, oprot):
15599 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15600 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15601 
      return
4910 phani.kuma 15602 
    oprot.writeStructBegin('getDoasNotPickedUp_result')
3431 rajveer 15603 
    if self.success is not None:
2764 chandransh 15604 
      oprot.writeFieldBegin('success', TType.LIST, 0)
15605 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
5411 rajveer 15606 
      for iter365 in self.success:
15607 
        iter365.write(oprot)
2764 chandransh 15608 
      oprot.writeListEnd()
15609 
      oprot.writeFieldEnd()
15610 
    oprot.writeFieldStop()
15611 
    oprot.writeStructEnd()
15612 
 
3431 rajveer 15613 
  def validate(self):
15614 
    return
15615 
 
15616 
 
2764 chandransh 15617 
  def __repr__(self):
15618 
    L = ['%s=%r' % (key, value)
15619 
      for key, value in self.__dict__.iteritems()]
15620 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15621 
 
15622 
  def __eq__(self, other):
15623 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15624 
 
15625 
  def __ne__(self, other):
15626 
    return not (self == other)
15627 
 
4741 phani.kuma 15628 
class markReturnOrdersAsPickedUp_args:
15629 
  """
15630 
  Attributes:
15631 
   - providerId
15632 
   - pickupDetails
15633 
  """
15634 
 
15635 
  thrift_spec = (
15636 
    None, # 0
15637 
    (1, TType.I64, 'providerId', None, None, ), # 1
15638 
    (2, TType.MAP, 'pickupDetails', (TType.STRING,None,TType.STRING,None), None, ), # 2
15639 
  )
15640 
 
15641 
  def __init__(self, providerId=None, pickupDetails=None,):
15642 
    self.providerId = providerId
15643 
    self.pickupDetails = pickupDetails
15644 
 
15645 
  def read(self, iprot):
15646 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15647 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15648 
      return
15649 
    iprot.readStructBegin()
15650 
    while True:
15651 
      (fname, ftype, fid) = iprot.readFieldBegin()
15652 
      if ftype == TType.STOP:
15653 
        break
15654 
      if fid == 1:
15655 
        if ftype == TType.I64:
15656 
          self.providerId = iprot.readI64();
15657 
        else:
15658 
          iprot.skip(ftype)
15659 
      elif fid == 2:
15660 
        if ftype == TType.MAP:
15661 
          self.pickupDetails = {}
5411 rajveer 15662 
          (_ktype367, _vtype368, _size366 ) = iprot.readMapBegin()
15663 
          for _i370 in xrange(_size366):
15664 
            _key371 = iprot.readString();
15665 
            _val372 = iprot.readString();
15666 
            self.pickupDetails[_key371] = _val372
4741 phani.kuma 15667 
          iprot.readMapEnd()
15668 
        else:
15669 
          iprot.skip(ftype)
15670 
      else:
15671 
        iprot.skip(ftype)
15672 
      iprot.readFieldEnd()
15673 
    iprot.readStructEnd()
15674 
 
15675 
  def write(self, oprot):
15676 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15677 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15678 
      return
15679 
    oprot.writeStructBegin('markReturnOrdersAsPickedUp_args')
15680 
    if self.providerId is not None:
15681 
      oprot.writeFieldBegin('providerId', TType.I64, 1)
15682 
      oprot.writeI64(self.providerId)
15683 
      oprot.writeFieldEnd()
15684 
    if self.pickupDetails is not None:
15685 
      oprot.writeFieldBegin('pickupDetails', TType.MAP, 2)
15686 
      oprot.writeMapBegin(TType.STRING, TType.STRING, len(self.pickupDetails))
5411 rajveer 15687 
      for kiter373,viter374 in self.pickupDetails.items():
15688 
        oprot.writeString(kiter373)
15689 
        oprot.writeString(viter374)
4741 phani.kuma 15690 
      oprot.writeMapEnd()
15691 
      oprot.writeFieldEnd()
15692 
    oprot.writeFieldStop()
15693 
    oprot.writeStructEnd()
15694 
 
15695 
  def validate(self):
15696 
    return
15697 
 
15698 
 
15699 
  def __repr__(self):
15700 
    L = ['%s=%r' % (key, value)
15701 
      for key, value in self.__dict__.iteritems()]
15702 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15703 
 
15704 
  def __eq__(self, other):
15705 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15706 
 
15707 
  def __ne__(self, other):
15708 
    return not (self == other)
15709 
 
15710 
class markReturnOrdersAsPickedUp_result:
4910 phani.kuma 15711 
 
15712 
  thrift_spec = (
15713 
  )
15714 
 
15715 
  def read(self, iprot):
15716 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15717 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15718 
      return
15719 
    iprot.readStructBegin()
15720 
    while True:
15721 
      (fname, ftype, fid) = iprot.readFieldBegin()
15722 
      if ftype == TType.STOP:
15723 
        break
15724 
      else:
15725 
        iprot.skip(ftype)
15726 
      iprot.readFieldEnd()
15727 
    iprot.readStructEnd()
15728 
 
15729 
  def write(self, oprot):
15730 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15731 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15732 
      return
15733 
    oprot.writeStructBegin('markReturnOrdersAsPickedUp_result')
15734 
    oprot.writeFieldStop()
15735 
    oprot.writeStructEnd()
15736 
 
15737 
  def validate(self):
15738 
    return
15739 
 
15740 
 
15741 
  def __repr__(self):
15742 
    L = ['%s=%r' % (key, value)
15743 
      for key, value in self.__dict__.iteritems()]
15744 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15745 
 
15746 
  def __eq__(self, other):
15747 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15748 
 
15749 
  def __ne__(self, other):
15750 
    return not (self == other)
15751 
 
15752 
class getReturnOrdersNotPickedUp_args:
4741 phani.kuma 15753 
  """
15754 
  Attributes:
4910 phani.kuma 15755 
   - providerId
15756 
  """
15757 
 
15758 
  thrift_spec = (
15759 
    None, # 0
15760 
    (1, TType.I64, 'providerId', None, None, ), # 1
15761 
  )
15762 
 
15763 
  def __init__(self, providerId=None,):
15764 
    self.providerId = providerId
15765 
 
15766 
  def read(self, iprot):
15767 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15768 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15769 
      return
15770 
    iprot.readStructBegin()
15771 
    while True:
15772 
      (fname, ftype, fid) = iprot.readFieldBegin()
15773 
      if ftype == TType.STOP:
15774 
        break
15775 
      if fid == 1:
15776 
        if ftype == TType.I64:
15777 
          self.providerId = iprot.readI64();
15778 
        else:
15779 
          iprot.skip(ftype)
15780 
      else:
15781 
        iprot.skip(ftype)
15782 
      iprot.readFieldEnd()
15783 
    iprot.readStructEnd()
15784 
 
15785 
  def write(self, oprot):
15786 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15787 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15788 
      return
15789 
    oprot.writeStructBegin('getReturnOrdersNotPickedUp_args')
15790 
    if self.providerId is not None:
15791 
      oprot.writeFieldBegin('providerId', TType.I64, 1)
15792 
      oprot.writeI64(self.providerId)
15793 
      oprot.writeFieldEnd()
15794 
    oprot.writeFieldStop()
15795 
    oprot.writeStructEnd()
15796 
 
15797 
  def validate(self):
15798 
    return
15799 
 
15800 
 
15801 
  def __repr__(self):
15802 
    L = ['%s=%r' % (key, value)
15803 
      for key, value in self.__dict__.iteritems()]
15804 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15805 
 
15806 
  def __eq__(self, other):
15807 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15808 
 
15809 
  def __ne__(self, other):
15810 
    return not (self == other)
15811 
 
15812 
class getReturnOrdersNotPickedUp_result:
15813 
  """
15814 
  Attributes:
4741 phani.kuma 15815 
   - success
15816 
  """
15817 
 
15818 
  thrift_spec = (
15819 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
15820 
  )
15821 
 
15822 
  def __init__(self, success=None,):
15823 
    self.success = success
15824 
 
15825 
  def read(self, iprot):
15826 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15827 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15828 
      return
15829 
    iprot.readStructBegin()
15830 
    while True:
15831 
      (fname, ftype, fid) = iprot.readFieldBegin()
15832 
      if ftype == TType.STOP:
15833 
        break
15834 
      if fid == 0:
15835 
        if ftype == TType.LIST:
15836 
          self.success = []
5411 rajveer 15837 
          (_etype378, _size375) = iprot.readListBegin()
15838 
          for _i379 in xrange(_size375):
15839 
            _elem380 = Order()
15840 
            _elem380.read(iprot)
15841 
            self.success.append(_elem380)
4741 phani.kuma 15842 
          iprot.readListEnd()
15843 
        else:
15844 
          iprot.skip(ftype)
15845 
      else:
15846 
        iprot.skip(ftype)
15847 
      iprot.readFieldEnd()
15848 
    iprot.readStructEnd()
15849 
 
15850 
  def write(self, oprot):
15851 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15852 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15853 
      return
4910 phani.kuma 15854 
    oprot.writeStructBegin('getReturnOrdersNotPickedUp_result')
4741 phani.kuma 15855 
    if self.success is not None:
15856 
      oprot.writeFieldBegin('success', TType.LIST, 0)
15857 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
5411 rajveer 15858 
      for iter381 in self.success:
15859 
        iter381.write(oprot)
4741 phani.kuma 15860 
      oprot.writeListEnd()
15861 
      oprot.writeFieldEnd()
15862 
    oprot.writeFieldStop()
15863 
    oprot.writeStructEnd()
15864 
 
15865 
  def validate(self):
15866 
    return
15867 
 
15868 
 
15869 
  def __repr__(self):
15870 
    L = ['%s=%r' % (key, value)
15871 
      for key, value in self.__dict__.iteritems()]
15872 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15873 
 
15874 
  def __eq__(self, other):
15875 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15876 
 
15877 
  def __ne__(self, other):
15878 
    return not (self == other)
15879 
 
2616 chandransh 15880 
class receiveReturn_args:
2591 chandransh 15881 
  """
15882 
  Attributes:
15883 
   - orderId
4479 rajveer 15884 
   - receiveCondition
2591 chandransh 15885 
  """
2536 chandransh 15886 
 
2591 chandransh 15887 
  thrift_spec = (
15888 
    None, # 0
15889 
    (1, TType.I64, 'orderId', None, None, ), # 1
4479 rajveer 15890 
    (2, TType.I64, 'receiveCondition', None, None, ), # 2
2591 chandransh 15891 
  )
15892 
 
4479 rajveer 15893 
  def __init__(self, orderId=None, receiveCondition=None,):
2591 chandransh 15894 
    self.orderId = orderId
4479 rajveer 15895 
    self.receiveCondition = receiveCondition
2591 chandransh 15896 
 
15897 
  def read(self, iprot):
15898 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15899 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15900 
      return
15901 
    iprot.readStructBegin()
15902 
    while True:
15903 
      (fname, ftype, fid) = iprot.readFieldBegin()
15904 
      if ftype == TType.STOP:
15905 
        break
15906 
      if fid == 1:
15907 
        if ftype == TType.I64:
15908 
          self.orderId = iprot.readI64();
15909 
        else:
15910 
          iprot.skip(ftype)
4479 rajveer 15911 
      elif fid == 2:
15912 
        if ftype == TType.I64:
15913 
          self.receiveCondition = iprot.readI64();
15914 
        else:
15915 
          iprot.skip(ftype)
2591 chandransh 15916 
      else:
15917 
        iprot.skip(ftype)
15918 
      iprot.readFieldEnd()
15919 
    iprot.readStructEnd()
15920 
 
15921 
  def write(self, oprot):
15922 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15923 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15924 
      return
2616 chandransh 15925 
    oprot.writeStructBegin('receiveReturn_args')
3431 rajveer 15926 
    if self.orderId is not None:
2591 chandransh 15927 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
15928 
      oprot.writeI64(self.orderId)
15929 
      oprot.writeFieldEnd()
4479 rajveer 15930 
    if self.receiveCondition is not None:
15931 
      oprot.writeFieldBegin('receiveCondition', TType.I64, 2)
15932 
      oprot.writeI64(self.receiveCondition)
15933 
      oprot.writeFieldEnd()
2591 chandransh 15934 
    oprot.writeFieldStop()
15935 
    oprot.writeStructEnd()
15936 
 
3431 rajveer 15937 
  def validate(self):
15938 
    return
15939 
 
15940 
 
2591 chandransh 15941 
  def __repr__(self):
15942 
    L = ['%s=%r' % (key, value)
15943 
      for key, value in self.__dict__.iteritems()]
15944 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15945 
 
15946 
  def __eq__(self, other):
15947 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15948 
 
15949 
  def __ne__(self, other):
15950 
    return not (self == other)
15951 
 
2616 chandransh 15952 
class receiveReturn_result:
2591 chandransh 15953 
  """
15954 
  Attributes:
15955 
   - success
15956 
   - ex
15957 
  """
15958 
 
15959 
  thrift_spec = (
15960 
    (0, TType.BOOL, 'success', None, None, ), # 0
15961 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
15962 
  )
15963 
 
15964 
  def __init__(self, success=None, ex=None,):
15965 
    self.success = success
15966 
    self.ex = ex
15967 
 
15968 
  def read(self, iprot):
15969 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15970 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15971 
      return
15972 
    iprot.readStructBegin()
15973 
    while True:
15974 
      (fname, ftype, fid) = iprot.readFieldBegin()
15975 
      if ftype == TType.STOP:
15976 
        break
15977 
      if fid == 0:
15978 
        if ftype == TType.BOOL:
15979 
          self.success = iprot.readBool();
15980 
        else:
15981 
          iprot.skip(ftype)
15982 
      elif fid == 1:
15983 
        if ftype == TType.STRUCT:
15984 
          self.ex = TransactionServiceException()
15985 
          self.ex.read(iprot)
15986 
        else:
15987 
          iprot.skip(ftype)
15988 
      else:
15989 
        iprot.skip(ftype)
15990 
      iprot.readFieldEnd()
15991 
    iprot.readStructEnd()
15992 
 
15993 
  def write(self, oprot):
15994 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15995 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15996 
      return
2616 chandransh 15997 
    oprot.writeStructBegin('receiveReturn_result')
3431 rajveer 15998 
    if self.success is not None:
2591 chandransh 15999 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
16000 
      oprot.writeBool(self.success)
16001 
      oprot.writeFieldEnd()
3431 rajveer 16002 
    if self.ex is not None:
2591 chandransh 16003 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
16004 
      self.ex.write(oprot)
16005 
      oprot.writeFieldEnd()
16006 
    oprot.writeFieldStop()
16007 
    oprot.writeStructEnd()
16008 
 
3431 rajveer 16009 
  def validate(self):
16010 
    return
16011 
 
16012 
 
2591 chandransh 16013 
  def __repr__(self):
16014 
    L = ['%s=%r' % (key, value)
16015 
      for key, value in self.__dict__.iteritems()]
16016 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16017 
 
16018 
  def __eq__(self, other):
16019 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16020 
 
16021 
  def __ne__(self, other):
16022 
    return not (self == other)
16023 
 
16024 
class validateDoa_args:
16025 
  """
16026 
  Attributes:
16027 
   - orderId
16028 
   - isValid
16029 
  """
16030 
 
16031 
  thrift_spec = (
16032 
    None, # 0
16033 
    (1, TType.I64, 'orderId', None, None, ), # 1
16034 
    (2, TType.BOOL, 'isValid', None, None, ), # 2
16035 
  )
16036 
 
16037 
  def __init__(self, orderId=None, isValid=None,):
16038 
    self.orderId = orderId
16039 
    self.isValid = isValid
16040 
 
16041 
  def read(self, iprot):
16042 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16043 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16044 
      return
16045 
    iprot.readStructBegin()
16046 
    while True:
16047 
      (fname, ftype, fid) = iprot.readFieldBegin()
16048 
      if ftype == TType.STOP:
16049 
        break
16050 
      if fid == 1:
16051 
        if ftype == TType.I64:
16052 
          self.orderId = iprot.readI64();
16053 
        else:
16054 
          iprot.skip(ftype)
16055 
      elif fid == 2:
16056 
        if ftype == TType.BOOL:
16057 
          self.isValid = iprot.readBool();
16058 
        else:
16059 
          iprot.skip(ftype)
16060 
      else:
16061 
        iprot.skip(ftype)
16062 
      iprot.readFieldEnd()
16063 
    iprot.readStructEnd()
16064 
 
16065 
  def write(self, oprot):
16066 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16067 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16068 
      return
16069 
    oprot.writeStructBegin('validateDoa_args')
3431 rajveer 16070 
    if self.orderId is not None:
2591 chandransh 16071 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
16072 
      oprot.writeI64(self.orderId)
16073 
      oprot.writeFieldEnd()
3431 rajveer 16074 
    if self.isValid is not None:
2591 chandransh 16075 
      oprot.writeFieldBegin('isValid', TType.BOOL, 2)
16076 
      oprot.writeBool(self.isValid)
16077 
      oprot.writeFieldEnd()
16078 
    oprot.writeFieldStop()
16079 
    oprot.writeStructEnd()
16080 
 
3431 rajveer 16081 
  def validate(self):
16082 
    return
16083 
 
16084 
 
2591 chandransh 16085 
  def __repr__(self):
16086 
    L = ['%s=%r' % (key, value)
16087 
      for key, value in self.__dict__.iteritems()]
16088 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16089 
 
16090 
  def __eq__(self, other):
16091 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16092 
 
16093 
  def __ne__(self, other):
16094 
    return not (self == other)
16095 
 
16096 
class validateDoa_result:
16097 
  """
16098 
  Attributes:
16099 
   - success
16100 
   - ex
16101 
  """
16102 
 
16103 
  thrift_spec = (
16104 
    (0, TType.BOOL, 'success', None, None, ), # 0
16105 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
16106 
  )
16107 
 
16108 
  def __init__(self, success=None, ex=None,):
16109 
    self.success = success
16110 
    self.ex = ex
16111 
 
16112 
  def read(self, iprot):
16113 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16114 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16115 
      return
16116 
    iprot.readStructBegin()
16117 
    while True:
16118 
      (fname, ftype, fid) = iprot.readFieldBegin()
16119 
      if ftype == TType.STOP:
16120 
        break
16121 
      if fid == 0:
16122 
        if ftype == TType.BOOL:
16123 
          self.success = iprot.readBool();
16124 
        else:
16125 
          iprot.skip(ftype)
16126 
      elif fid == 1:
16127 
        if ftype == TType.STRUCT:
16128 
          self.ex = TransactionServiceException()
16129 
          self.ex.read(iprot)
16130 
        else:
16131 
          iprot.skip(ftype)
16132 
      else:
16133 
        iprot.skip(ftype)
16134 
      iprot.readFieldEnd()
16135 
    iprot.readStructEnd()
16136 
 
16137 
  def write(self, oprot):
16138 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16139 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16140 
      return
16141 
    oprot.writeStructBegin('validateDoa_result')
3431 rajveer 16142 
    if self.success is not None:
2591 chandransh 16143 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
16144 
      oprot.writeBool(self.success)
16145 
      oprot.writeFieldEnd()
3431 rajveer 16146 
    if self.ex is not None:
2591 chandransh 16147 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
16148 
      self.ex.write(oprot)
16149 
      oprot.writeFieldEnd()
16150 
    oprot.writeFieldStop()
16151 
    oprot.writeStructEnd()
16152 
 
3431 rajveer 16153 
  def validate(self):
16154 
    return
16155 
 
16156 
 
2591 chandransh 16157 
  def __repr__(self):
16158 
    L = ['%s=%r' % (key, value)
16159 
      for key, value in self.__dict__.iteritems()]
16160 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16161 
 
16162 
  def __eq__(self, other):
16163 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16164 
 
16165 
  def __ne__(self, other):
16166 
    return not (self == other)
16167 
 
4495 rajveer 16168 
class validateReturnProduct_args:
16169 
  """
16170 
  Attributes:
16171 
   - orderId
16172 
   - isUsable
16173 
  """
16174 
 
16175 
  thrift_spec = (
16176 
    None, # 0
16177 
    (1, TType.I64, 'orderId', None, None, ), # 1
16178 
    (2, TType.BOOL, 'isUsable', None, None, ), # 2
16179 
  )
16180 
 
16181 
  def __init__(self, orderId=None, isUsable=None,):
16182 
    self.orderId = orderId
16183 
    self.isUsable = isUsable
16184 
 
16185 
  def read(self, iprot):
16186 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16187 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16188 
      return
16189 
    iprot.readStructBegin()
16190 
    while True:
16191 
      (fname, ftype, fid) = iprot.readFieldBegin()
16192 
      if ftype == TType.STOP:
16193 
        break
16194 
      if fid == 1:
16195 
        if ftype == TType.I64:
16196 
          self.orderId = iprot.readI64();
16197 
        else:
16198 
          iprot.skip(ftype)
16199 
      elif fid == 2:
16200 
        if ftype == TType.BOOL:
16201 
          self.isUsable = iprot.readBool();
16202 
        else:
16203 
          iprot.skip(ftype)
16204 
      else:
16205 
        iprot.skip(ftype)
16206 
      iprot.readFieldEnd()
16207 
    iprot.readStructEnd()
16208 
 
16209 
  def write(self, oprot):
16210 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16211 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16212 
      return
16213 
    oprot.writeStructBegin('validateReturnProduct_args')
16214 
    if self.orderId is not None:
16215 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
16216 
      oprot.writeI64(self.orderId)
16217 
      oprot.writeFieldEnd()
16218 
    if self.isUsable is not None:
16219 
      oprot.writeFieldBegin('isUsable', TType.BOOL, 2)
16220 
      oprot.writeBool(self.isUsable)
16221 
      oprot.writeFieldEnd()
16222 
    oprot.writeFieldStop()
16223 
    oprot.writeStructEnd()
16224 
 
16225 
  def validate(self):
16226 
    return
16227 
 
16228 
 
16229 
  def __repr__(self):
16230 
    L = ['%s=%r' % (key, value)
16231 
      for key, value in self.__dict__.iteritems()]
16232 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16233 
 
16234 
  def __eq__(self, other):
16235 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16236 
 
16237 
  def __ne__(self, other):
16238 
    return not (self == other)
16239 
 
16240 
class validateReturnProduct_result:
16241 
  """
16242 
  Attributes:
16243 
   - success
16244 
   - ex
16245 
  """
16246 
 
16247 
  thrift_spec = (
16248 
    (0, TType.BOOL, 'success', None, None, ), # 0
16249 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
16250 
  )
16251 
 
16252 
  def __init__(self, success=None, ex=None,):
16253 
    self.success = success
16254 
    self.ex = ex
16255 
 
16256 
  def read(self, iprot):
16257 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16258 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16259 
      return
16260 
    iprot.readStructBegin()
16261 
    while True:
16262 
      (fname, ftype, fid) = iprot.readFieldBegin()
16263 
      if ftype == TType.STOP:
16264 
        break
16265 
      if fid == 0:
16266 
        if ftype == TType.BOOL:
16267 
          self.success = iprot.readBool();
16268 
        else:
16269 
          iprot.skip(ftype)
16270 
      elif fid == 1:
16271 
        if ftype == TType.STRUCT:
16272 
          self.ex = TransactionServiceException()
16273 
          self.ex.read(iprot)
16274 
        else:
16275 
          iprot.skip(ftype)
16276 
      else:
16277 
        iprot.skip(ftype)
16278 
      iprot.readFieldEnd()
16279 
    iprot.readStructEnd()
16280 
 
16281 
  def write(self, oprot):
16282 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16283 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16284 
      return
16285 
    oprot.writeStructBegin('validateReturnProduct_result')
16286 
    if self.success is not None:
16287 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
16288 
      oprot.writeBool(self.success)
16289 
      oprot.writeFieldEnd()
16290 
    if self.ex is not None:
16291 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
16292 
      self.ex.write(oprot)
16293 
      oprot.writeFieldEnd()
16294 
    oprot.writeFieldStop()
16295 
    oprot.writeStructEnd()
16296 
 
16297 
  def validate(self):
16298 
    return
16299 
 
16300 
 
16301 
  def __repr__(self):
16302 
    L = ['%s=%r' % (key, value)
16303 
      for key, value in self.__dict__.iteritems()]
16304 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16305 
 
16306 
  def __eq__(self, other):
16307 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16308 
 
16309 
  def __ne__(self, other):
16310 
    return not (self == other)
16311 
 
2616 chandransh 16312 
class reshipOrder_args:
16313 
  """
16314 
  Attributes:
16315 
   - orderId
16316 
  """
2591 chandransh 16317 
 
2616 chandransh 16318 
  thrift_spec = (
16319 
    None, # 0
16320 
    (1, TType.I64, 'orderId', None, None, ), # 1
16321 
  )
16322 
 
16323 
  def __init__(self, orderId=None,):
16324 
    self.orderId = orderId
16325 
 
16326 
  def read(self, iprot):
16327 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16328 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16329 
      return
16330 
    iprot.readStructBegin()
16331 
    while True:
16332 
      (fname, ftype, fid) = iprot.readFieldBegin()
16333 
      if ftype == TType.STOP:
16334 
        break
16335 
      if fid == 1:
16336 
        if ftype == TType.I64:
16337 
          self.orderId = iprot.readI64();
16338 
        else:
16339 
          iprot.skip(ftype)
16340 
      else:
16341 
        iprot.skip(ftype)
16342 
      iprot.readFieldEnd()
16343 
    iprot.readStructEnd()
16344 
 
16345 
  def write(self, oprot):
16346 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16347 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16348 
      return
16349 
    oprot.writeStructBegin('reshipOrder_args')
3431 rajveer 16350 
    if self.orderId is not None:
2616 chandransh 16351 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
16352 
      oprot.writeI64(self.orderId)
16353 
      oprot.writeFieldEnd()
16354 
    oprot.writeFieldStop()
16355 
    oprot.writeStructEnd()
16356 
 
3431 rajveer 16357 
  def validate(self):
16358 
    return
16359 
 
16360 
 
2616 chandransh 16361 
  def __repr__(self):
16362 
    L = ['%s=%r' % (key, value)
16363 
      for key, value in self.__dict__.iteritems()]
16364 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16365 
 
16366 
  def __eq__(self, other):
16367 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16368 
 
16369 
  def __ne__(self, other):
16370 
    return not (self == other)
16371 
 
16372 
class reshipOrder_result:
16373 
  """
16374 
  Attributes:
16375 
   - success
16376 
   - ex
16377 
  """
16378 
 
16379 
  thrift_spec = (
16380 
    (0, TType.I64, 'success', None, None, ), # 0
16381 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
16382 
  )
16383 
 
16384 
  def __init__(self, success=None, ex=None,):
16385 
    self.success = success
16386 
    self.ex = ex
16387 
 
16388 
  def read(self, iprot):
16389 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16390 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16391 
      return
16392 
    iprot.readStructBegin()
16393 
    while True:
16394 
      (fname, ftype, fid) = iprot.readFieldBegin()
16395 
      if ftype == TType.STOP:
16396 
        break
16397 
      if fid == 0:
16398 
        if ftype == TType.I64:
16399 
          self.success = iprot.readI64();
16400 
        else:
16401 
          iprot.skip(ftype)
16402 
      elif fid == 1:
16403 
        if ftype == TType.STRUCT:
16404 
          self.ex = TransactionServiceException()
16405 
          self.ex.read(iprot)
16406 
        else:
16407 
          iprot.skip(ftype)
16408 
      else:
16409 
        iprot.skip(ftype)
16410 
      iprot.readFieldEnd()
16411 
    iprot.readStructEnd()
16412 
 
16413 
  def write(self, oprot):
16414 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16415 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16416 
      return
16417 
    oprot.writeStructBegin('reshipOrder_result')
3431 rajveer 16418 
    if self.success is not None:
2616 chandransh 16419 
      oprot.writeFieldBegin('success', TType.I64, 0)
16420 
      oprot.writeI64(self.success)
16421 
      oprot.writeFieldEnd()
3431 rajveer 16422 
    if self.ex is not None:
2616 chandransh 16423 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
16424 
      self.ex.write(oprot)
16425 
      oprot.writeFieldEnd()
16426 
    oprot.writeFieldStop()
16427 
    oprot.writeStructEnd()
16428 
 
3431 rajveer 16429 
  def validate(self):
16430 
    return
16431 
 
16432 
 
2616 chandransh 16433 
  def __repr__(self):
16434 
    L = ['%s=%r' % (key, value)
16435 
      for key, value in self.__dict__.iteritems()]
16436 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16437 
 
16438 
  def __eq__(self, other):
16439 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16440 
 
16441 
  def __ne__(self, other):
16442 
    return not (self == other)
16443 
 
16444 
class refundOrder_args:
16445 
  """
16446 
  Attributes:
16447 
   - orderId
3226 chandransh 16448 
   - refundedBy
16449 
   - reason
2616 chandransh 16450 
  """
16451 
 
16452 
  thrift_spec = (
16453 
    None, # 0
16454 
    (1, TType.I64, 'orderId', None, None, ), # 1
3226 chandransh 16455 
    (2, TType.STRING, 'refundedBy', None, None, ), # 2
16456 
    (3, TType.STRING, 'reason', None, None, ), # 3
2616 chandransh 16457 
  )
16458 
 
3226 chandransh 16459 
  def __init__(self, orderId=None, refundedBy=None, reason=None,):
2616 chandransh 16460 
    self.orderId = orderId
3226 chandransh 16461 
    self.refundedBy = refundedBy
16462 
    self.reason = reason
2616 chandransh 16463 
 
16464 
  def read(self, iprot):
16465 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16466 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16467 
      return
16468 
    iprot.readStructBegin()
16469 
    while True:
16470 
      (fname, ftype, fid) = iprot.readFieldBegin()
16471 
      if ftype == TType.STOP:
16472 
        break
16473 
      if fid == 1:
16474 
        if ftype == TType.I64:
16475 
          self.orderId = iprot.readI64();
16476 
        else:
16477 
          iprot.skip(ftype)
3226 chandransh 16478 
      elif fid == 2:
16479 
        if ftype == TType.STRING:
16480 
          self.refundedBy = iprot.readString();
16481 
        else:
16482 
          iprot.skip(ftype)
16483 
      elif fid == 3:
16484 
        if ftype == TType.STRING:
16485 
          self.reason = iprot.readString();
16486 
        else:
16487 
          iprot.skip(ftype)
2616 chandransh 16488 
      else:
16489 
        iprot.skip(ftype)
16490 
      iprot.readFieldEnd()
16491 
    iprot.readStructEnd()
16492 
 
16493 
  def write(self, oprot):
16494 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16495 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16496 
      return
16497 
    oprot.writeStructBegin('refundOrder_args')
3431 rajveer 16498 
    if self.orderId is not None:
2616 chandransh 16499 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
16500 
      oprot.writeI64(self.orderId)
16501 
      oprot.writeFieldEnd()
3431 rajveer 16502 
    if self.refundedBy is not None:
3226 chandransh 16503 
      oprot.writeFieldBegin('refundedBy', TType.STRING, 2)
16504 
      oprot.writeString(self.refundedBy)
16505 
      oprot.writeFieldEnd()
3431 rajveer 16506 
    if self.reason is not None:
3226 chandransh 16507 
      oprot.writeFieldBegin('reason', TType.STRING, 3)
16508 
      oprot.writeString(self.reason)
16509 
      oprot.writeFieldEnd()
2616 chandransh 16510 
    oprot.writeFieldStop()
16511 
    oprot.writeStructEnd()
16512 
 
3431 rajveer 16513 
  def validate(self):
16514 
    return
16515 
 
16516 
 
2616 chandransh 16517 
  def __repr__(self):
16518 
    L = ['%s=%r' % (key, value)
16519 
      for key, value in self.__dict__.iteritems()]
16520 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16521 
 
16522 
  def __eq__(self, other):
16523 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16524 
 
16525 
  def __ne__(self, other):
16526 
    return not (self == other)
16527 
 
16528 
class refundOrder_result:
16529 
  """
16530 
  Attributes:
16531 
   - success
16532 
   - ex
16533 
  """
16534 
 
16535 
  thrift_spec = (
16536 
    (0, TType.BOOL, 'success', None, None, ), # 0
16537 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
16538 
  )
16539 
 
16540 
  def __init__(self, success=None, ex=None,):
16541 
    self.success = success
16542 
    self.ex = ex
16543 
 
16544 
  def read(self, iprot):
16545 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16546 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16547 
      return
16548 
    iprot.readStructBegin()
16549 
    while True:
16550 
      (fname, ftype, fid) = iprot.readFieldBegin()
16551 
      if ftype == TType.STOP:
16552 
        break
16553 
      if fid == 0:
16554 
        if ftype == TType.BOOL:
16555 
          self.success = iprot.readBool();
16556 
        else:
16557 
          iprot.skip(ftype)
16558 
      elif fid == 1:
16559 
        if ftype == TType.STRUCT:
16560 
          self.ex = TransactionServiceException()
16561 
          self.ex.read(iprot)
16562 
        else:
16563 
          iprot.skip(ftype)
16564 
      else:
16565 
        iprot.skip(ftype)
16566 
      iprot.readFieldEnd()
16567 
    iprot.readStructEnd()
16568 
 
16569 
  def write(self, oprot):
16570 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16571 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16572 
      return
16573 
    oprot.writeStructBegin('refundOrder_result')
3431 rajveer 16574 
    if self.success is not None:
2616 chandransh 16575 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
16576 
      oprot.writeBool(self.success)
16577 
      oprot.writeFieldEnd()
3431 rajveer 16578 
    if self.ex is not None:
2616 chandransh 16579 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
16580 
      self.ex.write(oprot)
16581 
      oprot.writeFieldEnd()
16582 
    oprot.writeFieldStop()
16583 
    oprot.writeStructEnd()
16584 
 
3431 rajveer 16585 
  def validate(self):
16586 
    return
16587 
 
16588 
 
2616 chandransh 16589 
  def __repr__(self):
16590 
    L = ['%s=%r' % (key, value)
16591 
      for key, value in self.__dict__.iteritems()]
16592 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16593 
 
16594 
  def __eq__(self, other):
16595 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16596 
 
16597 
  def __ne__(self, other):
16598 
    return not (self == other)
16599 
 
2690 chandransh 16600 
class getReturnOrders_args:
16601 
  """
16602 
  Attributes:
16603 
   - warehouseId
16604 
   - fromDate
16605 
   - toDate
16606 
  """
2616 chandransh 16607 
 
2690 chandransh 16608 
  thrift_spec = (
16609 
    None, # 0
16610 
    (1, TType.I64, 'warehouseId', None, None, ), # 1
16611 
    (2, TType.I64, 'fromDate', None, None, ), # 2
16612 
    (3, TType.I64, 'toDate', None, None, ), # 3
16613 
  )
16614 
 
16615 
  def __init__(self, warehouseId=None, fromDate=None, toDate=None,):
16616 
    self.warehouseId = warehouseId
16617 
    self.fromDate = fromDate
16618 
    self.toDate = toDate
16619 
 
16620 
  def read(self, iprot):
16621 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16622 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16623 
      return
16624 
    iprot.readStructBegin()
16625 
    while True:
16626 
      (fname, ftype, fid) = iprot.readFieldBegin()
16627 
      if ftype == TType.STOP:
16628 
        break
16629 
      if fid == 1:
16630 
        if ftype == TType.I64:
16631 
          self.warehouseId = iprot.readI64();
16632 
        else:
16633 
          iprot.skip(ftype)
16634 
      elif fid == 2:
16635 
        if ftype == TType.I64:
16636 
          self.fromDate = iprot.readI64();
16637 
        else:
16638 
          iprot.skip(ftype)
16639 
      elif fid == 3:
16640 
        if ftype == TType.I64:
16641 
          self.toDate = iprot.readI64();
16642 
        else:
16643 
          iprot.skip(ftype)
16644 
      else:
16645 
        iprot.skip(ftype)
16646 
      iprot.readFieldEnd()
16647 
    iprot.readStructEnd()
16648 
 
16649 
  def write(self, oprot):
16650 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16651 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16652 
      return
16653 
    oprot.writeStructBegin('getReturnOrders_args')
3431 rajveer 16654 
    if self.warehouseId is not None:
2690 chandransh 16655 
      oprot.writeFieldBegin('warehouseId', TType.I64, 1)
16656 
      oprot.writeI64(self.warehouseId)
16657 
      oprot.writeFieldEnd()
3431 rajveer 16658 
    if self.fromDate is not None:
2690 chandransh 16659 
      oprot.writeFieldBegin('fromDate', TType.I64, 2)
16660 
      oprot.writeI64(self.fromDate)
16661 
      oprot.writeFieldEnd()
3431 rajveer 16662 
    if self.toDate is not None:
2690 chandransh 16663 
      oprot.writeFieldBegin('toDate', TType.I64, 3)
16664 
      oprot.writeI64(self.toDate)
16665 
      oprot.writeFieldEnd()
16666 
    oprot.writeFieldStop()
16667 
    oprot.writeStructEnd()
16668 
 
3431 rajveer 16669 
  def validate(self):
16670 
    return
16671 
 
16672 
 
2690 chandransh 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 getReturnOrders_result:
16685 
  """
16686 
  Attributes:
16687 
   - success
16688 
  """
16689 
 
16690 
  thrift_spec = (
16691 
    (0, TType.LIST, 'success', (TType.STRUCT,(ReturnOrder, ReturnOrder.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 = []
5411 rajveer 16709 
          (_etype385, _size382) = iprot.readListBegin()
16710 
          for _i386 in xrange(_size382):
16711 
            _elem387 = ReturnOrder()
16712 
            _elem387.read(iprot)
16713 
            self.success.append(_elem387)
2690 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
16726 
    oprot.writeStructBegin('getReturnOrders_result')
3431 rajveer 16727 
    if self.success is not None:
2690 chandransh 16728 
      oprot.writeFieldBegin('success', TType.LIST, 0)
16729 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
5411 rajveer 16730 
      for iter388 in self.success:
16731 
        iter388.write(oprot)
2690 chandransh 16732 
      oprot.writeListEnd()
16733 
      oprot.writeFieldEnd()
16734 
    oprot.writeFieldStop()
16735 
    oprot.writeStructEnd()
16736 
 
3431 rajveer 16737 
  def validate(self):
16738 
    return
16739 
 
16740 
 
2690 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 
 
5481 phani.kuma 16752 
class getAllReturnOrders_args:
16753 
  """
16754 
  Attributes:
16755 
   - onlyNotProcessed
16756 
   - fromDate
16757 
   - toDate
16758 
  """
16759 
 
16760 
  thrift_spec = (
16761 
    None, # 0
16762 
    (1, TType.BOOL, 'onlyNotProcessed', None, None, ), # 1
16763 
    (2, TType.I64, 'fromDate', None, None, ), # 2
16764 
    (3, TType.I64, 'toDate', None, None, ), # 3
16765 
  )
16766 
 
16767 
  def __init__(self, onlyNotProcessed=None, fromDate=None, toDate=None,):
16768 
    self.onlyNotProcessed = onlyNotProcessed
16769 
    self.fromDate = fromDate
16770 
    self.toDate = toDate
16771 
 
16772 
  def read(self, iprot):
16773 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16774 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16775 
      return
16776 
    iprot.readStructBegin()
16777 
    while True:
16778 
      (fname, ftype, fid) = iprot.readFieldBegin()
16779 
      if ftype == TType.STOP:
16780 
        break
16781 
      if fid == 1:
16782 
        if ftype == TType.BOOL:
16783 
          self.onlyNotProcessed = iprot.readBool();
16784 
        else:
16785 
          iprot.skip(ftype)
16786 
      elif fid == 2:
16787 
        if ftype == TType.I64:
16788 
          self.fromDate = iprot.readI64();
16789 
        else:
16790 
          iprot.skip(ftype)
16791 
      elif fid == 3:
16792 
        if ftype == TType.I64:
16793 
          self.toDate = iprot.readI64();
16794 
        else:
16795 
          iprot.skip(ftype)
16796 
      else:
16797 
        iprot.skip(ftype)
16798 
      iprot.readFieldEnd()
16799 
    iprot.readStructEnd()
16800 
 
16801 
  def write(self, oprot):
16802 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16803 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16804 
      return
16805 
    oprot.writeStructBegin('getAllReturnOrders_args')
16806 
    if self.onlyNotProcessed is not None:
16807 
      oprot.writeFieldBegin('onlyNotProcessed', TType.BOOL, 1)
16808 
      oprot.writeBool(self.onlyNotProcessed)
16809 
      oprot.writeFieldEnd()
16810 
    if self.fromDate is not None:
16811 
      oprot.writeFieldBegin('fromDate', TType.I64, 2)
16812 
      oprot.writeI64(self.fromDate)
16813 
      oprot.writeFieldEnd()
16814 
    if self.toDate is not None:
16815 
      oprot.writeFieldBegin('toDate', TType.I64, 3)
16816 
      oprot.writeI64(self.toDate)
16817 
      oprot.writeFieldEnd()
16818 
    oprot.writeFieldStop()
16819 
    oprot.writeStructEnd()
16820 
 
16821 
  def validate(self):
16822 
    return
16823 
 
16824 
 
16825 
  def __repr__(self):
16826 
    L = ['%s=%r' % (key, value)
16827 
      for key, value in self.__dict__.iteritems()]
16828 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16829 
 
16830 
  def __eq__(self, other):
16831 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16832 
 
16833 
  def __ne__(self, other):
16834 
    return not (self == other)
16835 
 
16836 
class getAllReturnOrders_result:
16837 
  """
16838 
  Attributes:
16839 
   - success
16840 
  """
16841 
 
16842 
  thrift_spec = (
16843 
    (0, TType.LIST, 'success', (TType.STRUCT,(ReturnOrder, ReturnOrder.thrift_spec)), None, ), # 0
16844 
  )
16845 
 
16846 
  def __init__(self, success=None,):
16847 
    self.success = success
16848 
 
16849 
  def read(self, iprot):
16850 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16851 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16852 
      return
16853 
    iprot.readStructBegin()
16854 
    while True:
16855 
      (fname, ftype, fid) = iprot.readFieldBegin()
16856 
      if ftype == TType.STOP:
16857 
        break
16858 
      if fid == 0:
16859 
        if ftype == TType.LIST:
16860 
          self.success = []
16861 
          (_etype392, _size389) = iprot.readListBegin()
16862 
          for _i393 in xrange(_size389):
16863 
            _elem394 = ReturnOrder()
16864 
            _elem394.read(iprot)
16865 
            self.success.append(_elem394)
16866 
          iprot.readListEnd()
16867 
        else:
16868 
          iprot.skip(ftype)
16869 
      else:
16870 
        iprot.skip(ftype)
16871 
      iprot.readFieldEnd()
16872 
    iprot.readStructEnd()
16873 
 
16874 
  def write(self, oprot):
16875 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16876 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16877 
      return
16878 
    oprot.writeStructBegin('getAllReturnOrders_result')
16879 
    if self.success is not None:
16880 
      oprot.writeFieldBegin('success', TType.LIST, 0)
16881 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
16882 
      for iter395 in self.success:
16883 
        iter395.write(oprot)
16884 
      oprot.writeListEnd()
16885 
      oprot.writeFieldEnd()
16886 
    oprot.writeFieldStop()
16887 
    oprot.writeStructEnd()
16888 
 
16889 
  def validate(self):
16890 
    return
16891 
 
16892 
 
16893 
  def __repr__(self):
16894 
    L = ['%s=%r' % (key, value)
16895 
      for key, value in self.__dict__.iteritems()]
16896 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16897 
 
16898 
  def __eq__(self, other):
16899 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16900 
 
16901 
  def __ne__(self, other):
16902 
    return not (self == other)
16903 
 
2700 chandransh 16904 
class getReturnOrder_args:
16905 
  """
16906 
  Attributes:
16907 
   - id
16908 
  """
16909 
 
16910 
  thrift_spec = (
16911 
    None, # 0
16912 
    (1, TType.I64, 'id', None, None, ), # 1
16913 
  )
16914 
 
16915 
  def __init__(self, id=None,):
16916 
    self.id = id
16917 
 
16918 
  def read(self, iprot):
16919 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16920 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16921 
      return
16922 
    iprot.readStructBegin()
16923 
    while True:
16924 
      (fname, ftype, fid) = iprot.readFieldBegin()
16925 
      if ftype == TType.STOP:
16926 
        break
16927 
      if fid == 1:
16928 
        if ftype == TType.I64:
16929 
          self.id = iprot.readI64();
16930 
        else:
16931 
          iprot.skip(ftype)
16932 
      else:
16933 
        iprot.skip(ftype)
16934 
      iprot.readFieldEnd()
16935 
    iprot.readStructEnd()
16936 
 
16937 
  def write(self, oprot):
16938 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16939 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16940 
      return
16941 
    oprot.writeStructBegin('getReturnOrder_args')
3431 rajveer 16942 
    if self.id is not None:
2700 chandransh 16943 
      oprot.writeFieldBegin('id', TType.I64, 1)
16944 
      oprot.writeI64(self.id)
16945 
      oprot.writeFieldEnd()
16946 
    oprot.writeFieldStop()
16947 
    oprot.writeStructEnd()
16948 
 
3431 rajveer 16949 
  def validate(self):
16950 
    return
16951 
 
16952 
 
2700 chandransh 16953 
  def __repr__(self):
16954 
    L = ['%s=%r' % (key, value)
16955 
      for key, value in self.__dict__.iteritems()]
16956 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16957 
 
16958 
  def __eq__(self, other):
16959 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16960 
 
16961 
  def __ne__(self, other):
16962 
    return not (self == other)
16963 
 
16964 
class getReturnOrder_result:
16965 
  """
16966 
  Attributes:
16967 
   - success
16968 
   - ex
16969 
  """
16970 
 
16971 
  thrift_spec = (
16972 
    (0, TType.STRUCT, 'success', (ReturnOrder, ReturnOrder.thrift_spec), None, ), # 0
16973 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
16974 
  )
16975 
 
16976 
  def __init__(self, success=None, ex=None,):
16977 
    self.success = success
16978 
    self.ex = ex
16979 
 
16980 
  def read(self, iprot):
16981 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16982 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16983 
      return
16984 
    iprot.readStructBegin()
16985 
    while True:
16986 
      (fname, ftype, fid) = iprot.readFieldBegin()
16987 
      if ftype == TType.STOP:
16988 
        break
16989 
      if fid == 0:
16990 
        if ftype == TType.STRUCT:
16991 
          self.success = ReturnOrder()
16992 
          self.success.read(iprot)
16993 
        else:
16994 
          iprot.skip(ftype)
16995 
      elif fid == 1:
16996 
        if ftype == TType.STRUCT:
16997 
          self.ex = TransactionServiceException()
16998 
          self.ex.read(iprot)
16999 
        else:
17000 
          iprot.skip(ftype)
17001 
      else:
17002 
        iprot.skip(ftype)
17003 
      iprot.readFieldEnd()
17004 
    iprot.readStructEnd()
17005 
 
17006 
  def write(self, oprot):
17007 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
17008 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
17009 
      return
17010 
    oprot.writeStructBegin('getReturnOrder_result')
3431 rajveer 17011 
    if self.success is not None:
2700 chandransh 17012 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
17013 
      self.success.write(oprot)
17014 
      oprot.writeFieldEnd()
3431 rajveer 17015 
    if self.ex is not None:
2700 chandransh 17016 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
17017 
      self.ex.write(oprot)
17018 
      oprot.writeFieldEnd()
17019 
    oprot.writeFieldStop()
17020 
    oprot.writeStructEnd()
17021 
 
3431 rajveer 17022 
  def validate(self):
17023 
    return
17024 
 
17025 
 
2700 chandransh 17026 
  def __repr__(self):
17027 
    L = ['%s=%r' % (key, value)
17028 
      for key, value in self.__dict__.iteritems()]
17029 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
17030 
 
17031 
  def __eq__(self, other):
17032 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
17033 
 
17034 
  def __ne__(self, other):
17035 
    return not (self == other)
17036 
 
2690 chandransh 17037 
class processReturn_args:
17038 
  """
17039 
  Attributes:
17040 
   - returnOrderId
17041 
  """
17042 
 
17043 
  thrift_spec = (
17044 
    None, # 0
17045 
    (1, TType.I64, 'returnOrderId', None, None, ), # 1
17046 
  )
17047 
 
17048 
  def __init__(self, returnOrderId=None,):
17049 
    self.returnOrderId = returnOrderId
17050 
 
17051 
  def read(self, iprot):
17052 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
17053 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
17054 
      return
17055 
    iprot.readStructBegin()
17056 
    while True:
17057 
      (fname, ftype, fid) = iprot.readFieldBegin()
17058 
      if ftype == TType.STOP:
17059 
        break
17060 
      if fid == 1:
17061 
        if ftype == TType.I64:
17062 
          self.returnOrderId = iprot.readI64();
17063 
        else:
17064 
          iprot.skip(ftype)
17065 
      else:
17066 
        iprot.skip(ftype)
17067 
      iprot.readFieldEnd()
17068 
    iprot.readStructEnd()
17069 
 
17070 
  def write(self, oprot):
17071 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
17072 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
17073 
      return
17074 
    oprot.writeStructBegin('processReturn_args')
3431 rajveer 17075 
    if self.returnOrderId is not None:
2690 chandransh 17076 
      oprot.writeFieldBegin('returnOrderId', TType.I64, 1)
17077 
      oprot.writeI64(self.returnOrderId)
17078 
      oprot.writeFieldEnd()
17079 
    oprot.writeFieldStop()
17080 
    oprot.writeStructEnd()
17081 
 
3431 rajveer 17082 
  def validate(self):
17083 
    return
17084 
 
17085 
 
2690 chandransh 17086 
  def __repr__(self):
17087 
    L = ['%s=%r' % (key, value)
17088 
      for key, value in self.__dict__.iteritems()]
17089 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
17090 
 
17091 
  def __eq__(self, other):
17092 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
17093 
 
17094 
  def __ne__(self, other):
17095 
    return not (self == other)
17096 
 
17097 
class processReturn_result:
17098 
  """
17099 
  Attributes:
17100 
   - ex
17101 
  """
17102 
 
17103 
  thrift_spec = (
17104 
    None, # 0
17105 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
17106 
  )
17107 
 
17108 
  def __init__(self, ex=None,):
17109 
    self.ex = ex
17110 
 
17111 
  def read(self, iprot):
17112 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
17113 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
17114 
      return
17115 
    iprot.readStructBegin()
17116 
    while True:
17117 
      (fname, ftype, fid) = iprot.readFieldBegin()
17118 
      if ftype == TType.STOP:
17119 
        break
17120 
      if fid == 1:
17121 
        if ftype == TType.STRUCT:
17122 
          self.ex = TransactionServiceException()
17123 
          self.ex.read(iprot)
17124 
        else:
17125 
          iprot.skip(ftype)
17126 
      else:
17127 
        iprot.skip(ftype)
17128 
      iprot.readFieldEnd()
17129 
    iprot.readStructEnd()
17130 
 
17131 
  def write(self, oprot):
17132 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
17133 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
17134 
      return
17135 
    oprot.writeStructBegin('processReturn_result')
3431 rajveer 17136 
    if self.ex is not None:
2690 chandransh 17137 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
17138 
      self.ex.write(oprot)
17139 
      oprot.writeFieldEnd()
17140 
    oprot.writeFieldStop()
17141 
    oprot.writeStructEnd()
17142 
 
3431 rajveer 17143 
  def validate(self):
17144 
    return
17145 
 
17146 
 
2690 chandransh 17147 
  def __repr__(self):
17148 
    L = ['%s=%r' % (key, value)
17149 
      for key, value in self.__dict__.iteritems()]
17150 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
17151 
 
17152 
  def __eq__(self, other):
17153 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
17154 
 
17155 
  def __ne__(self, other):
17156 
    return not (self == other)
17157 
 
3451 chandransh 17158 
class updateWeight_args:
17159 
  """
17160 
  Attributes:
17161 
   - orderId
17162 
   - weight
17163 
  """
17164 
 
17165 
  thrift_spec = (
17166 
    None, # 0
17167 
    (1, TType.I64, 'orderId', None, None, ), # 1
17168 
    (2, TType.DOUBLE, 'weight', None, None, ), # 2
17169 
  )
17170 
 
17171 
  def __init__(self, orderId=None, weight=None,):
17172 
    self.orderId = orderId
17173 
    self.weight = weight
17174 
 
17175 
  def read(self, iprot):
17176 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
17177 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
17178 
      return
17179 
    iprot.readStructBegin()
17180 
    while True:
17181 
      (fname, ftype, fid) = iprot.readFieldBegin()
17182 
      if ftype == TType.STOP:
17183 
        break
17184 
      if fid == 1:
17185 
        if ftype == TType.I64:
17186 
          self.orderId = iprot.readI64();
17187 
        else:
17188 
          iprot.skip(ftype)
17189 
      elif fid == 2:
17190 
        if ftype == TType.DOUBLE:
17191 
          self.weight = iprot.readDouble();
17192 
        else:
17193 
          iprot.skip(ftype)
17194 
      else:
17195 
        iprot.skip(ftype)
17196 
      iprot.readFieldEnd()
17197 
    iprot.readStructEnd()
17198 
 
17199 
  def write(self, oprot):
17200 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
17201 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
17202 
      return
17203 
    oprot.writeStructBegin('updateWeight_args')
17204 
    if self.orderId is not None:
17205 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
17206 
      oprot.writeI64(self.orderId)
17207 
      oprot.writeFieldEnd()
17208 
    if self.weight is not None:
17209 
      oprot.writeFieldBegin('weight', TType.DOUBLE, 2)
17210 
      oprot.writeDouble(self.weight)
17211 
      oprot.writeFieldEnd()
17212 
    oprot.writeFieldStop()
17213 
    oprot.writeStructEnd()
17214 
 
17215 
  def validate(self):
17216 
    return
17217 
 
17218 
 
17219 
  def __repr__(self):
17220 
    L = ['%s=%r' % (key, value)
17221 
      for key, value in self.__dict__.iteritems()]
17222 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
17223 
 
17224 
  def __eq__(self, other):
17225 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
17226 
 
17227 
  def __ne__(self, other):
17228 
    return not (self == other)
17229 
 
17230 
class updateWeight_result:
17231 
  """
17232 
  Attributes:
17233 
   - success
17234 
   - ex
17235 
  """
17236 
 
17237 
  thrift_spec = (
17238 
    (0, TType.STRUCT, 'success', (Order, Order.thrift_spec), None, ), # 0
17239 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
17240 
  )
17241 
 
17242 
  def __init__(self, success=None, ex=None,):
17243 
    self.success = success
17244 
    self.ex = ex
17245 
 
17246 
  def read(self, iprot):
17247 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
17248 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
17249 
      return
17250 
    iprot.readStructBegin()
17251 
    while True:
17252 
      (fname, ftype, fid) = iprot.readFieldBegin()
17253 
      if ftype == TType.STOP:
17254 
        break
17255 
      if fid == 0:
17256 
        if ftype == TType.STRUCT:
17257 
          self.success = Order()
17258 
          self.success.read(iprot)
17259 
        else:
17260 
          iprot.skip(ftype)
17261 
      elif fid == 1:
17262 
        if ftype == TType.STRUCT:
17263 
          self.ex = TransactionServiceException()
17264 
          self.ex.read(iprot)
17265 
        else:
17266 
          iprot.skip(ftype)
17267 
      else:
17268 
        iprot.skip(ftype)
17269 
      iprot.readFieldEnd()
17270 
    iprot.readStructEnd()
17271 
 
17272 
  def write(self, oprot):
17273 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
17274 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
17275 
      return
17276 
    oprot.writeStructBegin('updateWeight_result')
17277 
    if self.success is not None:
17278 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
17279 
      self.success.write(oprot)
17280 
      oprot.writeFieldEnd()
17281 
    if self.ex is not None:
17282 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
17283 
      self.ex.write(oprot)
17284 
      oprot.writeFieldEnd()
17285 
    oprot.writeFieldStop()
17286 
    oprot.writeStructEnd()
17287 
 
17288 
  def validate(self):
17289 
    return
17290 
 
17291 
 
17292 
  def __repr__(self):
17293 
    L = ['%s=%r' % (key, value)
17294 
      for key, value in self.__dict__.iteritems()]
17295 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
17296 
 
17297 
  def __eq__(self, other):
17298 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
17299 
 
17300 
  def __ne__(self, other):
17301 
    return not (self == other)
3469 chandransh 17302 
 
17303 
class changeItem_args:
17304 
  """
17305 
  Attributes:
17306 
   - orderId
17307 
   - itemId
17308 
  """
17309 
 
17310 
  thrift_spec = (
17311 
    None, # 0
17312 
    (1, TType.I64, 'orderId', None, None, ), # 1
17313 
    (2, TType.I64, 'itemId', None, None, ), # 2
17314 
  )
17315 
 
17316 
  def __init__(self, orderId=None, itemId=None,):
17317 
    self.orderId = orderId
17318 
    self.itemId = itemId
17319 
 
17320 
  def read(self, iprot):
17321 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
17322 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
17323 
      return
17324 
    iprot.readStructBegin()
17325 
    while True:
17326 
      (fname, ftype, fid) = iprot.readFieldBegin()
17327 
      if ftype == TType.STOP:
17328 
        break
17329 
      if fid == 1:
17330 
        if ftype == TType.I64:
17331 
          self.orderId = iprot.readI64();
17332 
        else:
17333 
          iprot.skip(ftype)
17334 
      elif fid == 2:
17335 
        if ftype == TType.I64:
17336 
          self.itemId = iprot.readI64();
17337 
        else:
17338 
          iprot.skip(ftype)
17339 
      else:
17340 
        iprot.skip(ftype)
17341 
      iprot.readFieldEnd()
17342 
    iprot.readStructEnd()
17343 
 
17344 
  def write(self, oprot):
17345 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
17346 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
17347 
      return
17348 
    oprot.writeStructBegin('changeItem_args')
17349 
    if self.orderId is not None:
17350 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
17351 
      oprot.writeI64(self.orderId)
17352 
      oprot.writeFieldEnd()
17353 
    if self.itemId is not None:
17354 
      oprot.writeFieldBegin('itemId', TType.I64, 2)
17355 
      oprot.writeI64(self.itemId)
17356 
      oprot.writeFieldEnd()
17357 
    oprot.writeFieldStop()
17358 
    oprot.writeStructEnd()
17359 
 
17360 
  def validate(self):
17361 
    return
17362 
 
17363 
 
17364 
  def __repr__(self):
17365 
    L = ['%s=%r' % (key, value)
17366 
      for key, value in self.__dict__.iteritems()]
17367 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
17368 
 
17369 
  def __eq__(self, other):
17370 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
17371 
 
17372 
  def __ne__(self, other):
17373 
    return not (self == other)
17374 
 
17375 
class changeItem_result:
17376 
  """
17377 
  Attributes:
17378 
   - success
17379 
   - ex
17380 
  """
17381 
 
17382 
  thrift_spec = (
17383 
    (0, TType.STRUCT, 'success', (Order, Order.thrift_spec), None, ), # 0
17384 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
17385 
  )
17386 
 
17387 
  def __init__(self, success=None, ex=None,):
17388 
    self.success = success
17389 
    self.ex = ex
17390 
 
17391 
  def read(self, iprot):
17392 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
17393 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
17394 
      return
17395 
    iprot.readStructBegin()
17396 
    while True:
17397 
      (fname, ftype, fid) = iprot.readFieldBegin()
17398 
      if ftype == TType.STOP:
17399 
        break
17400 
      if fid == 0:
17401 
        if ftype == TType.STRUCT:
17402 
          self.success = Order()
17403 
          self.success.read(iprot)
17404 
        else:
17405 
          iprot.skip(ftype)
17406 
      elif fid == 1:
17407 
        if ftype == TType.STRUCT:
17408 
          self.ex = TransactionServiceException()
17409 
          self.ex.read(iprot)
17410 
        else:
17411 
          iprot.skip(ftype)
17412 
      else:
17413 
        iprot.skip(ftype)
17414 
      iprot.readFieldEnd()
17415 
    iprot.readStructEnd()
17416 
 
17417 
  def write(self, oprot):
17418 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
17419 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
17420 
      return
17421 
    oprot.writeStructBegin('changeItem_result')
17422 
    if self.success is not None:
17423 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
17424 
      self.success.write(oprot)
17425 
      oprot.writeFieldEnd()
17426 
    if self.ex is not None:
17427 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
17428 
      self.ex.write(oprot)
17429 
      oprot.writeFieldEnd()
17430 
    oprot.writeFieldStop()
17431 
    oprot.writeStructEnd()
17432 
 
17433 
  def validate(self):
17434 
    return
17435 
 
17436 
 
17437 
  def __repr__(self):
17438 
    L = ['%s=%r' % (key, value)
17439 
      for key, value in self.__dict__.iteritems()]
17440 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
17441 
 
17442 
  def __eq__(self, other):
17443 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
17444 
 
17445 
  def __ne__(self, other):
17446 
    return not (self == other)
17447 
 
17448 
class shiftToWarehouse_args:
17449 
  """
17450 
  Attributes:
17451 
   - orderId
17452 
   - warehouseId
17453 
  """
17454 
 
17455 
  thrift_spec = (
17456 
    None, # 0
17457 
    (1, TType.I64, 'orderId', None, None, ), # 1
17458 
    (2, TType.I64, 'warehouseId', None, None, ), # 2
17459 
  )
17460 
 
17461 
  def __init__(self, orderId=None, warehouseId=None,):
17462 
    self.orderId = orderId
17463 
    self.warehouseId = warehouseId
17464 
 
17465 
  def read(self, iprot):
17466 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
17467 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
17468 
      return
17469 
    iprot.readStructBegin()
17470 
    while True:
17471 
      (fname, ftype, fid) = iprot.readFieldBegin()
17472 
      if ftype == TType.STOP:
17473 
        break
17474 
      if fid == 1:
17475 
        if ftype == TType.I64:
17476 
          self.orderId = iprot.readI64();
17477 
        else:
17478 
          iprot.skip(ftype)
17479 
      elif fid == 2:
17480 
        if ftype == TType.I64:
17481 
          self.warehouseId = iprot.readI64();
17482 
        else:
17483 
          iprot.skip(ftype)
17484 
      else:
17485 
        iprot.skip(ftype)
17486 
      iprot.readFieldEnd()
17487 
    iprot.readStructEnd()
17488 
 
17489 
  def write(self, oprot):
17490 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
17491 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
17492 
      return
17493 
    oprot.writeStructBegin('shiftToWarehouse_args')
17494 
    if self.orderId is not None:
17495 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
17496 
      oprot.writeI64(self.orderId)
17497 
      oprot.writeFieldEnd()
17498 
    if self.warehouseId is not None:
17499 
      oprot.writeFieldBegin('warehouseId', TType.I64, 2)
17500 
      oprot.writeI64(self.warehouseId)
17501 
      oprot.writeFieldEnd()
17502 
    oprot.writeFieldStop()
17503 
    oprot.writeStructEnd()
17504 
 
17505 
  def validate(self):
17506 
    return
17507 
 
17508 
 
17509 
  def __repr__(self):
17510 
    L = ['%s=%r' % (key, value)
17511 
      for key, value in self.__dict__.iteritems()]
17512 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
17513 
 
17514 
  def __eq__(self, other):
17515 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
17516 
 
17517 
  def __ne__(self, other):
17518 
    return not (self == other)
17519 
 
17520 
class shiftToWarehouse_result:
17521 
  """
17522 
  Attributes:
17523 
   - success
17524 
   - ex
17525 
  """
17526 
 
17527 
  thrift_spec = (
17528 
    (0, TType.STRUCT, 'success', (Order, Order.thrift_spec), None, ), # 0
17529 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
17530 
  )
17531 
 
17532 
  def __init__(self, success=None, ex=None,):
17533 
    self.success = success
17534 
    self.ex = ex
17535 
 
17536 
  def read(self, iprot):
17537 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
17538 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
17539 
      return
17540 
    iprot.readStructBegin()
17541 
    while True:
17542 
      (fname, ftype, fid) = iprot.readFieldBegin()
17543 
      if ftype == TType.STOP:
17544 
        break
17545 
      if fid == 0:
17546 
        if ftype == TType.STRUCT:
17547 
          self.success = Order()
17548 
          self.success.read(iprot)
17549 
        else:
17550 
          iprot.skip(ftype)
17551 
      elif fid == 1:
17552 
        if ftype == TType.STRUCT:
17553 
          self.ex = TransactionServiceException()
17554 
          self.ex.read(iprot)
17555 
        else:
17556 
          iprot.skip(ftype)
17557 
      else:
17558 
        iprot.skip(ftype)
17559 
      iprot.readFieldEnd()
17560 
    iprot.readStructEnd()
17561 
 
17562 
  def write(self, oprot):
17563 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
17564 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
17565 
      return
17566 
    oprot.writeStructBegin('shiftToWarehouse_result')
17567 
    if self.success is not None:
17568 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
17569 
      self.success.write(oprot)
17570 
      oprot.writeFieldEnd()
17571 
    if self.ex is not None:
17572 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
17573 
      self.ex.write(oprot)
17574 
      oprot.writeFieldEnd()
17575 
    oprot.writeFieldStop()
17576 
    oprot.writeStructEnd()
17577 
 
17578 
  def validate(self):
17579 
    return
17580 
 
17581 
 
17582 
  def __repr__(self):
17583 
    L = ['%s=%r' % (key, value)
17584 
      for key, value in self.__dict__.iteritems()]
17585 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
17586 
 
17587 
  def __eq__(self, other):
17588 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
17589 
 
17590 
  def __ne__(self, other):
17591 
    return not (self == other)
3553 chandransh 17592 
 
17593 
class addDelayReason_args:
17594 
  """
17595 
  Attributes:
17596 
   - orderId
17597 
   - delayReason
3986 chandransh 17598 
   - furtherDelay
4647 rajveer 17599 
   - delayReasonText
3553 chandransh 17600 
  """
17601 
 
17602 
  thrift_spec = (
17603 
    None, # 0
17604 
    (1, TType.I64, 'orderId', None, None, ), # 1
17605 
    (2, TType.I32, 'delayReason', None, None, ), # 2
3986 chandransh 17606 
    (3, TType.I64, 'furtherDelay', None, None, ), # 3
4647 rajveer 17607 
    (4, TType.STRING, 'delayReasonText', None, None, ), # 4
3553 chandransh 17608 
  )
17609 
 
4647 rajveer 17610 
  def __init__(self, orderId=None, delayReason=None, furtherDelay=None, delayReasonText=None,):
3553 chandransh 17611 
    self.orderId = orderId
17612 
    self.delayReason = delayReason
3986 chandransh 17613 
    self.furtherDelay = furtherDelay
4647 rajveer 17614 
    self.delayReasonText = delayReasonText
3553 chandransh 17615 
 
17616 
  def read(self, iprot):
17617 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
17618 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
17619 
      return
17620 
    iprot.readStructBegin()
17621 
    while True:
17622 
      (fname, ftype, fid) = iprot.readFieldBegin()
17623 
      if ftype == TType.STOP:
17624 
        break
17625 
      if fid == 1:
17626 
        if ftype == TType.I64:
17627 
          self.orderId = iprot.readI64();
17628 
        else:
17629 
          iprot.skip(ftype)
17630 
      elif fid == 2:
17631 
        if ftype == TType.I32:
17632 
          self.delayReason = iprot.readI32();
17633 
        else:
17634 
          iprot.skip(ftype)
3986 chandransh 17635 
      elif fid == 3:
17636 
        if ftype == TType.I64:
17637 
          self.furtherDelay = iprot.readI64();
17638 
        else:
17639 
          iprot.skip(ftype)
4647 rajveer 17640 
      elif fid == 4:
17641 
        if ftype == TType.STRING:
17642 
          self.delayReasonText = iprot.readString();
17643 
        else:
17644 
          iprot.skip(ftype)
3553 chandransh 17645 
      else:
17646 
        iprot.skip(ftype)
17647 
      iprot.readFieldEnd()
17648 
    iprot.readStructEnd()
17649 
 
17650 
  def write(self, oprot):
17651 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
17652 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
17653 
      return
17654 
    oprot.writeStructBegin('addDelayReason_args')
17655 
    if self.orderId is not None:
17656 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
17657 
      oprot.writeI64(self.orderId)
17658 
      oprot.writeFieldEnd()
17659 
    if self.delayReason is not None:
17660 
      oprot.writeFieldBegin('delayReason', TType.I32, 2)
17661 
      oprot.writeI32(self.delayReason)
17662 
      oprot.writeFieldEnd()
3986 chandransh 17663 
    if self.furtherDelay is not None:
17664 
      oprot.writeFieldBegin('furtherDelay', TType.I64, 3)
17665 
      oprot.writeI64(self.furtherDelay)
17666 
      oprot.writeFieldEnd()
4647 rajveer 17667 
    if self.delayReasonText is not None:
17668 
      oprot.writeFieldBegin('delayReasonText', TType.STRING, 4)
17669 
      oprot.writeString(self.delayReasonText)
17670 
      oprot.writeFieldEnd()
3553 chandransh 17671 
    oprot.writeFieldStop()
17672 
    oprot.writeStructEnd()
17673 
 
17674 
  def validate(self):
17675 
    return
17676 
 
17677 
 
17678 
  def __repr__(self):
17679 
    L = ['%s=%r' % (key, value)
17680 
      for key, value in self.__dict__.iteritems()]
17681 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
17682 
 
17683 
  def __eq__(self, other):
17684 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
17685 
 
17686 
  def __ne__(self, other):
17687 
    return not (self == other)
17688 
 
17689 
class addDelayReason_result:
17690 
  """
17691 
  Attributes:
17692 
   - success
17693 
   - ex
17694 
  """
17695 
 
17696 
  thrift_spec = (
17697 
    (0, TType.BOOL, 'success', None, None, ), # 0
17698 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
17699 
  )
17700 
 
17701 
  def __init__(self, success=None, ex=None,):
17702 
    self.success = success
17703 
    self.ex = ex
17704 
 
17705 
  def read(self, iprot):
17706 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
17707 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
17708 
      return
17709 
    iprot.readStructBegin()
17710 
    while True:
17711 
      (fname, ftype, fid) = iprot.readFieldBegin()
17712 
      if ftype == TType.STOP:
17713 
        break
17714 
      if fid == 0:
17715 
        if ftype == TType.BOOL:
17716 
          self.success = iprot.readBool();
17717 
        else:
17718 
          iprot.skip(ftype)
17719 
      elif fid == 1:
17720 
        if ftype == TType.STRUCT:
17721 
          self.ex = TransactionServiceException()
17722 
          self.ex.read(iprot)
17723 
        else:
17724 
          iprot.skip(ftype)
17725 
      else:
17726 
        iprot.skip(ftype)
17727 
      iprot.readFieldEnd()
17728 
    iprot.readStructEnd()
17729 
 
17730 
  def write(self, oprot):
17731 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
17732 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
17733 
      return
17734 
    oprot.writeStructBegin('addDelayReason_result')
17735 
    if self.success is not None:
17736 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
17737 
      oprot.writeBool(self.success)
17738 
      oprot.writeFieldEnd()
17739 
    if self.ex is not None:
17740 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
17741 
      self.ex.write(oprot)
17742 
      oprot.writeFieldEnd()
17743 
    oprot.writeFieldStop()
17744 
    oprot.writeStructEnd()
17745 
 
17746 
  def validate(self):
17747 
    return
17748 
 
17749 
 
17750 
  def __repr__(self):
17751 
    L = ['%s=%r' % (key, value)
17752 
      for key, value in self.__dict__.iteritems()]
17753 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
17754 
 
17755 
  def __eq__(self, other):
17756 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
17757 
 
17758 
  def __ne__(self, other):
17759 
    return not (self == other)
3956 chandransh 17760 
 
17761 
class reconcileCodCollection_args:
17762 
  """
17763 
  Attributes:
17764 
   - collectedAmountMap
17765 
   - xferBy
17766 
   - xferTxnId
17767 
   - xferDate
17768 
  """
17769 
 
17770 
  thrift_spec = (
17771 
    None, # 0
17772 
    (1, TType.MAP, 'collectedAmountMap', (TType.STRING,None,TType.DOUBLE,None), None, ), # 1
17773 
    (2, TType.STRING, 'xferBy', None, None, ), # 2
17774 
    (3, TType.STRING, 'xferTxnId', None, None, ), # 3
17775 
    (4, TType.I64, 'xferDate', None, None, ), # 4
17776 
  )
17777 
 
17778 
  def __init__(self, collectedAmountMap=None, xferBy=None, xferTxnId=None, xferDate=None,):
17779 
    self.collectedAmountMap = collectedAmountMap
17780 
    self.xferBy = xferBy
17781 
    self.xferTxnId = xferTxnId
17782 
    self.xferDate = xferDate
17783 
 
17784 
  def read(self, iprot):
17785 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
17786 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
17787 
      return
17788 
    iprot.readStructBegin()
17789 
    while True:
17790 
      (fname, ftype, fid) = iprot.readFieldBegin()
17791 
      if ftype == TType.STOP:
17792 
        break
17793 
      if fid == 1:
17794 
        if ftype == TType.MAP:
17795 
          self.collectedAmountMap = {}
5481 phani.kuma 17796 
          (_ktype397, _vtype398, _size396 ) = iprot.readMapBegin()
17797 
          for _i400 in xrange(_size396):
17798 
            _key401 = iprot.readString();
17799 
            _val402 = iprot.readDouble();
17800 
            self.collectedAmountMap[_key401] = _val402
3956 chandransh 17801 
          iprot.readMapEnd()
17802 
        else:
17803 
          iprot.skip(ftype)
17804 
      elif fid == 2:
17805 
        if ftype == TType.STRING:
17806 
          self.xferBy = iprot.readString();
17807 
        else:
17808 
          iprot.skip(ftype)
17809 
      elif fid == 3:
17810 
        if ftype == TType.STRING:
17811 
          self.xferTxnId = iprot.readString();
17812 
        else:
17813 
          iprot.skip(ftype)
17814 
      elif fid == 4:
17815 
        if ftype == TType.I64:
17816 
          self.xferDate = iprot.readI64();
17817 
        else:
17818 
          iprot.skip(ftype)
17819 
      else:
17820 
        iprot.skip(ftype)
17821 
      iprot.readFieldEnd()
17822 
    iprot.readStructEnd()
17823 
 
17824 
  def write(self, oprot):
17825 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
17826 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
17827 
      return
17828 
    oprot.writeStructBegin('reconcileCodCollection_args')
17829 
    if self.collectedAmountMap is not None:
17830 
      oprot.writeFieldBegin('collectedAmountMap', TType.MAP, 1)
17831 
      oprot.writeMapBegin(TType.STRING, TType.DOUBLE, len(self.collectedAmountMap))
5481 phani.kuma 17832 
      for kiter403,viter404 in self.collectedAmountMap.items():
17833 
        oprot.writeString(kiter403)
17834 
        oprot.writeDouble(viter404)
3956 chandransh 17835 
      oprot.writeMapEnd()
17836 
      oprot.writeFieldEnd()
17837 
    if self.xferBy is not None:
17838 
      oprot.writeFieldBegin('xferBy', TType.STRING, 2)
17839 
      oprot.writeString(self.xferBy)
17840 
      oprot.writeFieldEnd()
17841 
    if self.xferTxnId is not None:
17842 
      oprot.writeFieldBegin('xferTxnId', TType.STRING, 3)
17843 
      oprot.writeString(self.xferTxnId)
17844 
      oprot.writeFieldEnd()
17845 
    if self.xferDate is not None:
17846 
      oprot.writeFieldBegin('xferDate', TType.I64, 4)
17847 
      oprot.writeI64(self.xferDate)
17848 
      oprot.writeFieldEnd()
17849 
    oprot.writeFieldStop()
17850 
    oprot.writeStructEnd()
17851 
 
17852 
  def validate(self):
17853 
    return
17854 
 
17855 
 
17856 
  def __repr__(self):
17857 
    L = ['%s=%r' % (key, value)
17858 
      for key, value in self.__dict__.iteritems()]
17859 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
17860 
 
17861 
  def __eq__(self, other):
17862 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
17863 
 
17864 
  def __ne__(self, other):
17865 
    return not (self == other)
17866 
 
17867 
class reconcileCodCollection_result:
17868 
  """
17869 
  Attributes:
17870 
   - success
17871 
   - ex
17872 
  """
17873 
 
17874 
  thrift_spec = (
17875 
    (0, TType.MAP, 'success', (TType.STRING,None,TType.STRING,None), None, ), # 0
17876 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
17877 
  )
17878 
 
17879 
  def __init__(self, success=None, ex=None,):
17880 
    self.success = success
17881 
    self.ex = ex
17882 
 
17883 
  def read(self, iprot):
17884 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
17885 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
17886 
      return
17887 
    iprot.readStructBegin()
17888 
    while True:
17889 
      (fname, ftype, fid) = iprot.readFieldBegin()
17890 
      if ftype == TType.STOP:
17891 
        break
17892 
      if fid == 0:
17893 
        if ftype == TType.MAP:
17894 
          self.success = {}
5481 phani.kuma 17895 
          (_ktype406, _vtype407, _size405 ) = iprot.readMapBegin()
17896 
          for _i409 in xrange(_size405):
17897 
            _key410 = iprot.readString();
17898 
            _val411 = iprot.readString();
17899 
            self.success[_key410] = _val411
3956 chandransh 17900 
          iprot.readMapEnd()
17901 
        else:
17902 
          iprot.skip(ftype)
17903 
      elif fid == 1:
17904 
        if ftype == TType.STRUCT:
17905 
          self.ex = TransactionServiceException()
17906 
          self.ex.read(iprot)
17907 
        else:
17908 
          iprot.skip(ftype)
17909 
      else:
17910 
        iprot.skip(ftype)
17911 
      iprot.readFieldEnd()
17912 
    iprot.readStructEnd()
17913 
 
17914 
  def write(self, oprot):
17915 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
17916 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
17917 
      return
17918 
    oprot.writeStructBegin('reconcileCodCollection_result')
17919 
    if self.success is not None:
17920 
      oprot.writeFieldBegin('success', TType.MAP, 0)
17921 
      oprot.writeMapBegin(TType.STRING, TType.STRING, len(self.success))
5481 phani.kuma 17922 
      for kiter412,viter413 in self.success.items():
17923 
        oprot.writeString(kiter412)
17924 
        oprot.writeString(viter413)
3956 chandransh 17925 
      oprot.writeMapEnd()
17926 
      oprot.writeFieldEnd()
17927 
    if self.ex is not None:
17928 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
17929 
      self.ex.write(oprot)
17930 
      oprot.writeFieldEnd()
17931 
    oprot.writeFieldStop()
17932 
    oprot.writeStructEnd()
17933 
 
17934 
  def validate(self):
17935 
    return
17936 
 
17937 
 
17938 
  def __repr__(self):
17939 
    L = ['%s=%r' % (key, value)
17940 
      for key, value in self.__dict__.iteritems()]
17941 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
17942 
 
17943 
  def __eq__(self, other):
17944 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
17945 
 
17946 
  def __ne__(self, other):
17947 
    return not (self == other)
4008 mandeep.dh 17948 
 
17949 
class getTransactionsRequiringExtraProcessing_args:
17950 
  """
17951 
  Attributes:
17952 
   - category
17953 
  """
17954 
 
17955 
  thrift_spec = (
17956 
    None, # 0
17957 
    (1, TType.I32, 'category', None, None, ), # 1
17958 
  )
17959 
 
17960 
  def __init__(self, category=None,):
17961 
    self.category = category
17962 
 
17963 
  def read(self, iprot):
17964 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
17965 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
17966 
      return
17967 
    iprot.readStructBegin()
17968 
    while True:
17969 
      (fname, ftype, fid) = iprot.readFieldBegin()
17970 
      if ftype == TType.STOP:
17971 
        break
17972 
      if fid == 1:
17973 
        if ftype == TType.I32:
17974 
          self.category = iprot.readI32();
17975 
        else:
17976 
          iprot.skip(ftype)
17977 
      else:
17978 
        iprot.skip(ftype)
17979 
      iprot.readFieldEnd()
17980 
    iprot.readStructEnd()
17981 
 
17982 
  def write(self, oprot):
17983 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
17984 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
17985 
      return
17986 
    oprot.writeStructBegin('getTransactionsRequiringExtraProcessing_args')
17987 
    if self.category is not None:
17988 
      oprot.writeFieldBegin('category', TType.I32, 1)
17989 
      oprot.writeI32(self.category)
17990 
      oprot.writeFieldEnd()
17991 
    oprot.writeFieldStop()
17992 
    oprot.writeStructEnd()
17993 
 
17994 
  def validate(self):
17995 
    return
17996 
 
17997 
 
17998 
  def __repr__(self):
17999 
    L = ['%s=%r' % (key, value)
18000 
      for key, value in self.__dict__.iteritems()]
18001 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
18002 
 
18003 
  def __eq__(self, other):
18004 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
18005 
 
18006 
  def __ne__(self, other):
18007 
    return not (self == other)
18008 
 
18009 
class getTransactionsRequiringExtraProcessing_result:
18010 
  """
18011 
  Attributes:
18012 
   - success
18013 
  """
18014 
 
18015 
  thrift_spec = (
18016 
    (0, TType.LIST, 'success', (TType.I64,None), None, ), # 0
18017 
  )
18018 
 
18019 
  def __init__(self, success=None,):
18020 
    self.success = success
18021 
 
18022 
  def read(self, iprot):
18023 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
18024 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
18025 
      return
18026 
    iprot.readStructBegin()
18027 
    while True:
18028 
      (fname, ftype, fid) = iprot.readFieldBegin()
18029 
      if ftype == TType.STOP:
18030 
        break
18031 
      if fid == 0:
18032 
        if ftype == TType.LIST:
18033 
          self.success = []
5481 phani.kuma 18034 
          (_etype417, _size414) = iprot.readListBegin()
18035 
          for _i418 in xrange(_size414):
18036 
            _elem419 = iprot.readI64();
18037 
            self.success.append(_elem419)
4008 mandeep.dh 18038 
          iprot.readListEnd()
18039 
        else:
18040 
          iprot.skip(ftype)
18041 
      else:
18042 
        iprot.skip(ftype)
18043 
      iprot.readFieldEnd()
18044 
    iprot.readStructEnd()
18045 
 
18046 
  def write(self, oprot):
18047 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
18048 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
18049 
      return
18050 
    oprot.writeStructBegin('getTransactionsRequiringExtraProcessing_result')
18051 
    if self.success is not None:
18052 
      oprot.writeFieldBegin('success', TType.LIST, 0)
18053 
      oprot.writeListBegin(TType.I64, len(self.success))
5481 phani.kuma 18054 
      for iter420 in self.success:
18055 
        oprot.writeI64(iter420)
4008 mandeep.dh 18056 
      oprot.writeListEnd()
18057 
      oprot.writeFieldEnd()
18058 
    oprot.writeFieldStop()
18059 
    oprot.writeStructEnd()
18060 
 
18061 
  def validate(self):
18062 
    return
18063 
 
18064 
 
18065 
  def __repr__(self):
18066 
    L = ['%s=%r' % (key, value)
18067 
      for key, value in self.__dict__.iteritems()]
18068 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
18069 
 
18070 
  def __eq__(self, other):
18071 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
18072 
 
18073 
  def __ne__(self, other):
18074 
    return not (self == other)
18075 
 
18076 
class markTransactionAsProcessed_args:
18077 
  """
18078 
  Attributes:
18079 
   - transactionId
18080 
   - category
18081 
  """
18082 
 
18083 
  thrift_spec = (
18084 
    None, # 0
18085 
    (1, TType.I64, 'transactionId', None, None, ), # 1
18086 
    (2, TType.I32, 'category', None, None, ), # 2
18087 
  )
18088 
 
18089 
  def __init__(self, transactionId=None, category=None,):
18090 
    self.transactionId = transactionId
18091 
    self.category = category
18092 
 
18093 
  def read(self, iprot):
18094 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
18095 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
18096 
      return
18097 
    iprot.readStructBegin()
18098 
    while True:
18099 
      (fname, ftype, fid) = iprot.readFieldBegin()
18100 
      if ftype == TType.STOP:
18101 
        break
18102 
      if fid == 1:
18103 
        if ftype == TType.I64:
18104 
          self.transactionId = iprot.readI64();
18105 
        else:
18106 
          iprot.skip(ftype)
18107 
      elif fid == 2:
18108 
        if ftype == TType.I32:
18109 
          self.category = iprot.readI32();
18110 
        else:
18111 
          iprot.skip(ftype)
18112 
      else:
18113 
        iprot.skip(ftype)
18114 
      iprot.readFieldEnd()
18115 
    iprot.readStructEnd()
18116 
 
18117 
  def write(self, oprot):
18118 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
18119 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
18120 
      return
18121 
    oprot.writeStructBegin('markTransactionAsProcessed_args')
18122 
    if self.transactionId is not None:
18123 
      oprot.writeFieldBegin('transactionId', TType.I64, 1)
18124 
      oprot.writeI64(self.transactionId)
18125 
      oprot.writeFieldEnd()
18126 
    if self.category is not None:
18127 
      oprot.writeFieldBegin('category', TType.I32, 2)
18128 
      oprot.writeI32(self.category)
18129 
      oprot.writeFieldEnd()
18130 
    oprot.writeFieldStop()
18131 
    oprot.writeStructEnd()
18132 
 
18133 
  def validate(self):
18134 
    return
18135 
 
18136 
 
18137 
  def __repr__(self):
18138 
    L = ['%s=%r' % (key, value)
18139 
      for key, value in self.__dict__.iteritems()]
18140 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
18141 
 
18142 
  def __eq__(self, other):
18143 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
18144 
 
18145 
  def __ne__(self, other):
18146 
    return not (self == other)
18147 
 
18148 
class markTransactionAsProcessed_result:
18149 
 
18150 
  thrift_spec = (
18151 
  )
18152 
 
18153 
  def read(self, iprot):
18154 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
18155 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
18156 
      return
18157 
    iprot.readStructBegin()
18158 
    while True:
18159 
      (fname, ftype, fid) = iprot.readFieldBegin()
18160 
      if ftype == TType.STOP:
18161 
        break
18162 
      else:
18163 
        iprot.skip(ftype)
18164 
      iprot.readFieldEnd()
18165 
    iprot.readStructEnd()
18166 
 
18167 
  def write(self, oprot):
18168 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
18169 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
18170 
      return
18171 
    oprot.writeStructBegin('markTransactionAsProcessed_result')
18172 
    oprot.writeFieldStop()
18173 
    oprot.writeStructEnd()
18174 
 
18175 
  def validate(self):
18176 
    return
18177 
 
18178 
 
18179 
  def __repr__(self):
18180 
    L = ['%s=%r' % (key, value)
18181 
      for key, value in self.__dict__.iteritems()]
18182 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
18183 
 
18184 
  def __eq__(self, other):
18185 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
18186 
 
18187 
  def __ne__(self, other):
18188 
    return not (self == other)
4018 chandransh 18189 
 
18190 
class getItemWiseRiskyOrdersCount_args:
18191 
 
18192 
  thrift_spec = (
18193 
  )
18194 
 
18195 
  def read(self, iprot):
18196 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
18197 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
18198 
      return
18199 
    iprot.readStructBegin()
18200 
    while True:
18201 
      (fname, ftype, fid) = iprot.readFieldBegin()
18202 
      if ftype == TType.STOP:
18203 
        break
18204 
      else:
18205 
        iprot.skip(ftype)
18206 
      iprot.readFieldEnd()
18207 
    iprot.readStructEnd()
18208 
 
18209 
  def write(self, oprot):
18210 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
18211 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
18212 
      return
18213 
    oprot.writeStructBegin('getItemWiseRiskyOrdersCount_args')
18214 
    oprot.writeFieldStop()
18215 
    oprot.writeStructEnd()
18216 
 
18217 
  def validate(self):
18218 
    return
18219 
 
18220 
 
18221 
  def __repr__(self):
18222 
    L = ['%s=%r' % (key, value)
18223 
      for key, value in self.__dict__.iteritems()]
18224 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
18225 
 
18226 
  def __eq__(self, other):
18227 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
18228 
 
18229 
  def __ne__(self, other):
18230 
    return not (self == other)
18231 
 
18232 
class getItemWiseRiskyOrdersCount_result:
18233 
  """
18234 
  Attributes:
18235 
   - success
18236 
  """
18237 
 
18238 
  thrift_spec = (
18239 
    (0, TType.MAP, 'success', (TType.I64,None,TType.I64,None), None, ), # 0
18240 
  )
18241 
 
18242 
  def __init__(self, success=None,):
18243 
    self.success = success
18244 
 
18245 
  def read(self, iprot):
18246 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
18247 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
18248 
      return
18249 
    iprot.readStructBegin()
18250 
    while True:
18251 
      (fname, ftype, fid) = iprot.readFieldBegin()
18252 
      if ftype == TType.STOP:
18253 
        break
18254 
      if fid == 0:
18255 
        if ftype == TType.MAP:
18256 
          self.success = {}
5481 phani.kuma 18257 
          (_ktype422, _vtype423, _size421 ) = iprot.readMapBegin()
18258 
          for _i425 in xrange(_size421):
18259 
            _key426 = iprot.readI64();
18260 
            _val427 = iprot.readI64();
18261 
            self.success[_key426] = _val427
4018 chandransh 18262 
          iprot.readMapEnd()
18263 
        else:
18264 
          iprot.skip(ftype)
18265 
      else:
18266 
        iprot.skip(ftype)
18267 
      iprot.readFieldEnd()
18268 
    iprot.readStructEnd()
18269 
 
18270 
  def write(self, oprot):
18271 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
18272 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
18273 
      return
18274 
    oprot.writeStructBegin('getItemWiseRiskyOrdersCount_result')
18275 
    if self.success is not None:
18276 
      oprot.writeFieldBegin('success', TType.MAP, 0)
18277 
      oprot.writeMapBegin(TType.I64, TType.I64, len(self.success))
5481 phani.kuma 18278 
      for kiter428,viter429 in self.success.items():
18279 
        oprot.writeI64(kiter428)
18280 
        oprot.writeI64(viter429)
4018 chandransh 18281 
      oprot.writeMapEnd()
18282 
      oprot.writeFieldEnd()
18283 
    oprot.writeFieldStop()
18284 
    oprot.writeStructEnd()
18285 
 
18286 
  def validate(self):
18287 
    return
18288 
 
18289 
 
18290 
  def __repr__(self):
18291 
    L = ['%s=%r' % (key, value)
18292 
      for key, value in self.__dict__.iteritems()]
18293 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
18294 
 
18295 
  def __eq__(self, other):
18296 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
18297 
 
18298 
  def __ne__(self, other):
18299 
    return not (self == other)
4247 rajveer 18300 
 
4295 varun.gupt 18301 
class getOrdersForItemIds_args:
18302 
  """
18303 
  Attributes:
18304 
   - itemIds
18305 
  """
18306 
 
18307 
  thrift_spec = (
18308 
    None, # 0
18309 
    (1, TType.LIST, 'itemIds', (TType.I64,None), None, ), # 1
18310 
  )
18311 
 
18312 
  def __init__(self, itemIds=None,):
18313 
    self.itemIds = itemIds
18314 
 
18315 
  def read(self, iprot):
18316 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
18317 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
18318 
      return
18319 
    iprot.readStructBegin()
18320 
    while True:
18321 
      (fname, ftype, fid) = iprot.readFieldBegin()
18322 
      if ftype == TType.STOP:
18323 
        break
18324 
      if fid == 1:
18325 
        if ftype == TType.LIST:
18326 
          self.itemIds = []
5481 phani.kuma 18327 
          (_etype433, _size430) = iprot.readListBegin()
18328 
          for _i434 in xrange(_size430):
18329 
            _elem435 = iprot.readI64();
18330 
            self.itemIds.append(_elem435)
4295 varun.gupt 18331 
          iprot.readListEnd()
18332 
        else:
18333 
          iprot.skip(ftype)
18334 
      else:
18335 
        iprot.skip(ftype)
18336 
      iprot.readFieldEnd()
18337 
    iprot.readStructEnd()
18338 
 
18339 
  def write(self, oprot):
18340 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
18341 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
18342 
      return
18343 
    oprot.writeStructBegin('getOrdersForItemIds_args')
18344 
    if self.itemIds is not None:
18345 
      oprot.writeFieldBegin('itemIds', TType.LIST, 1)
18346 
      oprot.writeListBegin(TType.I64, len(self.itemIds))
5481 phani.kuma 18347 
      for iter436 in self.itemIds:
18348 
        oprot.writeI64(iter436)
4295 varun.gupt 18349 
      oprot.writeListEnd()
18350 
      oprot.writeFieldEnd()
18351 
    oprot.writeFieldStop()
18352 
    oprot.writeStructEnd()
18353 
 
18354 
  def validate(self):
18355 
    return
18356 
 
18357 
 
18358 
  def __repr__(self):
18359 
    L = ['%s=%r' % (key, value)
18360 
      for key, value in self.__dict__.iteritems()]
18361 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
18362 
 
18363 
  def __eq__(self, other):
18364 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
18365 
 
18366 
  def __ne__(self, other):
18367 
    return not (self == other)
18368 
 
18369 
class getOrdersForItemIds_result:
18370 
  """
18371 
  Attributes:
18372 
   - success
18373 
  """
18374 
 
18375 
  thrift_spec = (
18376 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
18377 
  )
18378 
 
18379 
  def __init__(self, success=None,):
18380 
    self.success = success
18381 
 
18382 
  def read(self, iprot):
18383 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
18384 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
18385 
      return
18386 
    iprot.readStructBegin()
18387 
    while True:
18388 
      (fname, ftype, fid) = iprot.readFieldBegin()
18389 
      if ftype == TType.STOP:
18390 
        break
18391 
      if fid == 0:
18392 
        if ftype == TType.LIST:
18393 
          self.success = []
5481 phani.kuma 18394 
          (_etype440, _size437) = iprot.readListBegin()
18395 
          for _i441 in xrange(_size437):
18396 
            _elem442 = Order()
18397 
            _elem442.read(iprot)
18398 
            self.success.append(_elem442)
4295 varun.gupt 18399 
          iprot.readListEnd()
18400 
        else:
18401 
          iprot.skip(ftype)
18402 
      else:
18403 
        iprot.skip(ftype)
18404 
      iprot.readFieldEnd()
18405 
    iprot.readStructEnd()
18406 
 
18407 
  def write(self, oprot):
18408 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
18409 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
18410 
      return
18411 
    oprot.writeStructBegin('getOrdersForItemIds_result')
18412 
    if self.success is not None:
18413 
      oprot.writeFieldBegin('success', TType.LIST, 0)
18414 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
5481 phani.kuma 18415 
      for iter443 in self.success:
18416 
        iter443.write(oprot)
4295 varun.gupt 18417 
      oprot.writeListEnd()
18418 
      oprot.writeFieldEnd()
18419 
    oprot.writeFieldStop()
18420 
    oprot.writeStructEnd()
18421 
 
18422 
  def validate(self):
18423 
    return
18424 
 
18425 
 
18426 
  def __repr__(self):
18427 
    L = ['%s=%r' % (key, value)
18428 
      for key, value in self.__dict__.iteritems()]
18429 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
18430 
 
18431 
  def __eq__(self, other):
18432 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
18433 
 
18434 
  def __ne__(self, other):
18435 
    return not (self == other)
18436 
 
4247 rajveer 18437 
class markOrderCancellationRequestReceived_args:
18438 
  """
18439 
  Attributes:
18440 
   - orderId
18441 
  """
18442 
 
18443 
  thrift_spec = (
18444 
    None, # 0
18445 
    (1, TType.I64, 'orderId', None, None, ), # 1
18446 
  )
18447 
 
18448 
  def __init__(self, orderId=None,):
18449 
    self.orderId = orderId
18450 
 
18451 
  def read(self, iprot):
18452 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
18453 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
18454 
      return
18455 
    iprot.readStructBegin()
18456 
    while True:
18457 
      (fname, ftype, fid) = iprot.readFieldBegin()
18458 
      if ftype == TType.STOP:
18459 
        break
18460 
      if fid == 1:
18461 
        if ftype == TType.I64:
18462 
          self.orderId = iprot.readI64();
18463 
        else:
18464 
          iprot.skip(ftype)
18465 
      else:
18466 
        iprot.skip(ftype)
18467 
      iprot.readFieldEnd()
18468 
    iprot.readStructEnd()
18469 
 
18470 
  def write(self, oprot):
18471 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
18472 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
18473 
      return
18474 
    oprot.writeStructBegin('markOrderCancellationRequestReceived_args')
18475 
    if self.orderId is not None:
18476 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
18477 
      oprot.writeI64(self.orderId)
18478 
      oprot.writeFieldEnd()
18479 
    oprot.writeFieldStop()
18480 
    oprot.writeStructEnd()
18481 
 
18482 
  def validate(self):
18483 
    return
18484 
 
18485 
 
18486 
  def __repr__(self):
18487 
    L = ['%s=%r' % (key, value)
18488 
      for key, value in self.__dict__.iteritems()]
18489 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
18490 
 
18491 
  def __eq__(self, other):
18492 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
18493 
 
18494 
  def __ne__(self, other):
18495 
    return not (self == other)
18496 
 
18497 
class markOrderCancellationRequestReceived_result:
18498 
  """
18499 
  Attributes:
18500 
   - ex
18501 
  """
18502 
 
18503 
  thrift_spec = (
18504 
    None, # 0
18505 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
18506 
  )
18507 
 
18508 
  def __init__(self, ex=None,):
18509 
    self.ex = ex
18510 
 
18511 
  def read(self, iprot):
18512 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
18513 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
18514 
      return
18515 
    iprot.readStructBegin()
18516 
    while True:
18517 
      (fname, ftype, fid) = iprot.readFieldBegin()
18518 
      if ftype == TType.STOP:
18519 
        break
18520 
      if fid == 1:
18521 
        if ftype == TType.STRUCT:
18522 
          self.ex = TransactionServiceException()
18523 
          self.ex.read(iprot)
18524 
        else:
18525 
          iprot.skip(ftype)
18526 
      else:
18527 
        iprot.skip(ftype)
18528 
      iprot.readFieldEnd()
18529 
    iprot.readStructEnd()
18530 
 
18531 
  def write(self, oprot):
18532 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
18533 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
18534 
      return
18535 
    oprot.writeStructBegin('markOrderCancellationRequestReceived_result')
18536 
    if self.ex is not None:
18537 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
18538 
      self.ex.write(oprot)
18539 
      oprot.writeFieldEnd()
18540 
    oprot.writeFieldStop()
18541 
    oprot.writeStructEnd()
18542 
 
18543 
  def validate(self):
18544 
    return
18545 
 
18546 
 
18547 
  def __repr__(self):
18548 
    L = ['%s=%r' % (key, value)
18549 
      for key, value in self.__dict__.iteritems()]
18550 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
18551 
 
18552 
  def __eq__(self, other):
18553 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
18554 
 
18555 
  def __ne__(self, other):
18556 
    return not (self == other)
18557 
 
18558 
class markOrderCancellationRequestConfirmed_args:
18559 
  """
18560 
  Attributes:
18561 
   - orderId
18562 
  """
18563 
 
18564 
  thrift_spec = (
18565 
    None, # 0
18566 
    (1, TType.I64, 'orderId', None, None, ), # 1
18567 
  )
18568 
 
18569 
  def __init__(self, orderId=None,):
18570 
    self.orderId = orderId
18571 
 
18572 
  def read(self, iprot):
18573 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
18574 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
18575 
      return
18576 
    iprot.readStructBegin()
18577 
    while True:
18578 
      (fname, ftype, fid) = iprot.readFieldBegin()
18579 
      if ftype == TType.STOP:
18580 
        break
18581 
      if fid == 1:
18582 
        if ftype == TType.I64:
18583 
          self.orderId = iprot.readI64();
18584 
        else:
18585 
          iprot.skip(ftype)
18586 
      else:
18587 
        iprot.skip(ftype)
18588 
      iprot.readFieldEnd()
18589 
    iprot.readStructEnd()
18590 
 
18591 
  def write(self, oprot):
18592 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
18593 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
18594 
      return
18595 
    oprot.writeStructBegin('markOrderCancellationRequestConfirmed_args')
18596 
    if self.orderId is not None:
18597 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
18598 
      oprot.writeI64(self.orderId)
18599 
      oprot.writeFieldEnd()
18600 
    oprot.writeFieldStop()
18601 
    oprot.writeStructEnd()
18602 
 
18603 
  def validate(self):
18604 
    return
18605 
 
18606 
 
18607 
  def __repr__(self):
18608 
    L = ['%s=%r' % (key, value)
18609 
      for key, value in self.__dict__.iteritems()]
18610 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
18611 
 
18612 
  def __eq__(self, other):
18613 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
18614 
 
18615 
  def __ne__(self, other):
18616 
    return not (self == other)
18617 
 
18618 
class markOrderCancellationRequestConfirmed_result:
18619 
  """
18620 
  Attributes:
18621 
   - ex
18622 
  """
18623 
 
18624 
  thrift_spec = (
18625 
    None, # 0
18626 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
18627 
  )
18628 
 
18629 
  def __init__(self, ex=None,):
18630 
    self.ex = ex
18631 
 
18632 
  def read(self, iprot):
18633 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
18634 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
18635 
      return
18636 
    iprot.readStructBegin()
18637 
    while True:
18638 
      (fname, ftype, fid) = iprot.readFieldBegin()
18639 
      if ftype == TType.STOP:
18640 
        break
18641 
      if fid == 1:
18642 
        if ftype == TType.STRUCT:
18643 
          self.ex = TransactionServiceException()
18644 
          self.ex.read(iprot)
18645 
        else:
18646 
          iprot.skip(ftype)
18647 
      else:
18648 
        iprot.skip(ftype)
18649 
      iprot.readFieldEnd()
18650 
    iprot.readStructEnd()
18651 
 
18652 
  def write(self, oprot):
18653 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
18654 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
18655 
      return
18656 
    oprot.writeStructBegin('markOrderCancellationRequestConfirmed_result')
18657 
    if self.ex is not None:
18658 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
18659 
      self.ex.write(oprot)
18660 
      oprot.writeFieldEnd()
18661 
    oprot.writeFieldStop()
18662 
    oprot.writeStructEnd()
18663 
 
18664 
  def validate(self):
18665 
    return
18666 
 
18667 
 
18668 
  def __repr__(self):
18669 
    L = ['%s=%r' % (key, value)
18670 
      for key, value in self.__dict__.iteritems()]
18671 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
18672 
 
18673 
  def __eq__(self, other):
18674 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
18675 
 
18676 
  def __ne__(self, other):
18677 
    return not (self == other)
18678 
 
18679 
class markOrderCancellationRequestDenied_args:
18680 
  """
18681 
  Attributes:
18682 
   - orderId
18683 
  """
18684 
 
18685 
  thrift_spec = (
18686 
    None, # 0
18687 
    (1, TType.I64, 'orderId', None, None, ), # 1
18688 
  )
18689 
 
18690 
  def __init__(self, orderId=None,):
18691 
    self.orderId = orderId
18692 
 
18693 
  def read(self, iprot):
18694 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
18695 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
18696 
      return
18697 
    iprot.readStructBegin()
18698 
    while True:
18699 
      (fname, ftype, fid) = iprot.readFieldBegin()
18700 
      if ftype == TType.STOP:
18701 
        break
18702 
      if fid == 1:
18703 
        if ftype == TType.I64:
18704 
          self.orderId = iprot.readI64();
18705 
        else:
18706 
          iprot.skip(ftype)
18707 
      else:
18708 
        iprot.skip(ftype)
18709 
      iprot.readFieldEnd()
18710 
    iprot.readStructEnd()
18711 
 
18712 
  def write(self, oprot):
18713 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
18714 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
18715 
      return
18716 
    oprot.writeStructBegin('markOrderCancellationRequestDenied_args')
18717 
    if self.orderId is not None:
18718 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
18719 
      oprot.writeI64(self.orderId)
18720 
      oprot.writeFieldEnd()
18721 
    oprot.writeFieldStop()
18722 
    oprot.writeStructEnd()
18723 
 
18724 
  def validate(self):
18725 
    return
18726 
 
18727 
 
18728 
  def __repr__(self):
18729 
    L = ['%s=%r' % (key, value)
18730 
      for key, value in self.__dict__.iteritems()]
18731 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
18732 
 
18733 
  def __eq__(self, other):
18734 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
18735 
 
18736 
  def __ne__(self, other):
18737 
    return not (self == other)
18738 
 
18739 
class markOrderCancellationRequestDenied_result:
18740 
  """
18741 
  Attributes:
18742 
   - ex
18743 
  """
18744 
 
18745 
  thrift_spec = (
18746 
    None, # 0
18747 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
18748 
  )
18749 
 
18750 
  def __init__(self, ex=None,):
18751 
    self.ex = ex
18752 
 
18753 
  def read(self, iprot):
18754 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
18755 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
18756 
      return
18757 
    iprot.readStructBegin()
18758 
    while True:
18759 
      (fname, ftype, fid) = iprot.readFieldBegin()
18760 
      if ftype == TType.STOP:
18761 
        break
18762 
      if fid == 1:
18763 
        if ftype == TType.STRUCT:
18764 
          self.ex = TransactionServiceException()
18765 
          self.ex.read(iprot)
18766 
        else:
18767 
          iprot.skip(ftype)
18768 
      else:
18769 
        iprot.skip(ftype)
18770 
      iprot.readFieldEnd()
18771 
    iprot.readStructEnd()
18772 
 
18773 
  def write(self, oprot):
18774 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
18775 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
18776 
      return
18777 
    oprot.writeStructBegin('markOrderCancellationRequestDenied_result')
18778 
    if self.ex is not None:
18779 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
18780 
      self.ex.write(oprot)
18781 
      oprot.writeFieldEnd()
18782 
    oprot.writeFieldStop()
18783 
    oprot.writeStructEnd()
18784 
 
18785 
  def validate(self):
18786 
    return
18787 
 
18788 
 
18789 
  def __repr__(self):
18790 
    L = ['%s=%r' % (key, value)
18791 
      for key, value in self.__dict__.iteritems()]
18792 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
18793 
 
18794 
  def __eq__(self, other):
18795 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
18796 
 
18797 
  def __ne__(self, other):
18798 
    return not (self == other)
18799 
 
4258 rajveer 18800 
class markTransactionAsPaymentFlagRemoved_args:
4247 rajveer 18801 
  """
18802 
  Attributes:
4258 rajveer 18803 
   - transactionId
4247 rajveer 18804 
  """
18805 
 
18806 
  thrift_spec = (
18807 
    None, # 0
4258 rajveer 18808 
    (1, TType.I64, 'transactionId', None, None, ), # 1
4247 rajveer 18809 
  )
18810 
 
4258 rajveer 18811 
  def __init__(self, transactionId=None,):
18812 
    self.transactionId = transactionId
4247 rajveer 18813 
 
18814 
  def read(self, iprot):
18815 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
18816 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
18817 
      return
18818 
    iprot.readStructBegin()
18819 
    while True:
18820 
      (fname, ftype, fid) = iprot.readFieldBegin()
18821 
      if ftype == TType.STOP:
18822 
        break
18823 
      if fid == 1:
18824 
        if ftype == TType.I64:
4258 rajveer 18825 
          self.transactionId = iprot.readI64();
4247 rajveer 18826 
        else:
18827 
          iprot.skip(ftype)
18828 
      else:
18829 
        iprot.skip(ftype)
18830 
      iprot.readFieldEnd()
18831 
    iprot.readStructEnd()
18832 
 
18833 
  def write(self, oprot):
18834 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
18835 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
18836 
      return
4258 rajveer 18837 
    oprot.writeStructBegin('markTransactionAsPaymentFlagRemoved_args')
18838 
    if self.transactionId is not None:
18839 
      oprot.writeFieldBegin('transactionId', TType.I64, 1)
18840 
      oprot.writeI64(self.transactionId)
4247 rajveer 18841 
      oprot.writeFieldEnd()
18842 
    oprot.writeFieldStop()
18843 
    oprot.writeStructEnd()
18844 
 
18845 
  def validate(self):
18846 
    return
18847 
 
18848 
 
18849 
  def __repr__(self):
18850 
    L = ['%s=%r' % (key, value)
18851 
      for key, value in self.__dict__.iteritems()]
18852 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
18853 
 
18854 
  def __eq__(self, other):
18855 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
18856 
 
18857 
  def __ne__(self, other):
18858 
    return not (self == other)
18859 
 
4258 rajveer 18860 
class markTransactionAsPaymentFlagRemoved_result:
4247 rajveer 18861 
  """
18862 
  Attributes:
18863 
   - ex
18864 
  """
18865 
 
18866 
  thrift_spec = (
18867 
    None, # 0
18868 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
18869 
  )
18870 
 
18871 
  def __init__(self, ex=None,):
18872 
    self.ex = ex
18873 
 
18874 
  def read(self, iprot):
18875 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
18876 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
18877 
      return
18878 
    iprot.readStructBegin()
18879 
    while True:
18880 
      (fname, ftype, fid) = iprot.readFieldBegin()
18881 
      if ftype == TType.STOP:
18882 
        break
18883 
      if fid == 1:
18884 
        if ftype == TType.STRUCT:
18885 
          self.ex = TransactionServiceException()
18886 
          self.ex.read(iprot)
18887 
        else:
18888 
          iprot.skip(ftype)
18889 
      else:
18890 
        iprot.skip(ftype)
18891 
      iprot.readFieldEnd()
18892 
    iprot.readStructEnd()
18893 
 
18894 
  def write(self, oprot):
18895 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
18896 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
18897 
      return
4258 rajveer 18898 
    oprot.writeStructBegin('markTransactionAsPaymentFlagRemoved_result')
4247 rajveer 18899 
    if self.ex is not None:
18900 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
18901 
      self.ex.write(oprot)
18902 
      oprot.writeFieldEnd()
18903 
    oprot.writeFieldStop()
18904 
    oprot.writeStructEnd()
18905 
 
18906 
  def validate(self):
18907 
    return
18908 
 
18909 
 
18910 
  def __repr__(self):
18911 
    L = ['%s=%r' % (key, value)
18912 
      for key, value in self.__dict__.iteritems()]
18913 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
18914 
 
18915 
  def __eq__(self, other):
18916 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
18917 
 
18918 
  def __ne__(self, other):
18919 
    return not (self == other)
4259 anupam.sin 18920 
 
18921 
class refundTransaction_args:
18922 
  """
18923 
  Attributes:
18924 
   - transactionId
18925 
   - refundedBy
18926 
   - reason
18927 
  """
18928 
 
18929 
  thrift_spec = (
18930 
    None, # 0
18931 
    (1, TType.I64, 'transactionId', None, None, ), # 1
18932 
    (2, TType.STRING, 'refundedBy', None, None, ), # 2
18933 
    (3, TType.STRING, 'reason', None, None, ), # 3
18934 
  )
18935 
 
18936 
  def __init__(self, transactionId=None, refundedBy=None, reason=None,):
18937 
    self.transactionId = transactionId
18938 
    self.refundedBy = refundedBy
18939 
    self.reason = reason
18940 
 
18941 
  def read(self, iprot):
18942 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
18943 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
18944 
      return
18945 
    iprot.readStructBegin()
18946 
    while True:
18947 
      (fname, ftype, fid) = iprot.readFieldBegin()
18948 
      if ftype == TType.STOP:
18949 
        break
18950 
      if fid == 1:
18951 
        if ftype == TType.I64:
18952 
          self.transactionId = iprot.readI64();
18953 
        else:
18954 
          iprot.skip(ftype)
18955 
      elif fid == 2:
18956 
        if ftype == TType.STRING:
18957 
          self.refundedBy = iprot.readString();
18958 
        else:
18959 
          iprot.skip(ftype)
18960 
      elif fid == 3:
18961 
        if ftype == TType.STRING:
18962 
          self.reason = iprot.readString();
18963 
        else:
18964 
          iprot.skip(ftype)
18965 
      else:
18966 
        iprot.skip(ftype)
18967 
      iprot.readFieldEnd()
18968 
    iprot.readStructEnd()
18969 
 
18970 
  def write(self, oprot):
18971 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
18972 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
18973 
      return
18974 
    oprot.writeStructBegin('refundTransaction_args')
18975 
    if self.transactionId is not None:
18976 
      oprot.writeFieldBegin('transactionId', TType.I64, 1)
18977 
      oprot.writeI64(self.transactionId)
18978 
      oprot.writeFieldEnd()
18979 
    if self.refundedBy is not None:
18980 
      oprot.writeFieldBegin('refundedBy', TType.STRING, 2)
18981 
      oprot.writeString(self.refundedBy)
18982 
      oprot.writeFieldEnd()
18983 
    if self.reason is not None:
18984 
      oprot.writeFieldBegin('reason', TType.STRING, 3)
18985 
      oprot.writeString(self.reason)
18986 
      oprot.writeFieldEnd()
18987 
    oprot.writeFieldStop()
18988 
    oprot.writeStructEnd()
18989 
 
18990 
  def validate(self):
18991 
    return
18992 
 
18993 
 
18994 
  def __repr__(self):
18995 
    L = ['%s=%r' % (key, value)
18996 
      for key, value in self.__dict__.iteritems()]
18997 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
18998 
 
18999 
  def __eq__(self, other):
19000 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
19001 
 
19002 
  def __ne__(self, other):
19003 
    return not (self == other)
19004 
 
19005 
class refundTransaction_result:
19006 
  """
19007 
  Attributes:
19008 
   - ex
19009 
  """
19010 
 
19011 
  thrift_spec = (
19012 
    None, # 0
19013 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
19014 
  )
19015 
 
19016 
  def __init__(self, ex=None,):
19017 
    self.ex = ex
19018 
 
19019 
  def read(self, iprot):
19020 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
19021 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
19022 
      return
19023 
    iprot.readStructBegin()
19024 
    while True:
19025 
      (fname, ftype, fid) = iprot.readFieldBegin()
19026 
      if ftype == TType.STOP:
19027 
        break
19028 
      if fid == 1:
19029 
        if ftype == TType.STRUCT:
19030 
          self.ex = TransactionServiceException()
19031 
          self.ex.read(iprot)
19032 
        else:
19033 
          iprot.skip(ftype)
19034 
      else:
19035 
        iprot.skip(ftype)
19036 
      iprot.readFieldEnd()
19037 
    iprot.readStructEnd()
19038 
 
19039 
  def write(self, oprot):
19040 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
19041 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
19042 
      return
19043 
    oprot.writeStructBegin('refundTransaction_result')
19044 
    if self.ex is not None:
19045 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
19046 
      self.ex.write(oprot)
19047 
      oprot.writeFieldEnd()
19048 
    oprot.writeFieldStop()
19049 
    oprot.writeStructEnd()
19050 
 
19051 
  def validate(self):
19052 
    return
19053 
 
19054 
 
19055 
  def __repr__(self):
19056 
    L = ['%s=%r' % (key, value)
19057 
      for key, value in self.__dict__.iteritems()]
19058 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
19059 
 
19060 
  def __eq__(self, other):
19061 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
19062 
 
19063 
  def __ne__(self, other):
19064 
    return not (self == other)
4285 rajveer 19065 
 
4324 mandeep.dh 19066 
class updateShipmentAddress_args:
19067 
  """
19068 
  Attributes:
19069 
   - orderId
19070 
   - addressId
19071 
  """
19072 
 
19073 
  thrift_spec = (
19074 
    None, # 0
19075 
    (1, TType.I64, 'orderId', None, None, ), # 1
19076 
    (2, TType.I64, 'addressId', None, None, ), # 2
19077 
  )
19078 
 
19079 
  def __init__(self, orderId=None, addressId=None,):
19080 
    self.orderId = orderId
19081 
    self.addressId = addressId
19082 
 
19083 
  def read(self, iprot):
19084 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
19085 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
19086 
      return
19087 
    iprot.readStructBegin()
19088 
    while True:
19089 
      (fname, ftype, fid) = iprot.readFieldBegin()
19090 
      if ftype == TType.STOP:
19091 
        break
19092 
      if fid == 1:
19093 
        if ftype == TType.I64:
19094 
          self.orderId = iprot.readI64();
19095 
        else:
19096 
          iprot.skip(ftype)
19097 
      elif fid == 2:
19098 
        if ftype == TType.I64:
19099 
          self.addressId = iprot.readI64();
19100 
        else:
19101 
          iprot.skip(ftype)
19102 
      else:
19103 
        iprot.skip(ftype)
19104 
      iprot.readFieldEnd()
19105 
    iprot.readStructEnd()
19106 
 
19107 
  def write(self, oprot):
19108 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
19109 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
19110 
      return
19111 
    oprot.writeStructBegin('updateShipmentAddress_args')
19112 
    if self.orderId is not None:
19113 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
19114 
      oprot.writeI64(self.orderId)
19115 
      oprot.writeFieldEnd()
19116 
    if self.addressId is not None:
19117 
      oprot.writeFieldBegin('addressId', TType.I64, 2)
19118 
      oprot.writeI64(self.addressId)
19119 
      oprot.writeFieldEnd()
19120 
    oprot.writeFieldStop()
19121 
    oprot.writeStructEnd()
19122 
 
19123 
  def validate(self):
19124 
    return
19125 
 
19126 
 
19127 
  def __repr__(self):
19128 
    L = ['%s=%r' % (key, value)
19129 
      for key, value in self.__dict__.iteritems()]
19130 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
19131 
 
19132 
  def __eq__(self, other):
19133 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
19134 
 
19135 
  def __ne__(self, other):
19136 
    return not (self == other)
19137 
 
19138 
class updateShipmentAddress_result:
19139 
  """
19140 
  Attributes:
19141 
   - ex
19142 
  """
19143 
 
19144 
  thrift_spec = (
19145 
    None, # 0
19146 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
19147 
  )
19148 
 
19149 
  def __init__(self, ex=None,):
19150 
    self.ex = ex
19151 
 
19152 
  def read(self, iprot):
19153 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
19154 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
19155 
      return
19156 
    iprot.readStructBegin()
19157 
    while True:
19158 
      (fname, ftype, fid) = iprot.readFieldBegin()
19159 
      if ftype == TType.STOP:
19160 
        break
19161 
      if fid == 1:
19162 
        if ftype == TType.STRUCT:
19163 
          self.ex = TransactionServiceException()
19164 
          self.ex.read(iprot)
19165 
        else:
19166 
          iprot.skip(ftype)
19167 
      else:
19168 
        iprot.skip(ftype)
19169 
      iprot.readFieldEnd()
19170 
    iprot.readStructEnd()
19171 
 
19172 
  def write(self, oprot):
19173 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
19174 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
19175 
      return
19176 
    oprot.writeStructBegin('updateShipmentAddress_result')
19177 
    if self.ex is not None:
19178 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
19179 
      self.ex.write(oprot)
19180 
      oprot.writeFieldEnd()
19181 
    oprot.writeFieldStop()
19182 
    oprot.writeStructEnd()
19183 
 
19184 
  def validate(self):
19185 
    return
19186 
 
19187 
 
19188 
  def __repr__(self):
19189 
    L = ['%s=%r' % (key, value)
19190 
      for key, value in self.__dict__.iteritems()]
19191 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
19192 
 
19193 
  def __eq__(self, other):
19194 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
19195 
 
19196 
  def __ne__(self, other):
19197 
    return not (self == other)
19198 
 
4285 rajveer 19199 
class acceptOrdersForItemId_args:
19200 
  """
19201 
  Attributes:
19202 
   - itemId
19203 
   - inventory
19204 
  """
19205 
 
19206 
  thrift_spec = (
19207 
    None, # 0
19208 
    (1, TType.I64, 'itemId', None, None, ), # 1
19209 
    (2, TType.I64, 'inventory', None, None, ), # 2
19210 
  )
19211 
 
19212 
  def __init__(self, itemId=None, inventory=None,):
19213 
    self.itemId = itemId
19214 
    self.inventory = inventory
19215 
 
19216 
  def read(self, iprot):
19217 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
19218 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
19219 
      return
19220 
    iprot.readStructBegin()
19221 
    while True:
19222 
      (fname, ftype, fid) = iprot.readFieldBegin()
19223 
      if ftype == TType.STOP:
19224 
        break
19225 
      if fid == 1:
19226 
        if ftype == TType.I64:
19227 
          self.itemId = iprot.readI64();
19228 
        else:
19229 
          iprot.skip(ftype)
19230 
      elif fid == 2:
19231 
        if ftype == TType.I64:
19232 
          self.inventory = iprot.readI64();
19233 
        else:
19234 
          iprot.skip(ftype)
19235 
      else:
19236 
        iprot.skip(ftype)
19237 
      iprot.readFieldEnd()
19238 
    iprot.readStructEnd()
19239 
 
19240 
  def write(self, oprot):
19241 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
19242 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
19243 
      return
19244 
    oprot.writeStructBegin('acceptOrdersForItemId_args')
19245 
    if self.itemId is not None:
19246 
      oprot.writeFieldBegin('itemId', TType.I64, 1)
19247 
      oprot.writeI64(self.itemId)
19248 
      oprot.writeFieldEnd()
19249 
    if self.inventory is not None:
19250 
      oprot.writeFieldBegin('inventory', TType.I64, 2)
19251 
      oprot.writeI64(self.inventory)
19252 
      oprot.writeFieldEnd()
19253 
    oprot.writeFieldStop()
19254 
    oprot.writeStructEnd()
19255 
 
19256 
  def validate(self):
19257 
    return
19258 
 
19259 
 
19260 
  def __repr__(self):
19261 
    L = ['%s=%r' % (key, value)
19262 
      for key, value in self.__dict__.iteritems()]
19263 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
19264 
 
19265 
  def __eq__(self, other):
19266 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
19267 
 
19268 
  def __ne__(self, other):
19269 
    return not (self == other)
19270 
 
19271 
class acceptOrdersForItemId_result:
19272 
  """
19273 
  Attributes:
19274 
   - success
19275 
   - ex
19276 
  """
19277 
 
19278 
  thrift_spec = (
19279 
    (0, TType.BOOL, 'success', None, None, ), # 0
19280 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
19281 
  )
19282 
 
19283 
  def __init__(self, success=None, ex=None,):
19284 
    self.success = success
19285 
    self.ex = ex
19286 
 
19287 
  def read(self, iprot):
19288 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
19289 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
19290 
      return
19291 
    iprot.readStructBegin()
19292 
    while True:
19293 
      (fname, ftype, fid) = iprot.readFieldBegin()
19294 
      if ftype == TType.STOP:
19295 
        break
19296 
      if fid == 0:
19297 
        if ftype == TType.BOOL:
19298 
          self.success = iprot.readBool();
19299 
        else:
19300 
          iprot.skip(ftype)
19301 
      elif fid == 1:
19302 
        if ftype == TType.STRUCT:
19303 
          self.ex = TransactionServiceException()
19304 
          self.ex.read(iprot)
19305 
        else:
19306 
          iprot.skip(ftype)
19307 
      else:
19308 
        iprot.skip(ftype)
19309 
      iprot.readFieldEnd()
19310 
    iprot.readStructEnd()
19311 
 
19312 
  def write(self, oprot):
19313 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
19314 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
19315 
      return
19316 
    oprot.writeStructBegin('acceptOrdersForItemId_result')
19317 
    if self.success is not None:
19318 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
19319 
      oprot.writeBool(self.success)
19320 
      oprot.writeFieldEnd()
19321 
    if self.ex is not None:
19322 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
19323 
      self.ex.write(oprot)
19324 
      oprot.writeFieldEnd()
19325 
    oprot.writeFieldStop()
19326 
    oprot.writeStructEnd()
19327 
 
19328 
  def validate(self):
19329 
    return
19330 
 
19331 
 
19332 
  def __repr__(self):
19333 
    L = ['%s=%r' % (key, value)
19334 
      for key, value in self.__dict__.iteritems()]
19335 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
19336 
 
19337 
  def __eq__(self, other):
19338 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
19339 
 
19340 
  def __ne__(self, other):
19341 
    return not (self == other)
4303 rajveer 19342 
 
19343 
class markOrdersAsPORaised_args:
19344 
  """
19345 
  Attributes:
19346 
   - vendorId
19347 
   - itemId
19348 
   - quantity
19349 
   - estimate
4369 rajveer 19350 
   - isReminder
4303 rajveer 19351 
  """
19352 
 
19353 
  thrift_spec = (
19354 
    None, # 0
19355 
    (1, TType.I64, 'vendorId', None, None, ), # 1
19356 
    (2, TType.I64, 'itemId', None, None, ), # 2
19357 
    (3, TType.I64, 'quantity', None, None, ), # 3
19358 
    (4, TType.I64, 'estimate', None, None, ), # 4
4369 rajveer 19359 
    (5, TType.BOOL, 'isReminder', None, None, ), # 5
4303 rajveer 19360 
  )
19361 
 
4369 rajveer 19362 
  def __init__(self, vendorId=None, itemId=None, quantity=None, estimate=None, isReminder=None,):
4303 rajveer 19363 
    self.vendorId = vendorId
19364 
    self.itemId = itemId
19365 
    self.quantity = quantity
19366 
    self.estimate = estimate
4369 rajveer 19367 
    self.isReminder = isReminder
4303 rajveer 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 == 1:
19379 
        if ftype == TType.I64:
19380 
          self.vendorId = iprot.readI64();
19381 
        else:
19382 
          iprot.skip(ftype)
19383 
      elif fid == 2:
19384 
        if ftype == TType.I64:
19385 
          self.itemId = iprot.readI64();
19386 
        else:
19387 
          iprot.skip(ftype)
19388 
      elif fid == 3:
19389 
        if ftype == TType.I64:
19390 
          self.quantity = iprot.readI64();
19391 
        else:
19392 
          iprot.skip(ftype)
19393 
      elif fid == 4:
19394 
        if ftype == TType.I64:
19395 
          self.estimate = iprot.readI64();
19396 
        else:
19397 
          iprot.skip(ftype)
4369 rajveer 19398 
      elif fid == 5:
19399 
        if ftype == TType.BOOL:
19400 
          self.isReminder = iprot.readBool();
19401 
        else:
19402 
          iprot.skip(ftype)
4303 rajveer 19403 
      else:
19404 
        iprot.skip(ftype)
19405 
      iprot.readFieldEnd()
19406 
    iprot.readStructEnd()
19407 
 
19408 
  def write(self, oprot):
19409 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
19410 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
19411 
      return
19412 
    oprot.writeStructBegin('markOrdersAsPORaised_args')
19413 
    if self.vendorId is not None:
19414 
      oprot.writeFieldBegin('vendorId', TType.I64, 1)
19415 
      oprot.writeI64(self.vendorId)
19416 
      oprot.writeFieldEnd()
19417 
    if self.itemId is not None:
19418 
      oprot.writeFieldBegin('itemId', TType.I64, 2)
19419 
      oprot.writeI64(self.itemId)
19420 
      oprot.writeFieldEnd()
19421 
    if self.quantity is not None:
19422 
      oprot.writeFieldBegin('quantity', TType.I64, 3)
19423 
      oprot.writeI64(self.quantity)
19424 
      oprot.writeFieldEnd()
19425 
    if self.estimate is not None:
19426 
      oprot.writeFieldBegin('estimate', TType.I64, 4)
19427 
      oprot.writeI64(self.estimate)
19428 
      oprot.writeFieldEnd()
4369 rajveer 19429 
    if self.isReminder is not None:
19430 
      oprot.writeFieldBegin('isReminder', TType.BOOL, 5)
19431 
      oprot.writeBool(self.isReminder)
19432 
      oprot.writeFieldEnd()
4303 rajveer 19433 
    oprot.writeFieldStop()
19434 
    oprot.writeStructEnd()
19435 
 
19436 
  def validate(self):
19437 
    return
19438 
 
19439 
 
19440 
  def __repr__(self):
19441 
    L = ['%s=%r' % (key, value)
19442 
      for key, value in self.__dict__.iteritems()]
19443 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
19444 
 
19445 
  def __eq__(self, other):
19446 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
19447 
 
19448 
  def __ne__(self, other):
19449 
    return not (self == other)
19450 
 
19451 
class markOrdersAsPORaised_result:
19452 
  """
19453 
  Attributes:
19454 
   - ex
19455 
  """
19456 
 
19457 
  thrift_spec = (
19458 
    None, # 0
19459 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
19460 
  )
19461 
 
19462 
  def __init__(self, ex=None,):
19463 
    self.ex = ex
19464 
 
19465 
  def read(self, iprot):
19466 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
19467 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
19468 
      return
19469 
    iprot.readStructBegin()
19470 
    while True:
19471 
      (fname, ftype, fid) = iprot.readFieldBegin()
19472 
      if ftype == TType.STOP:
19473 
        break
19474 
      if fid == 1:
19475 
        if ftype == TType.STRUCT:
19476 
          self.ex = TransactionServiceException()
19477 
          self.ex.read(iprot)
19478 
        else:
19479 
          iprot.skip(ftype)
19480 
      else:
19481 
        iprot.skip(ftype)
19482 
      iprot.readFieldEnd()
19483 
    iprot.readStructEnd()
19484 
 
19485 
  def write(self, oprot):
19486 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
19487 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
19488 
      return
19489 
    oprot.writeStructBegin('markOrdersAsPORaised_result')
19490 
    if self.ex is not None:
19491 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
19492 
      self.ex.write(oprot)
19493 
      oprot.writeFieldEnd()
19494 
    oprot.writeFieldStop()
19495 
    oprot.writeStructEnd()
19496 
 
19497 
  def validate(self):
19498 
    return
19499 
 
19500 
 
19501 
  def __repr__(self):
19502 
    L = ['%s=%r' % (key, value)
19503 
      for key, value in self.__dict__.iteritems()]
19504 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
19505 
 
19506 
  def __eq__(self, other):
19507 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
19508 
 
19509 
  def __ne__(self, other):
19510 
    return not (self == other)
19511 
 
19512 
class markOrdersAsReversalInitiated_args:
19513 
  """
19514 
  Attributes:
19515 
   - vendorId
19516 
   - itemId
19517 
   - quantity
19518 
   - estimate
4369 rajveer 19519 
   - isReminder
4303 rajveer 19520 
  """
19521 
 
19522 
  thrift_spec = (
19523 
    None, # 0
19524 
    (1, TType.I64, 'vendorId', None, None, ), # 1
19525 
    (2, TType.I64, 'itemId', None, None, ), # 2
19526 
    (3, TType.I64, 'quantity', None, None, ), # 3
19527 
    (4, TType.I64, 'estimate', None, None, ), # 4
4369 rajveer 19528 
    (5, TType.BOOL, 'isReminder', None, None, ), # 5
4303 rajveer 19529 
  )
19530 
 
4369 rajveer 19531 
  def __init__(self, vendorId=None, itemId=None, quantity=None, estimate=None, isReminder=None,):
4303 rajveer 19532 
    self.vendorId = vendorId
19533 
    self.itemId = itemId
19534 
    self.quantity = quantity
19535 
    self.estimate = estimate
4369 rajveer 19536 
    self.isReminder = isReminder
4303 rajveer 19537 
 
19538 
  def read(self, iprot):
19539 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
19540 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
19541 
      return
19542 
    iprot.readStructBegin()
19543 
    while True:
19544 
      (fname, ftype, fid) = iprot.readFieldBegin()
19545 
      if ftype == TType.STOP:
19546 
        break
19547 
      if fid == 1:
19548 
        if ftype == TType.I64:
19549 
          self.vendorId = iprot.readI64();
19550 
        else:
19551 
          iprot.skip(ftype)
19552 
      elif fid == 2:
19553 
        if ftype == TType.I64:
19554 
          self.itemId = iprot.readI64();
19555 
        else:
19556 
          iprot.skip(ftype)
19557 
      elif fid == 3:
19558 
        if ftype == TType.I64:
19559 
          self.quantity = iprot.readI64();
19560 
        else:
19561 
          iprot.skip(ftype)
19562 
      elif fid == 4:
19563 
        if ftype == TType.I64:
19564 
          self.estimate = iprot.readI64();
19565 
        else:
19566 
          iprot.skip(ftype)
4369 rajveer 19567 
      elif fid == 5:
19568 
        if ftype == TType.BOOL:
19569 
          self.isReminder = iprot.readBool();
19570 
        else:
19571 
          iprot.skip(ftype)
4303 rajveer 19572 
      else:
19573 
        iprot.skip(ftype)
19574 
      iprot.readFieldEnd()
19575 
    iprot.readStructEnd()
19576 
 
19577 
  def write(self, oprot):
19578 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
19579 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
19580 
      return
19581 
    oprot.writeStructBegin('markOrdersAsReversalInitiated_args')
19582 
    if self.vendorId is not None:
19583 
      oprot.writeFieldBegin('vendorId', TType.I64, 1)
19584 
      oprot.writeI64(self.vendorId)
19585 
      oprot.writeFieldEnd()
19586 
    if self.itemId is not None:
19587 
      oprot.writeFieldBegin('itemId', TType.I64, 2)
19588 
      oprot.writeI64(self.itemId)
19589 
      oprot.writeFieldEnd()
19590 
    if self.quantity is not None:
19591 
      oprot.writeFieldBegin('quantity', TType.I64, 3)
19592 
      oprot.writeI64(self.quantity)
19593 
      oprot.writeFieldEnd()
19594 
    if self.estimate is not None:
19595 
      oprot.writeFieldBegin('estimate', TType.I64, 4)
19596 
      oprot.writeI64(self.estimate)
19597 
      oprot.writeFieldEnd()
4369 rajveer 19598 
    if self.isReminder is not None:
19599 
      oprot.writeFieldBegin('isReminder', TType.BOOL, 5)
19600 
      oprot.writeBool(self.isReminder)
19601 
      oprot.writeFieldEnd()
4303 rajveer 19602 
    oprot.writeFieldStop()
19603 
    oprot.writeStructEnd()
19604 
 
19605 
  def validate(self):
19606 
    return
19607 
 
19608 
 
19609 
  def __repr__(self):
19610 
    L = ['%s=%r' % (key, value)
19611 
      for key, value in self.__dict__.iteritems()]
19612 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
19613 
 
19614 
  def __eq__(self, other):
19615 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
19616 
 
19617 
  def __ne__(self, other):
19618 
    return not (self == other)
19619 
 
19620 
class markOrdersAsReversalInitiated_result:
19621 
  """
19622 
  Attributes:
19623 
   - ex
19624 
  """
19625 
 
19626 
  thrift_spec = (
19627 
    None, # 0
19628 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
19629 
  )
19630 
 
19631 
  def __init__(self, ex=None,):
19632 
    self.ex = ex
19633 
 
19634 
  def read(self, iprot):
19635 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
19636 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
19637 
      return
19638 
    iprot.readStructBegin()
19639 
    while True:
19640 
      (fname, ftype, fid) = iprot.readFieldBegin()
19641 
      if ftype == TType.STOP:
19642 
        break
19643 
      if fid == 1:
19644 
        if ftype == TType.STRUCT:
19645 
          self.ex = TransactionServiceException()
19646 
          self.ex.read(iprot)
19647 
        else:
19648 
          iprot.skip(ftype)
19649 
      else:
19650 
        iprot.skip(ftype)
19651 
      iprot.readFieldEnd()
19652 
    iprot.readStructEnd()
19653 
 
19654 
  def write(self, oprot):
19655 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
19656 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
19657 
      return
19658 
    oprot.writeStructBegin('markOrdersAsReversalInitiated_result')
19659 
    if self.ex is not None:
19660 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
19661 
      self.ex.write(oprot)
19662 
      oprot.writeFieldEnd()
19663 
    oprot.writeFieldStop()
19664 
    oprot.writeStructEnd()
19665 
 
19666 
  def validate(self):
19667 
    return
19668 
 
19669 
 
19670 
  def __repr__(self):
19671 
    L = ['%s=%r' % (key, value)
19672 
      for key, value in self.__dict__.iteritems()]
19673 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
19674 
 
19675 
  def __eq__(self, other):
19676 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
19677 
 
19678 
  def __ne__(self, other):
19679 
    return not (self == other)
19680 
 
19681 
class markOrdersAsNotAvailabke_args:
19682 
  """
19683 
  Attributes:
19684 
   - vendorId
19685 
   - itemId
19686 
   - quantity
19687 
   - estimate
4369 rajveer 19688 
   - isReminder
4303 rajveer 19689 
  """
19690 
 
19691 
  thrift_spec = (
19692 
    None, # 0
19693 
    (1, TType.I64, 'vendorId', None, None, ), # 1
19694 
    (2, TType.I64, 'itemId', None, None, ), # 2
19695 
    (3, TType.I64, 'quantity', None, None, ), # 3
19696 
    (4, TType.I64, 'estimate', None, None, ), # 4
4369 rajveer 19697 
    (5, TType.BOOL, 'isReminder', None, None, ), # 5
4303 rajveer 19698 
  )
19699 
 
4369 rajveer 19700 
  def __init__(self, vendorId=None, itemId=None, quantity=None, estimate=None, isReminder=None,):
4303 rajveer 19701 
    self.vendorId = vendorId
19702 
    self.itemId = itemId
19703 
    self.quantity = quantity
19704 
    self.estimate = estimate
4369 rajveer 19705 
    self.isReminder = isReminder
4303 rajveer 19706 
 
19707 
  def read(self, iprot):
19708 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
19709 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
19710 
      return
19711 
    iprot.readStructBegin()
19712 
    while True:
19713 
      (fname, ftype, fid) = iprot.readFieldBegin()
19714 
      if ftype == TType.STOP:
19715 
        break
19716 
      if fid == 1:
19717 
        if ftype == TType.I64:
19718 
          self.vendorId = iprot.readI64();
19719 
        else:
19720 
          iprot.skip(ftype)
19721 
      elif fid == 2:
19722 
        if ftype == TType.I64:
19723 
          self.itemId = iprot.readI64();
19724 
        else:
19725 
          iprot.skip(ftype)
19726 
      elif fid == 3:
19727 
        if ftype == TType.I64:
19728 
          self.quantity = iprot.readI64();
19729 
        else:
19730 
          iprot.skip(ftype)
19731 
      elif fid == 4:
19732 
        if ftype == TType.I64:
19733 
          self.estimate = iprot.readI64();
19734 
        else:
19735 
          iprot.skip(ftype)
4369 rajveer 19736 
      elif fid == 5:
19737 
        if ftype == TType.BOOL:
19738 
          self.isReminder = iprot.readBool();
19739 
        else:
19740 
          iprot.skip(ftype)
4303 rajveer 19741 
      else:
19742 
        iprot.skip(ftype)
19743 
      iprot.readFieldEnd()
19744 
    iprot.readStructEnd()
19745 
 
19746 
  def write(self, oprot):
19747 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
19748 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
19749 
      return
19750 
    oprot.writeStructBegin('markOrdersAsNotAvailabke_args')
19751 
    if self.vendorId is not None:
19752 
      oprot.writeFieldBegin('vendorId', TType.I64, 1)
19753 
      oprot.writeI64(self.vendorId)
19754 
      oprot.writeFieldEnd()
19755 
    if self.itemId is not None:
19756 
      oprot.writeFieldBegin('itemId', TType.I64, 2)
19757 
      oprot.writeI64(self.itemId)
19758 
      oprot.writeFieldEnd()
19759 
    if self.quantity is not None:
19760 
      oprot.writeFieldBegin('quantity', TType.I64, 3)
19761 
      oprot.writeI64(self.quantity)
19762 
      oprot.writeFieldEnd()
19763 
    if self.estimate is not None:
19764 
      oprot.writeFieldBegin('estimate', TType.I64, 4)
19765 
      oprot.writeI64(self.estimate)
19766 
      oprot.writeFieldEnd()
4369 rajveer 19767 
    if self.isReminder is not None:
19768 
      oprot.writeFieldBegin('isReminder', TType.BOOL, 5)
19769 
      oprot.writeBool(self.isReminder)
19770 
      oprot.writeFieldEnd()
4303 rajveer 19771 
    oprot.writeFieldStop()
19772 
    oprot.writeStructEnd()
19773 
 
19774 
  def validate(self):
19775 
    return
19776 
 
19777 
 
19778 
  def __repr__(self):
19779 
    L = ['%s=%r' % (key, value)
19780 
      for key, value in self.__dict__.iteritems()]
19781 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
19782 
 
19783 
  def __eq__(self, other):
19784 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
19785 
 
19786 
  def __ne__(self, other):
19787 
    return not (self == other)
19788 
 
19789 
class markOrdersAsNotAvailabke_result:
19790 
  """
19791 
  Attributes:
19792 
   - ex
19793 
  """
19794 
 
19795 
  thrift_spec = (
19796 
    None, # 0
19797 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
19798 
  )
19799 
 
19800 
  def __init__(self, ex=None,):
19801 
    self.ex = ex
19802 
 
19803 
  def read(self, iprot):
19804 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
19805 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
19806 
      return
19807 
    iprot.readStructBegin()
19808 
    while True:
19809 
      (fname, ftype, fid) = iprot.readFieldBegin()
19810 
      if ftype == TType.STOP:
19811 
        break
19812 
      if fid == 1:
19813 
        if ftype == TType.STRUCT:
19814 
          self.ex = TransactionServiceException()
19815 
          self.ex.read(iprot)
19816 
        else:
19817 
          iprot.skip(ftype)
19818 
      else:
19819 
        iprot.skip(ftype)
19820 
      iprot.readFieldEnd()
19821 
    iprot.readStructEnd()
19822 
 
19823 
  def write(self, oprot):
19824 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
19825 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
19826 
      return
19827 
    oprot.writeStructBegin('markOrdersAsNotAvailabke_result')
19828 
    if self.ex is not None:
19829 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
19830 
      self.ex.write(oprot)
19831 
      oprot.writeFieldEnd()
19832 
    oprot.writeFieldStop()
19833 
    oprot.writeStructEnd()
19834 
 
19835 
  def validate(self):
19836 
    return
19837 
 
19838 
 
19839 
  def __repr__(self):
19840 
    L = ['%s=%r' % (key, value)
19841 
      for key, value in self.__dict__.iteritems()]
19842 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
19843 
 
19844 
  def __eq__(self, other):
19845 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
19846 
 
19847 
  def __ne__(self, other):
19848 
    return not (self == other)
4369 rajveer 19849 
 
19850 
class markOrdersAsTimeout_args:
19851 
  """
19852 
  Attributes:
19853 
   - vendorId
19854 
  """
19855 
 
19856 
  thrift_spec = (
19857 
    None, # 0
19858 
    (1, TType.I64, 'vendorId', None, None, ), # 1
19859 
  )
19860 
 
19861 
  def __init__(self, vendorId=None,):
19862 
    self.vendorId = vendorId
19863 
 
19864 
  def read(self, iprot):
19865 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
19866 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
19867 
      return
19868 
    iprot.readStructBegin()
19869 
    while True:
19870 
      (fname, ftype, fid) = iprot.readFieldBegin()
19871 
      if ftype == TType.STOP:
19872 
        break
19873 
      if fid == 1:
19874 
        if ftype == TType.I64:
19875 
          self.vendorId = iprot.readI64();
19876 
        else:
19877 
          iprot.skip(ftype)
19878 
      else:
19879 
        iprot.skip(ftype)
19880 
      iprot.readFieldEnd()
19881 
    iprot.readStructEnd()
19882 
 
19883 
  def write(self, oprot):
19884 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
19885 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
19886 
      return
19887 
    oprot.writeStructBegin('markOrdersAsTimeout_args')
19888 
    if self.vendorId is not None:
19889 
      oprot.writeFieldBegin('vendorId', TType.I64, 1)
19890 
      oprot.writeI64(self.vendorId)
19891 
      oprot.writeFieldEnd()
19892 
    oprot.writeFieldStop()
19893 
    oprot.writeStructEnd()
19894 
 
19895 
  def validate(self):
19896 
    return
19897 
 
19898 
 
19899 
  def __repr__(self):
19900 
    L = ['%s=%r' % (key, value)
19901 
      for key, value in self.__dict__.iteritems()]
19902 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
19903 
 
19904 
  def __eq__(self, other):
19905 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
19906 
 
19907 
  def __ne__(self, other):
19908 
    return not (self == other)
19909 
 
19910 
class markOrdersAsTimeout_result:
19911 
  """
19912 
  Attributes:
19913 
   - success
19914 
   - ex
19915 
  """
19916 
 
19917 
  thrift_spec = (
19918 
    (0, TType.MAP, 'success', (TType.I32,None,TType.STRUCT,(TimeoutSummary, TimeoutSummary.thrift_spec)), None, ), # 0
19919 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
19920 
  )
19921 
 
19922 
  def __init__(self, success=None, ex=None,):
19923 
    self.success = success
19924 
    self.ex = ex
19925 
 
19926 
  def read(self, iprot):
19927 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
19928 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
19929 
      return
19930 
    iprot.readStructBegin()
19931 
    while True:
19932 
      (fname, ftype, fid) = iprot.readFieldBegin()
19933 
      if ftype == TType.STOP:
19934 
        break
19935 
      if fid == 0:
19936 
        if ftype == TType.MAP:
19937 
          self.success = {}
5481 phani.kuma 19938 
          (_ktype445, _vtype446, _size444 ) = iprot.readMapBegin()
19939 
          for _i448 in xrange(_size444):
19940 
            _key449 = iprot.readI32();
19941 
            _val450 = TimeoutSummary()
19942 
            _val450.read(iprot)
19943 
            self.success[_key449] = _val450
4369 rajveer 19944 
          iprot.readMapEnd()
19945 
        else:
19946 
          iprot.skip(ftype)
19947 
      elif fid == 1:
19948 
        if ftype == TType.STRUCT:
19949 
          self.ex = TransactionServiceException()
19950 
          self.ex.read(iprot)
19951 
        else:
19952 
          iprot.skip(ftype)
19953 
      else:
19954 
        iprot.skip(ftype)
19955 
      iprot.readFieldEnd()
19956 
    iprot.readStructEnd()
19957 
 
19958 
  def write(self, oprot):
19959 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
19960 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
19961 
      return
19962 
    oprot.writeStructBegin('markOrdersAsTimeout_result')
19963 
    if self.success is not None:
19964 
      oprot.writeFieldBegin('success', TType.MAP, 0)
19965 
      oprot.writeMapBegin(TType.I32, TType.STRUCT, len(self.success))
5481 phani.kuma 19966 
      for kiter451,viter452 in self.success.items():
19967 
        oprot.writeI32(kiter451)
19968 
        viter452.write(oprot)
4369 rajveer 19969 
      oprot.writeMapEnd()
19970 
      oprot.writeFieldEnd()
19971 
    if self.ex is not None:
19972 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
19973 
      self.ex.write(oprot)
19974 
      oprot.writeFieldEnd()
19975 
    oprot.writeFieldStop()
19976 
    oprot.writeStructEnd()
19977 
 
19978 
  def validate(self):
19979 
    return
19980 
 
19981 
 
19982 
  def __repr__(self):
19983 
    L = ['%s=%r' % (key, value)
19984 
      for key, value in self.__dict__.iteritems()]
19985 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
19986 
 
19987 
  def __eq__(self, other):
19988 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
19989 
 
19990 
  def __ne__(self, other):
19991 
    return not (self == other)
4386 anupam.sin 19992 
 
4662 rajveer 19993 
class markOrderAsLostInTransit_args:
19994 
  """
19995 
  Attributes:
19996 
   - orderId
19997 
  """
19998 
 
19999 
  thrift_spec = (
20000 
    None, # 0
20001 
    (1, TType.I64, 'orderId', None, None, ), # 1
20002 
  )
20003 
 
20004 
  def __init__(self, orderId=None,):
20005 
    self.orderId = orderId
20006 
 
20007 
  def read(self, iprot):
20008 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
20009 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
20010 
      return
20011 
    iprot.readStructBegin()
20012 
    while True:
20013 
      (fname, ftype, fid) = iprot.readFieldBegin()
20014 
      if ftype == TType.STOP:
20015 
        break
20016 
      if fid == 1:
20017 
        if ftype == TType.I64:
20018 
          self.orderId = iprot.readI64();
20019 
        else:
20020 
          iprot.skip(ftype)
20021 
      else:
20022 
        iprot.skip(ftype)
20023 
      iprot.readFieldEnd()
20024 
    iprot.readStructEnd()
20025 
 
20026 
  def write(self, oprot):
20027 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
20028 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
20029 
      return
20030 
    oprot.writeStructBegin('markOrderAsLostInTransit_args')
20031 
    if self.orderId is not None:
20032 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
20033 
      oprot.writeI64(self.orderId)
20034 
      oprot.writeFieldEnd()
20035 
    oprot.writeFieldStop()
20036 
    oprot.writeStructEnd()
20037 
 
20038 
  def validate(self):
20039 
    return
20040 
 
20041 
 
20042 
  def __repr__(self):
20043 
    L = ['%s=%r' % (key, value)
20044 
      for key, value in self.__dict__.iteritems()]
20045 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
20046 
 
20047 
  def __eq__(self, other):
20048 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
20049 
 
20050 
  def __ne__(self, other):
20051 
    return not (self == other)
20052 
 
20053 
class markOrderAsLostInTransit_result:
20054 
  """
20055 
  Attributes:
20056 
   - success
20057 
   - ex
20058 
  """
20059 
 
20060 
  thrift_spec = (
20061 
    (0, TType.BOOL, 'success', None, None, ), # 0
20062 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
20063 
  )
20064 
 
20065 
  def __init__(self, success=None, ex=None,):
20066 
    self.success = success
20067 
    self.ex = ex
20068 
 
20069 
  def read(self, iprot):
20070 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
20071 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
20072 
      return
20073 
    iprot.readStructBegin()
20074 
    while True:
20075 
      (fname, ftype, fid) = iprot.readFieldBegin()
20076 
      if ftype == TType.STOP:
20077 
        break
20078 
      if fid == 0:
20079 
        if ftype == TType.BOOL:
20080 
          self.success = iprot.readBool();
20081 
        else:
20082 
          iprot.skip(ftype)
20083 
      elif fid == 1:
20084 
        if ftype == TType.STRUCT:
20085 
          self.ex = TransactionServiceException()
20086 
          self.ex.read(iprot)
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('markOrderAsLostInTransit_result')
20099 
    if self.success is not None:
20100 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
20101 
      oprot.writeBool(self.success)
20102 
      oprot.writeFieldEnd()
20103 
    if self.ex is not None:
20104 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
20105 
      self.ex.write(oprot)
20106 
      oprot.writeFieldEnd()
20107 
    oprot.writeFieldStop()
20108 
    oprot.writeStructEnd()
20109 
 
20110 
  def validate(self):
20111 
    return
20112 
 
20113 
 
20114 
  def __repr__(self):
20115 
    L = ['%s=%r' % (key, value)
20116 
      for key, value in self.__dict__.iteritems()]
20117 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
20118 
 
20119 
  def __eq__(self, other):
20120 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
20121 
 
20122 
  def __ne__(self, other):
20123 
    return not (self == other)
20124 
 
4386 anupam.sin 20125 
class getOrderForAwb_args:
20126 
  """
20127 
  Attributes:
20128 
   - awb
20129 
  """
20130 
 
20131 
  thrift_spec = (
20132 
    None, # 0
20133 
    (1, TType.STRING, 'awb', None, None, ), # 1
20134 
  )
20135 
 
20136 
  def __init__(self, awb=None,):
20137 
    self.awb = awb
20138 
 
20139 
  def read(self, iprot):
20140 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
20141 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
20142 
      return
20143 
    iprot.readStructBegin()
20144 
    while True:
20145 
      (fname, ftype, fid) = iprot.readFieldBegin()
20146 
      if ftype == TType.STOP:
20147 
        break
20148 
      if fid == 1:
20149 
        if ftype == TType.STRING:
20150 
          self.awb = iprot.readString();
20151 
        else:
20152 
          iprot.skip(ftype)
20153 
      else:
20154 
        iprot.skip(ftype)
20155 
      iprot.readFieldEnd()
20156 
    iprot.readStructEnd()
20157 
 
20158 
  def write(self, oprot):
20159 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
20160 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
20161 
      return
20162 
    oprot.writeStructBegin('getOrderForAwb_args')
20163 
    if self.awb is not None:
20164 
      oprot.writeFieldBegin('awb', TType.STRING, 1)
20165 
      oprot.writeString(self.awb)
20166 
      oprot.writeFieldEnd()
20167 
    oprot.writeFieldStop()
20168 
    oprot.writeStructEnd()
20169 
 
20170 
  def validate(self):
20171 
    return
20172 
 
20173 
 
20174 
  def __repr__(self):
20175 
    L = ['%s=%r' % (key, value)
20176 
      for key, value in self.__dict__.iteritems()]
20177 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
20178 
 
20179 
  def __eq__(self, other):
20180 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
20181 
 
20182 
  def __ne__(self, other):
20183 
    return not (self == other)
20184 
 
20185 
class getOrderForAwb_result:
20186 
  """
20187 
  Attributes:
20188 
   - success
20189 
   - ex
20190 
  """
20191 
 
20192 
  thrift_spec = (
20193 
    (0, TType.STRUCT, 'success', (Order, Order.thrift_spec), None, ), # 0
20194 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
20195 
  )
20196 
 
20197 
  def __init__(self, success=None, ex=None,):
20198 
    self.success = success
20199 
    self.ex = ex
20200 
 
20201 
  def read(self, iprot):
20202 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
20203 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
20204 
      return
20205 
    iprot.readStructBegin()
20206 
    while True:
20207 
      (fname, ftype, fid) = iprot.readFieldBegin()
20208 
      if ftype == TType.STOP:
20209 
        break
20210 
      if fid == 0:
20211 
        if ftype == TType.STRUCT:
20212 
          self.success = Order()
20213 
          self.success.read(iprot)
20214 
        else:
20215 
          iprot.skip(ftype)
20216 
      elif fid == 1:
20217 
        if ftype == TType.STRUCT:
20218 
          self.ex = TransactionServiceException()
20219 
          self.ex.read(iprot)
20220 
        else:
20221 
          iprot.skip(ftype)
20222 
      else:
20223 
        iprot.skip(ftype)
20224 
      iprot.readFieldEnd()
20225 
    iprot.readStructEnd()
20226 
 
20227 
  def write(self, oprot):
20228 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
20229 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
20230 
      return
20231 
    oprot.writeStructBegin('getOrderForAwb_result')
20232 
    if self.success is not None:
20233 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
20234 
      self.success.write(oprot)
20235 
      oprot.writeFieldEnd()
20236 
    if self.ex is not None:
20237 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
20238 
      self.ex.write(oprot)
20239 
      oprot.writeFieldEnd()
20240 
    oprot.writeFieldStop()
20241 
    oprot.writeStructEnd()
20242 
 
20243 
  def validate(self):
20244 
    return
20245 
 
20246 
 
20247 
  def __repr__(self):
20248 
    L = ['%s=%r' % (key, value)
20249 
      for key, value in self.__dict__.iteritems()]
20250 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
20251 
 
20252 
  def __eq__(self, other):
20253 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
20254 
 
20255 
  def __ne__(self, other):
20256 
    return not (self == other)
4506 phani.kuma 20257 
 
20258 
class getOrdersForProviderForStatus_args:
20259 
  """
20260 
  Attributes:
20261 
   - logistics_provider_id
4910 phani.kuma 20262 
   - order_status_list
4506 phani.kuma 20263 
  """
20264 
 
20265 
  thrift_spec = (
20266 
    None, # 0
20267 
    (1, TType.I64, 'logistics_provider_id', None, None, ), # 1
4910 phani.kuma 20268 
    (2, TType.LIST, 'order_status_list', (TType.I32,None), None, ), # 2
4506 phani.kuma 20269 
  )
20270 
 
4910 phani.kuma 20271 
  def __init__(self, logistics_provider_id=None, order_status_list=None,):
4506 phani.kuma 20272 
    self.logistics_provider_id = logistics_provider_id
4910 phani.kuma 20273 
    self.order_status_list = order_status_list
4506 phani.kuma 20274 
 
20275 
  def read(self, iprot):
20276 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
20277 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
20278 
      return
20279 
    iprot.readStructBegin()
20280 
    while True:
20281 
      (fname, ftype, fid) = iprot.readFieldBegin()
20282 
      if ftype == TType.STOP:
20283 
        break
20284 
      if fid == 1:
20285 
        if ftype == TType.I64:
20286 
          self.logistics_provider_id = iprot.readI64();
20287 
        else:
20288 
          iprot.skip(ftype)
20289 
      elif fid == 2:
4910 phani.kuma 20290 
        if ftype == TType.LIST:
20291 
          self.order_status_list = []
5481 phani.kuma 20292 
          (_etype456, _size453) = iprot.readListBegin()
20293 
          for _i457 in xrange(_size453):
20294 
            _elem458 = iprot.readI32();
20295 
            self.order_status_list.append(_elem458)
4910 phani.kuma 20296 
          iprot.readListEnd()
4506 phani.kuma 20297 
        else:
20298 
          iprot.skip(ftype)
20299 
      else:
20300 
        iprot.skip(ftype)
20301 
      iprot.readFieldEnd()
20302 
    iprot.readStructEnd()
20303 
 
20304 
  def write(self, oprot):
20305 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
20306 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
20307 
      return
20308 
    oprot.writeStructBegin('getOrdersForProviderForStatus_args')
20309 
    if self.logistics_provider_id is not None:
20310 
      oprot.writeFieldBegin('logistics_provider_id', TType.I64, 1)
20311 
      oprot.writeI64(self.logistics_provider_id)
20312 
      oprot.writeFieldEnd()
4910 phani.kuma 20313 
    if self.order_status_list is not None:
20314 
      oprot.writeFieldBegin('order_status_list', TType.LIST, 2)
20315 
      oprot.writeListBegin(TType.I32, len(self.order_status_list))
5481 phani.kuma 20316 
      for iter459 in self.order_status_list:
20317 
        oprot.writeI32(iter459)
4910 phani.kuma 20318 
      oprot.writeListEnd()
4506 phani.kuma 20319 
      oprot.writeFieldEnd()
20320 
    oprot.writeFieldStop()
20321 
    oprot.writeStructEnd()
20322 
 
20323 
  def validate(self):
20324 
    return
20325 
 
20326 
 
20327 
  def __repr__(self):
20328 
    L = ['%s=%r' % (key, value)
20329 
      for key, value in self.__dict__.iteritems()]
20330 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
20331 
 
20332 
  def __eq__(self, other):
20333 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
20334 
 
20335 
  def __ne__(self, other):
20336 
    return not (self == other)
20337 
 
20338 
class getOrdersForProviderForStatus_result:
20339 
  """
20340 
  Attributes:
20341 
   - success
20342 
   - ex
20343 
  """
20344 
 
20345 
  thrift_spec = (
20346 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
20347 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
20348 
  )
20349 
 
20350 
  def __init__(self, success=None, ex=None,):
20351 
    self.success = success
20352 
    self.ex = ex
20353 
 
20354 
  def read(self, iprot):
20355 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
20356 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
20357 
      return
20358 
    iprot.readStructBegin()
20359 
    while True:
20360 
      (fname, ftype, fid) = iprot.readFieldBegin()
20361 
      if ftype == TType.STOP:
20362 
        break
20363 
      if fid == 0:
20364 
        if ftype == TType.LIST:
20365 
          self.success = []
5481 phani.kuma 20366 
          (_etype463, _size460) = iprot.readListBegin()
20367 
          for _i464 in xrange(_size460):
20368 
            _elem465 = Order()
20369 
            _elem465.read(iprot)
20370 
            self.success.append(_elem465)
4506 phani.kuma 20371 
          iprot.readListEnd()
20372 
        else:
20373 
          iprot.skip(ftype)
20374 
      elif fid == 1:
20375 
        if ftype == TType.STRUCT:
20376 
          self.ex = TransactionServiceException()
20377 
          self.ex.read(iprot)
20378 
        else:
20379 
          iprot.skip(ftype)
20380 
      else:
20381 
        iprot.skip(ftype)
20382 
      iprot.readFieldEnd()
20383 
    iprot.readStructEnd()
20384 
 
20385 
  def write(self, oprot):
20386 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
20387 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
20388 
      return
20389 
    oprot.writeStructBegin('getOrdersForProviderForStatus_result')
20390 
    if self.success is not None:
20391 
      oprot.writeFieldBegin('success', TType.LIST, 0)
20392 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
5481 phani.kuma 20393 
      for iter466 in self.success:
20394 
        iter466.write(oprot)
4506 phani.kuma 20395 
      oprot.writeListEnd()
20396 
      oprot.writeFieldEnd()
20397 
    if self.ex is not None:
20398 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
20399 
      self.ex.write(oprot)
20400 
      oprot.writeFieldEnd()
20401 
    oprot.writeFieldStop()
20402 
    oprot.writeStructEnd()
20403 
 
20404 
  def validate(self):
20405 
    return
20406 
 
20407 
 
20408 
  def __repr__(self):
20409 
    L = ['%s=%r' % (key, value)
20410 
      for key, value in self.__dict__.iteritems()]
20411 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
20412 
 
20413 
  def __eq__(self, other):
20414 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
20415 
 
20416 
  def __ne__(self, other):
20417 
    return not (self == other)
4600 varun.gupt 20418 
 
20419 
class getBilledOrdersForVendor_args:
20420 
  """
20421 
  Attributes:
20422 
   - vendorId
20423 
   - billingDateFrom
20424 
   - billingDateTo
20425 
  """
20426 
 
20427 
  thrift_spec = (
20428 
    None, # 0
20429 
    (1, TType.I64, 'vendorId', None, None, ), # 1
20430 
    (2, TType.I64, 'billingDateFrom', None, None, ), # 2
20431 
    (3, TType.I64, 'billingDateTo', None, None, ), # 3
20432 
  )
20433 
 
20434 
  def __init__(self, vendorId=None, billingDateFrom=None, billingDateTo=None,):
20435 
    self.vendorId = vendorId
20436 
    self.billingDateFrom = billingDateFrom
20437 
    self.billingDateTo = billingDateTo
20438 
 
20439 
  def read(self, iprot):
20440 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
20441 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
20442 
      return
20443 
    iprot.readStructBegin()
20444 
    while True:
20445 
      (fname, ftype, fid) = iprot.readFieldBegin()
20446 
      if ftype == TType.STOP:
20447 
        break
20448 
      if fid == 1:
20449 
        if ftype == TType.I64:
20450 
          self.vendorId = iprot.readI64();
20451 
        else:
20452 
          iprot.skip(ftype)
20453 
      elif fid == 2:
20454 
        if ftype == TType.I64:
20455 
          self.billingDateFrom = iprot.readI64();
20456 
        else:
20457 
          iprot.skip(ftype)
20458 
      elif fid == 3:
20459 
        if ftype == TType.I64:
20460 
          self.billingDateTo = iprot.readI64();
20461 
        else:
20462 
          iprot.skip(ftype)
20463 
      else:
20464 
        iprot.skip(ftype)
20465 
      iprot.readFieldEnd()
20466 
    iprot.readStructEnd()
20467 
 
20468 
  def write(self, oprot):
20469 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
20470 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
20471 
      return
20472 
    oprot.writeStructBegin('getBilledOrdersForVendor_args')
20473 
    if self.vendorId is not None:
20474 
      oprot.writeFieldBegin('vendorId', TType.I64, 1)
20475 
      oprot.writeI64(self.vendorId)
20476 
      oprot.writeFieldEnd()
20477 
    if self.billingDateFrom is not None:
20478 
      oprot.writeFieldBegin('billingDateFrom', TType.I64, 2)
20479 
      oprot.writeI64(self.billingDateFrom)
20480 
      oprot.writeFieldEnd()
20481 
    if self.billingDateTo is not None:
20482 
      oprot.writeFieldBegin('billingDateTo', TType.I64, 3)
20483 
      oprot.writeI64(self.billingDateTo)
20484 
      oprot.writeFieldEnd()
20485 
    oprot.writeFieldStop()
20486 
    oprot.writeStructEnd()
20487 
 
20488 
  def validate(self):
20489 
    return
20490 
 
20491 
 
20492 
  def __repr__(self):
20493 
    L = ['%s=%r' % (key, value)
20494 
      for key, value in self.__dict__.iteritems()]
20495 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
20496 
 
20497 
  def __eq__(self, other):
20498 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
20499 
 
20500 
  def __ne__(self, other):
20501 
    return not (self == other)
20502 
 
20503 
class getBilledOrdersForVendor_result:
20504 
  """
20505 
  Attributes:
20506 
   - success
20507 
   - ex
20508 
  """
20509 
 
20510 
  thrift_spec = (
20511 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
20512 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
20513 
  )
20514 
 
20515 
  def __init__(self, success=None, ex=None,):
20516 
    self.success = success
20517 
    self.ex = ex
20518 
 
20519 
  def read(self, iprot):
20520 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
20521 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
20522 
      return
20523 
    iprot.readStructBegin()
20524 
    while True:
20525 
      (fname, ftype, fid) = iprot.readFieldBegin()
20526 
      if ftype == TType.STOP:
20527 
        break
20528 
      if fid == 0:
20529 
        if ftype == TType.LIST:
20530 
          self.success = []
5481 phani.kuma 20531 
          (_etype470, _size467) = iprot.readListBegin()
20532 
          for _i471 in xrange(_size467):
20533 
            _elem472 = Order()
20534 
            _elem472.read(iprot)
20535 
            self.success.append(_elem472)
4600 varun.gupt 20536 
          iprot.readListEnd()
20537 
        else:
20538 
          iprot.skip(ftype)
20539 
      elif fid == 1:
20540 
        if ftype == TType.STRUCT:
20541 
          self.ex = TransactionServiceException()
20542 
          self.ex.read(iprot)
20543 
        else:
20544 
          iprot.skip(ftype)
20545 
      else:
20546 
        iprot.skip(ftype)
20547 
      iprot.readFieldEnd()
20548 
    iprot.readStructEnd()
20549 
 
20550 
  def write(self, oprot):
20551 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
20552 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
20553 
      return
20554 
    oprot.writeStructBegin('getBilledOrdersForVendor_result')
20555 
    if self.success is not None:
20556 
      oprot.writeFieldBegin('success', TType.LIST, 0)
20557 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
5481 phani.kuma 20558 
      for iter473 in self.success:
20559 
        iter473.write(oprot)
4600 varun.gupt 20560 
      oprot.writeListEnd()
20561 
      oprot.writeFieldEnd()
20562 
    if self.ex is not None:
20563 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
20564 
      self.ex.write(oprot)
20565 
      oprot.writeFieldEnd()
20566 
    oprot.writeFieldStop()
20567 
    oprot.writeStructEnd()
20568 
 
20569 
  def validate(self):
20570 
    return
20571 
 
20572 
 
20573 
  def __repr__(self):
20574 
    L = ['%s=%r' % (key, value)
20575 
      for key, value in self.__dict__.iteritems()]
20576 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
20577 
 
20578 
  def __eq__(self, other):
20579 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
20580 
 
20581 
  def __ne__(self, other):
20582 
    return not (self == other)
20583 
 
4607 rajveer 20584 
class getSlippedSippingDateOrders_args:
20585 
 
20586 
  thrift_spec = (
20587 
  )
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 
      else:
20599 
        iprot.skip(ftype)
20600 
      iprot.readFieldEnd()
20601 
    iprot.readStructEnd()
20602 
 
20603 
  def write(self, oprot):
20604 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
20605 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
20606 
      return
20607 
    oprot.writeStructBegin('getSlippedSippingDateOrders_args')
20608 
    oprot.writeFieldStop()
20609 
    oprot.writeStructEnd()
20610 
 
20611 
  def validate(self):
20612 
    return
20613 
 
20614 
 
20615 
  def __repr__(self):
20616 
    L = ['%s=%r' % (key, value)
20617 
      for key, value in self.__dict__.iteritems()]
20618 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
20619 
 
20620 
  def __eq__(self, other):
20621 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
20622 
 
20623 
  def __ne__(self, other):
20624 
    return not (self == other)
20625 
 
20626 
class getSlippedSippingDateOrders_result:
20627 
  """
20628 
  Attributes:
20629 
   - success
20630 
   - ex
20631 
  """
20632 
 
20633 
  thrift_spec = (
20634 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
20635 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
20636 
  )
20637 
 
20638 
  def __init__(self, success=None, ex=None,):
20639 
    self.success = success
20640 
    self.ex = ex
20641 
 
20642 
  def read(self, iprot):
20643 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
20644 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
20645 
      return
20646 
    iprot.readStructBegin()
20647 
    while True:
20648 
      (fname, ftype, fid) = iprot.readFieldBegin()
20649 
      if ftype == TType.STOP:
20650 
        break
20651 
      if fid == 0:
20652 
        if ftype == TType.LIST:
20653 
          self.success = []
5481 phani.kuma 20654 
          (_etype477, _size474) = iprot.readListBegin()
20655 
          for _i478 in xrange(_size474):
20656 
            _elem479 = Order()
20657 
            _elem479.read(iprot)
20658 
            self.success.append(_elem479)
4607 rajveer 20659 
          iprot.readListEnd()
20660 
        else:
20661 
          iprot.skip(ftype)
20662 
      elif fid == 1:
20663 
        if ftype == TType.STRUCT:
20664 
          self.ex = TransactionServiceException()
20665 
          self.ex.read(iprot)
20666 
        else:
20667 
          iprot.skip(ftype)
20668 
      else:
20669 
        iprot.skip(ftype)
20670 
      iprot.readFieldEnd()
20671 
    iprot.readStructEnd()
20672 
 
20673 
  def write(self, oprot):
20674 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
20675 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
20676 
      return
20677 
    oprot.writeStructBegin('getSlippedSippingDateOrders_result')
20678 
    if self.success is not None:
20679 
      oprot.writeFieldBegin('success', TType.LIST, 0)
20680 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
5481 phani.kuma 20681 
      for iter480 in self.success:
20682 
        iter480.write(oprot)
4607 rajveer 20683 
      oprot.writeListEnd()
20684 
      oprot.writeFieldEnd()
20685 
    if self.ex is not None:
20686 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
20687 
      self.ex.write(oprot)
20688 
      oprot.writeFieldEnd()
20689 
    oprot.writeFieldStop()
20690 
    oprot.writeStructEnd()
20691 
 
20692 
  def validate(self):
20693 
    return
20694 
 
20695 
 
20696 
  def __repr__(self):
20697 
    L = ['%s=%r' % (key, value)
20698 
      for key, value in self.__dict__.iteritems()]
20699 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
20700 
 
20701 
  def __eq__(self, other):
20702 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
20703 
 
20704 
  def __ne__(self, other):
20705 
    return not (self == other)
20706 
 
4709 rajveer 20707 
class getCancelledOrders_args:
20708 
  """
20709 
  Attributes:
20710 
   - cancelDateFrom
20711 
   - cancelDateTo
20712 
  """
20713 
 
20714 
  thrift_spec = (
20715 
    None, # 0
20716 
    (1, TType.I64, 'cancelDateFrom', None, None, ), # 1
20717 
    (2, TType.I64, 'cancelDateTo', None, None, ), # 2
20718 
  )
20719 
 
20720 
  def __init__(self, cancelDateFrom=None, cancelDateTo=None,):
20721 
    self.cancelDateFrom = cancelDateFrom
20722 
    self.cancelDateTo = cancelDateTo
20723 
 
20724 
  def read(self, iprot):
20725 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
20726 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
20727 
      return
20728 
    iprot.readStructBegin()
20729 
    while True:
20730 
      (fname, ftype, fid) = iprot.readFieldBegin()
20731 
      if ftype == TType.STOP:
20732 
        break
20733 
      if fid == 1:
20734 
        if ftype == TType.I64:
20735 
          self.cancelDateFrom = iprot.readI64();
20736 
        else:
20737 
          iprot.skip(ftype)
20738 
      elif fid == 2:
20739 
        if ftype == TType.I64:
20740 
          self.cancelDateTo = iprot.readI64();
20741 
        else:
20742 
          iprot.skip(ftype)
20743 
      else:
20744 
        iprot.skip(ftype)
20745 
      iprot.readFieldEnd()
20746 
    iprot.readStructEnd()
20747 
 
20748 
  def write(self, oprot):
20749 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
20750 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
20751 
      return
20752 
    oprot.writeStructBegin('getCancelledOrders_args')
20753 
    if self.cancelDateFrom is not None:
20754 
      oprot.writeFieldBegin('cancelDateFrom', TType.I64, 1)
20755 
      oprot.writeI64(self.cancelDateFrom)
20756 
      oprot.writeFieldEnd()
20757 
    if self.cancelDateTo is not None:
20758 
      oprot.writeFieldBegin('cancelDateTo', TType.I64, 2)
20759 
      oprot.writeI64(self.cancelDateTo)
20760 
      oprot.writeFieldEnd()
20761 
    oprot.writeFieldStop()
20762 
    oprot.writeStructEnd()
20763 
 
20764 
  def validate(self):
20765 
    return
20766 
 
20767 
 
20768 
  def __repr__(self):
20769 
    L = ['%s=%r' % (key, value)
20770 
      for key, value in self.__dict__.iteritems()]
20771 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
20772 
 
20773 
  def __eq__(self, other):
20774 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
20775 
 
20776 
  def __ne__(self, other):
20777 
    return not (self == other)
20778 
 
20779 
class getCancelledOrders_result:
20780 
  """
20781 
  Attributes:
20782 
   - success
20783 
   - ex
20784 
  """
20785 
 
20786 
  thrift_spec = (
20787 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
20788 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
20789 
  )
20790 
 
20791 
  def __init__(self, success=None, ex=None,):
20792 
    self.success = success
20793 
    self.ex = ex
20794 
 
20795 
  def read(self, iprot):
20796 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
20797 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
20798 
      return
20799 
    iprot.readStructBegin()
20800 
    while True:
20801 
      (fname, ftype, fid) = iprot.readFieldBegin()
20802 
      if ftype == TType.STOP:
20803 
        break
20804 
      if fid == 0:
20805 
        if ftype == TType.LIST:
20806 
          self.success = []
5481 phani.kuma 20807 
          (_etype484, _size481) = iprot.readListBegin()
20808 
          for _i485 in xrange(_size481):
20809 
            _elem486 = Order()
20810 
            _elem486.read(iprot)
20811 
            self.success.append(_elem486)
4709 rajveer 20812 
          iprot.readListEnd()
20813 
        else:
20814 
          iprot.skip(ftype)
20815 
      elif fid == 1:
20816 
        if ftype == TType.STRUCT:
20817 
          self.ex = TransactionServiceException()
20818 
          self.ex.read(iprot)
20819 
        else:
20820 
          iprot.skip(ftype)
20821 
      else:
20822 
        iprot.skip(ftype)
20823 
      iprot.readFieldEnd()
20824 
    iprot.readStructEnd()
20825 
 
20826 
  def write(self, oprot):
20827 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
20828 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
20829 
      return
20830 
    oprot.writeStructBegin('getCancelledOrders_result')
20831 
    if self.success is not None:
20832 
      oprot.writeFieldBegin('success', TType.LIST, 0)
20833 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
5481 phani.kuma 20834 
      for iter487 in self.success:
20835 
        iter487.write(oprot)
4709 rajveer 20836 
      oprot.writeListEnd()
20837 
      oprot.writeFieldEnd()
20838 
    if self.ex is not None:
20839 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
20840 
      self.ex.write(oprot)
20841 
      oprot.writeFieldEnd()
20842 
    oprot.writeFieldStop()
20843 
    oprot.writeStructEnd()
20844 
 
20845 
  def validate(self):
20846 
    return
20847 
 
20848 
 
20849 
  def __repr__(self):
20850 
    L = ['%s=%r' % (key, value)
20851 
      for key, value in self.__dict__.iteritems()]
20852 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
20853 
 
20854 
  def __eq__(self, other):
20855 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
20856 
 
20857 
  def __ne__(self, other):
20858 
    return not (self == other)
20859 
 
4600 varun.gupt 20860 
class saveBluedartSettlements_args:
20861 
  """
20862 
  Attributes:
20863 
   - mapAWBAndAmount
20864 
  """
20865 
 
20866 
  thrift_spec = (
20867 
    None, # 0
20868 
    (1, TType.MAP, 'mapAWBAndAmount', (TType.I64,None,TType.DOUBLE,None), None, ), # 1
20869 
  )
20870 
 
20871 
  def __init__(self, mapAWBAndAmount=None,):
20872 
    self.mapAWBAndAmount = mapAWBAndAmount
20873 
 
20874 
  def read(self, iprot):
20875 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
20876 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
20877 
      return
20878 
    iprot.readStructBegin()
20879 
    while True:
20880 
      (fname, ftype, fid) = iprot.readFieldBegin()
20881 
      if ftype == TType.STOP:
20882 
        break
20883 
      if fid == 1:
20884 
        if ftype == TType.MAP:
20885 
          self.mapAWBAndAmount = {}
5481 phani.kuma 20886 
          (_ktype489, _vtype490, _size488 ) = iprot.readMapBegin()
20887 
          for _i492 in xrange(_size488):
20888 
            _key493 = iprot.readI64();
20889 
            _val494 = iprot.readDouble();
20890 
            self.mapAWBAndAmount[_key493] = _val494
4600 varun.gupt 20891 
          iprot.readMapEnd()
20892 
        else:
20893 
          iprot.skip(ftype)
20894 
      else:
20895 
        iprot.skip(ftype)
20896 
      iprot.readFieldEnd()
20897 
    iprot.readStructEnd()
20898 
 
20899 
  def write(self, oprot):
20900 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
20901 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
20902 
      return
20903 
    oprot.writeStructBegin('saveBluedartSettlements_args')
20904 
    if self.mapAWBAndAmount is not None:
20905 
      oprot.writeFieldBegin('mapAWBAndAmount', TType.MAP, 1)
20906 
      oprot.writeMapBegin(TType.I64, TType.DOUBLE, len(self.mapAWBAndAmount))
5481 phani.kuma 20907 
      for kiter495,viter496 in self.mapAWBAndAmount.items():
20908 
        oprot.writeI64(kiter495)
20909 
        oprot.writeDouble(viter496)
4600 varun.gupt 20910 
      oprot.writeMapEnd()
20911 
      oprot.writeFieldEnd()
20912 
    oprot.writeFieldStop()
20913 
    oprot.writeStructEnd()
20914 
 
20915 
  def validate(self):
20916 
    return
20917 
 
20918 
 
20919 
  def __repr__(self):
20920 
    L = ['%s=%r' % (key, value)
20921 
      for key, value in self.__dict__.iteritems()]
20922 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
20923 
 
20924 
  def __eq__(self, other):
20925 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
20926 
 
20927 
  def __ne__(self, other):
20928 
    return not (self == other)
20929 
 
20930 
class saveBluedartSettlements_result:
20931 
  """
20932 
  Attributes:
20933 
   - ex
20934 
  """
20935 
 
20936 
  thrift_spec = (
20937 
    None, # 0
20938 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
20939 
  )
20940 
 
20941 
  def __init__(self, ex=None,):
20942 
    self.ex = ex
20943 
 
20944 
  def read(self, iprot):
20945 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
20946 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
20947 
      return
20948 
    iprot.readStructBegin()
20949 
    while True:
20950 
      (fname, ftype, fid) = iprot.readFieldBegin()
20951 
      if ftype == TType.STOP:
20952 
        break
20953 
      if fid == 1:
20954 
        if ftype == TType.STRUCT:
20955 
          self.ex = TransactionServiceException()
20956 
          self.ex.read(iprot)
20957 
        else:
20958 
          iprot.skip(ftype)
20959 
      else:
20960 
        iprot.skip(ftype)
20961 
      iprot.readFieldEnd()
20962 
    iprot.readStructEnd()
20963 
 
20964 
  def write(self, oprot):
20965 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
20966 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
20967 
      return
20968 
    oprot.writeStructBegin('saveBluedartSettlements_result')
20969 
    if self.ex is not None:
20970 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
20971 
      self.ex.write(oprot)
20972 
      oprot.writeFieldEnd()
20973 
    oprot.writeFieldStop()
20974 
    oprot.writeStructEnd()
20975 
 
20976 
  def validate(self):
20977 
    return
20978 
 
20979 
 
20980 
  def __repr__(self):
20981 
    L = ['%s=%r' % (key, value)
20982 
      for key, value in self.__dict__.iteritems()]
20983 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
20984 
 
20985 
  def __eq__(self, other):
20986 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
20987 
 
20988 
  def __ne__(self, other):
20989 
    return not (self == other)
20990 
 
20991 
class savePaymentSettlements_args:
20992 
  """
20993 
  Attributes:
20994 
   - settlementDate
20995 
   - paymentGatewayId
4905 varun.gupt 20996 
   - referenceId
4600 varun.gupt 20997 
   - serviceTax
20998 
   - otherCharges
20999 
   - netCollection
21000 
  """
21001 
 
21002 
  thrift_spec = (
21003 
    None, # 0
21004 
    (1, TType.I64, 'settlementDate', None, None, ), # 1
21005 
    (2, TType.I64, 'paymentGatewayId', None, None, ), # 2
4905 varun.gupt 21006 
    (3, TType.I64, 'referenceId', None, None, ), # 3
4600 varun.gupt 21007 
    (4, TType.DOUBLE, 'serviceTax', None, None, ), # 4
21008 
    (5, TType.DOUBLE, 'otherCharges', None, None, ), # 5
21009 
    (6, TType.DOUBLE, 'netCollection', None, None, ), # 6
21010 
  )
21011 
 
4905 varun.gupt 21012 
  def __init__(self, settlementDate=None, paymentGatewayId=None, referenceId=None, serviceTax=None, otherCharges=None, netCollection=None,):
4600 varun.gupt 21013 
    self.settlementDate = settlementDate
21014 
    self.paymentGatewayId = paymentGatewayId
4905 varun.gupt 21015 
    self.referenceId = referenceId
4600 varun.gupt 21016 
    self.serviceTax = serviceTax
21017 
    self.otherCharges = otherCharges
21018 
    self.netCollection = netCollection
21019 
 
21020 
  def read(self, iprot):
21021 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
21022 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
21023 
      return
21024 
    iprot.readStructBegin()
21025 
    while True:
21026 
      (fname, ftype, fid) = iprot.readFieldBegin()
21027 
      if ftype == TType.STOP:
21028 
        break
21029 
      if fid == 1:
21030 
        if ftype == TType.I64:
21031 
          self.settlementDate = iprot.readI64();
21032 
        else:
21033 
          iprot.skip(ftype)
21034 
      elif fid == 2:
21035 
        if ftype == TType.I64:
21036 
          self.paymentGatewayId = iprot.readI64();
21037 
        else:
21038 
          iprot.skip(ftype)
21039 
      elif fid == 3:
21040 
        if ftype == TType.I64:
4905 varun.gupt 21041 
          self.referenceId = iprot.readI64();
4600 varun.gupt 21042 
        else:
21043 
          iprot.skip(ftype)
21044 
      elif fid == 4:
21045 
        if ftype == TType.DOUBLE:
21046 
          self.serviceTax = iprot.readDouble();
21047 
        else:
21048 
          iprot.skip(ftype)
21049 
      elif fid == 5:
21050 
        if ftype == TType.DOUBLE:
21051 
          self.otherCharges = iprot.readDouble();
21052 
        else:
21053 
          iprot.skip(ftype)
21054 
      elif fid == 6:
21055 
        if ftype == TType.DOUBLE:
21056 
          self.netCollection = iprot.readDouble();
21057 
        else:
21058 
          iprot.skip(ftype)
21059 
      else:
21060 
        iprot.skip(ftype)
21061 
      iprot.readFieldEnd()
21062 
    iprot.readStructEnd()
21063 
 
21064 
  def write(self, oprot):
21065 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
21066 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
21067 
      return
21068 
    oprot.writeStructBegin('savePaymentSettlements_args')
21069 
    if self.settlementDate is not None:
21070 
      oprot.writeFieldBegin('settlementDate', TType.I64, 1)
21071 
      oprot.writeI64(self.settlementDate)
21072 
      oprot.writeFieldEnd()
21073 
    if self.paymentGatewayId is not None:
21074 
      oprot.writeFieldBegin('paymentGatewayId', TType.I64, 2)
21075 
      oprot.writeI64(self.paymentGatewayId)
21076 
      oprot.writeFieldEnd()
4905 varun.gupt 21077 
    if self.referenceId is not None:
21078 
      oprot.writeFieldBegin('referenceId', TType.I64, 3)
21079 
      oprot.writeI64(self.referenceId)
4600 varun.gupt 21080 
      oprot.writeFieldEnd()
21081 
    if self.serviceTax is not None:
21082 
      oprot.writeFieldBegin('serviceTax', TType.DOUBLE, 4)
21083 
      oprot.writeDouble(self.serviceTax)
21084 
      oprot.writeFieldEnd()
21085 
    if self.otherCharges is not None:
21086 
      oprot.writeFieldBegin('otherCharges', TType.DOUBLE, 5)
21087 
      oprot.writeDouble(self.otherCharges)
21088 
      oprot.writeFieldEnd()
21089 
    if self.netCollection is not None:
21090 
      oprot.writeFieldBegin('netCollection', TType.DOUBLE, 6)
21091 
      oprot.writeDouble(self.netCollection)
21092 
      oprot.writeFieldEnd()
21093 
    oprot.writeFieldStop()
21094 
    oprot.writeStructEnd()
21095 
 
21096 
  def validate(self):
21097 
    return
21098 
 
21099 
 
21100 
  def __repr__(self):
21101 
    L = ['%s=%r' % (key, value)
21102 
      for key, value in self.__dict__.iteritems()]
21103 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
21104 
 
21105 
  def __eq__(self, other):
21106 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
21107 
 
21108 
  def __ne__(self, other):
21109 
    return not (self == other)
21110 
 
21111 
class savePaymentSettlements_result:
21112 
  """
21113 
  Attributes:
21114 
   - ex
21115 
  """
21116 
 
21117 
  thrift_spec = (
21118 
    None, # 0
21119 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
21120 
  )
21121 
 
21122 
  def __init__(self, ex=None,):
21123 
    self.ex = ex
21124 
 
21125 
  def read(self, iprot):
21126 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
21127 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
21128 
      return
21129 
    iprot.readStructBegin()
21130 
    while True:
21131 
      (fname, ftype, fid) = iprot.readFieldBegin()
21132 
      if ftype == TType.STOP:
21133 
        break
21134 
      if fid == 1:
21135 
        if ftype == TType.STRUCT:
21136 
          self.ex = TransactionServiceException()
21137 
          self.ex.read(iprot)
21138 
        else:
21139 
          iprot.skip(ftype)
21140 
      else:
21141 
        iprot.skip(ftype)
21142 
      iprot.readFieldEnd()
21143 
    iprot.readStructEnd()
21144 
 
21145 
  def write(self, oprot):
21146 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
21147 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
21148 
      return
21149 
    oprot.writeStructBegin('savePaymentSettlements_result')
21150 
    if self.ex is not None:
21151 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
21152 
      self.ex.write(oprot)
21153 
      oprot.writeFieldEnd()
21154 
    oprot.writeFieldStop()
21155 
    oprot.writeStructEnd()
21156 
 
21157 
  def validate(self):
21158 
    return
21159 
 
21160 
 
21161 
  def __repr__(self):
21162 
    L = ['%s=%r' % (key, value)
21163 
      for key, value in self.__dict__.iteritems()]
21164 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
21165 
 
21166 
  def __eq__(self, other):
21167 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
21168 
 
21169 
  def __ne__(self, other):
21170 
    return not (self == other)
21171 
 
21172 
class saveEBSSettlementSummary_args:
21173 
  """
21174 
  Attributes:
21175 
   - settlementId
21176 
   - settlementDate
21177 
   - transactionDateFrom
21178 
   - transactionDateTo
21179 
   - amount
21180 
  """
21181 
 
21182 
  thrift_spec = (
21183 
    None, # 0
21184 
    (1, TType.I64, 'settlementId', None, None, ), # 1
21185 
    (2, TType.I64, 'settlementDate', None, None, ), # 2
21186 
    (3, TType.I64, 'transactionDateFrom', None, None, ), # 3
21187 
    (4, TType.I64, 'transactionDateTo', None, None, ), # 4
21188 
    (5, TType.DOUBLE, 'amount', None, None, ), # 5
21189 
  )
21190 
 
21191 
  def __init__(self, settlementId=None, settlementDate=None, transactionDateFrom=None, transactionDateTo=None, amount=None,):
21192 
    self.settlementId = settlementId
21193 
    self.settlementDate = settlementDate
21194 
    self.transactionDateFrom = transactionDateFrom
21195 
    self.transactionDateTo = transactionDateTo
21196 
    self.amount = amount
21197 
 
21198 
  def read(self, iprot):
21199 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
21200 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
21201 
      return
21202 
    iprot.readStructBegin()
21203 
    while True:
21204 
      (fname, ftype, fid) = iprot.readFieldBegin()
21205 
      if ftype == TType.STOP:
21206 
        break
21207 
      if fid == 1:
21208 
        if ftype == TType.I64:
21209 
          self.settlementId = iprot.readI64();
21210 
        else:
21211 
          iprot.skip(ftype)
21212 
      elif fid == 2:
21213 
        if ftype == TType.I64:
21214 
          self.settlementDate = iprot.readI64();
21215 
        else:
21216 
          iprot.skip(ftype)
21217 
      elif fid == 3:
21218 
        if ftype == TType.I64:
21219 
          self.transactionDateFrom = iprot.readI64();
21220 
        else:
21221 
          iprot.skip(ftype)
21222 
      elif fid == 4:
21223 
        if ftype == TType.I64:
21224 
          self.transactionDateTo = iprot.readI64();
21225 
        else:
21226 
          iprot.skip(ftype)
21227 
      elif fid == 5:
21228 
        if ftype == TType.DOUBLE:
21229 
          self.amount = iprot.readDouble();
21230 
        else:
21231 
          iprot.skip(ftype)
21232 
      else:
21233 
        iprot.skip(ftype)
21234 
      iprot.readFieldEnd()
21235 
    iprot.readStructEnd()
21236 
 
21237 
  def write(self, oprot):
21238 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
21239 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
21240 
      return
21241 
    oprot.writeStructBegin('saveEBSSettlementSummary_args')
21242 
    if self.settlementId is not None:
21243 
      oprot.writeFieldBegin('settlementId', TType.I64, 1)
21244 
      oprot.writeI64(self.settlementId)
21245 
      oprot.writeFieldEnd()
21246 
    if self.settlementDate is not None:
21247 
      oprot.writeFieldBegin('settlementDate', TType.I64, 2)
21248 
      oprot.writeI64(self.settlementDate)
21249 
      oprot.writeFieldEnd()
21250 
    if self.transactionDateFrom is not None:
21251 
      oprot.writeFieldBegin('transactionDateFrom', TType.I64, 3)
21252 
      oprot.writeI64(self.transactionDateFrom)
21253 
      oprot.writeFieldEnd()
21254 
    if self.transactionDateTo is not None:
21255 
      oprot.writeFieldBegin('transactionDateTo', TType.I64, 4)
21256 
      oprot.writeI64(self.transactionDateTo)
21257 
      oprot.writeFieldEnd()
21258 
    if self.amount is not None:
21259 
      oprot.writeFieldBegin('amount', TType.DOUBLE, 5)
21260 
      oprot.writeDouble(self.amount)
21261 
      oprot.writeFieldEnd()
21262 
    oprot.writeFieldStop()
21263 
    oprot.writeStructEnd()
21264 
 
21265 
  def validate(self):
21266 
    return
21267 
 
21268 
 
21269 
  def __repr__(self):
21270 
    L = ['%s=%r' % (key, value)
21271 
      for key, value in self.__dict__.iteritems()]
21272 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
21273 
 
21274 
  def __eq__(self, other):
21275 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
21276 
 
21277 
  def __ne__(self, other):
21278 
    return not (self == other)
21279 
 
21280 
class saveEBSSettlementSummary_result:
21281 
  """
21282 
  Attributes:
21283 
   - ex
21284 
  """
21285 
 
21286 
  thrift_spec = (
21287 
    None, # 0
21288 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
21289 
  )
21290 
 
21291 
  def __init__(self, ex=None,):
21292 
    self.ex = ex
21293 
 
21294 
  def read(self, iprot):
21295 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
21296 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
21297 
      return
21298 
    iprot.readStructBegin()
21299 
    while True:
21300 
      (fname, ftype, fid) = iprot.readFieldBegin()
21301 
      if ftype == TType.STOP:
21302 
        break
21303 
      if fid == 1:
21304 
        if ftype == TType.STRUCT:
21305 
          self.ex = TransactionServiceException()
21306 
          self.ex.read(iprot)
21307 
        else:
21308 
          iprot.skip(ftype)
21309 
      else:
21310 
        iprot.skip(ftype)
21311 
      iprot.readFieldEnd()
21312 
    iprot.readStructEnd()
21313 
 
21314 
  def write(self, oprot):
21315 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
21316 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
21317 
      return
21318 
    oprot.writeStructBegin('saveEBSSettlementSummary_result')
21319 
    if self.ex is not None:
21320 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
21321 
      self.ex.write(oprot)
21322 
      oprot.writeFieldEnd()
21323 
    oprot.writeFieldStop()
21324 
    oprot.writeStructEnd()
21325 
 
21326 
  def validate(self):
21327 
    return
21328 
 
21329 
 
21330 
  def __repr__(self):
21331 
    L = ['%s=%r' % (key, value)
21332 
      for key, value in self.__dict__.iteritems()]
21333 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
21334 
 
21335 
  def __eq__(self, other):
21336 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
21337 
 
21338 
  def __ne__(self, other):
21339 
    return not (self == other)
21340 
 
5386 phani.kuma 21341 
class getSettlementForPrepaid_args:
4600 varun.gupt 21342 
  """
21343 
  Attributes:
5189 varun.gupt 21344 
   - referenceId
21345 
   - isRefund
4600 varun.gupt 21346 
  """
21347 
 
21348 
  thrift_spec = (
21349 
    None, # 0
5189 varun.gupt 21350 
    (1, TType.I64, 'referenceId', None, None, ), # 1
5386 phani.kuma 21351 
    (2, TType.BOOL, 'isRefund', None, None, ), # 2
4600 varun.gupt 21352 
  )
21353 
 
5386 phani.kuma 21354 
  def __init__(self, referenceId=None, isRefund=None,):
5189 varun.gupt 21355 
    self.referenceId = referenceId
21356 
    self.isRefund = isRefund
4600 varun.gupt 21357 
 
21358 
  def read(self, iprot):
21359 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
21360 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
21361 
      return
21362 
    iprot.readStructBegin()
21363 
    while True:
21364 
      (fname, ftype, fid) = iprot.readFieldBegin()
21365 
      if ftype == TType.STOP:
21366 
        break
21367 
      if fid == 1:
21368 
        if ftype == TType.I64:
5189 varun.gupt 21369 
          self.referenceId = iprot.readI64();
4600 varun.gupt 21370 
        else:
21371 
          iprot.skip(ftype)
5189 varun.gupt 21372 
      elif fid == 2:
21373 
        if ftype == TType.BOOL:
21374 
          self.isRefund = iprot.readBool();
21375 
        else:
21376 
          iprot.skip(ftype)
4600 varun.gupt 21377 
      else:
21378 
        iprot.skip(ftype)
21379 
      iprot.readFieldEnd()
21380 
    iprot.readStructEnd()
21381 
 
21382 
  def write(self, oprot):
21383 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
21384 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
21385 
      return
5386 phani.kuma 21386 
    oprot.writeStructBegin('getSettlementForPrepaid_args')
5189 varun.gupt 21387 
    if self.referenceId is not None:
21388 
      oprot.writeFieldBegin('referenceId', TType.I64, 1)
21389 
      oprot.writeI64(self.referenceId)
4600 varun.gupt 21390 
      oprot.writeFieldEnd()
5386 phani.kuma 21391 
    if self.isRefund is not None:
21392 
      oprot.writeFieldBegin('isRefund', TType.BOOL, 2)
21393 
      oprot.writeBool(self.isRefund)
5382 varun.gupt 21394 
      oprot.writeFieldEnd()
5386 phani.kuma 21395 
    oprot.writeFieldStop()
21396 
    oprot.writeStructEnd()
21397 
 
21398 
  def validate(self):
21399 
    return
21400 
 
21401 
 
21402 
  def __repr__(self):
21403 
    L = ['%s=%r' % (key, value)
21404 
      for key, value in self.__dict__.iteritems()]
21405 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
21406 
 
21407 
  def __eq__(self, other):
21408 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
21409 
 
21410 
  def __ne__(self, other):
21411 
    return not (self == other)
21412 
 
21413 
class getSettlementForPrepaid_result:
21414 
  """
21415 
  Attributes:
21416 
   - success
21417 
   - ex
21418 
  """
21419 
 
21420 
  thrift_spec = (
21421 
    (0, TType.STRUCT, 'success', (PaymentSettlement, PaymentSettlement.thrift_spec), None, ), # 0
21422 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
21423 
  )
21424 
 
21425 
  def __init__(self, success=None, ex=None,):
21426 
    self.success = success
21427 
    self.ex = ex
21428 
 
21429 
  def read(self, iprot):
21430 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
21431 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
21432 
      return
21433 
    iprot.readStructBegin()
21434 
    while True:
21435 
      (fname, ftype, fid) = iprot.readFieldBegin()
21436 
      if ftype == TType.STOP:
21437 
        break
21438 
      if fid == 0:
21439 
        if ftype == TType.STRUCT:
21440 
          self.success = PaymentSettlement()
21441 
          self.success.read(iprot)
21442 
        else:
21443 
          iprot.skip(ftype)
21444 
      elif fid == 1:
21445 
        if ftype == TType.STRUCT:
21446 
          self.ex = TransactionServiceException()
21447 
          self.ex.read(iprot)
21448 
        else:
21449 
          iprot.skip(ftype)
21450 
      else:
21451 
        iprot.skip(ftype)
21452 
      iprot.readFieldEnd()
21453 
    iprot.readStructEnd()
21454 
 
21455 
  def write(self, oprot):
21456 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
21457 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
21458 
      return
21459 
    oprot.writeStructBegin('getSettlementForPrepaid_result')
21460 
    if self.success is not None:
21461 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
21462 
      self.success.write(oprot)
21463 
      oprot.writeFieldEnd()
21464 
    if self.ex is not None:
21465 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
21466 
      self.ex.write(oprot)
21467 
      oprot.writeFieldEnd()
21468 
    oprot.writeFieldStop()
21469 
    oprot.writeStructEnd()
21470 
 
21471 
  def validate(self):
21472 
    return
21473 
 
21474 
 
21475 
  def __repr__(self):
21476 
    L = ['%s=%r' % (key, value)
21477 
      for key, value in self.__dict__.iteritems()]
21478 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
21479 
 
21480 
  def __eq__(self, other):
21481 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
21482 
 
21483 
  def __ne__(self, other):
21484 
    return not (self == other)
21485 
 
21486 
class getSettlementForCod_args:
21487 
  """
21488 
  Attributes:
21489 
   - orderId
21490 
   - isRefund
21491 
  """
21492 
 
21493 
  thrift_spec = (
21494 
    None, # 0
21495 
    (1, TType.I64, 'orderId', None, None, ), # 1
21496 
    (2, TType.BOOL, 'isRefund', None, None, ), # 2
21497 
  )
21498 
 
21499 
  def __init__(self, orderId=None, isRefund=None,):
21500 
    self.orderId = orderId
21501 
    self.isRefund = isRefund
21502 
 
21503 
  def read(self, iprot):
21504 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
21505 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
21506 
      return
21507 
    iprot.readStructBegin()
21508 
    while True:
21509 
      (fname, ftype, fid) = iprot.readFieldBegin()
21510 
      if ftype == TType.STOP:
21511 
        break
21512 
      if fid == 1:
21513 
        if ftype == TType.I64:
21514 
          self.orderId = iprot.readI64();
21515 
        else:
21516 
          iprot.skip(ftype)
21517 
      elif fid == 2:
21518 
        if ftype == TType.BOOL:
21519 
          self.isRefund = iprot.readBool();
21520 
        else:
21521 
          iprot.skip(ftype)
21522 
      else:
21523 
        iprot.skip(ftype)
21524 
      iprot.readFieldEnd()
21525 
    iprot.readStructEnd()
21526 
 
21527 
  def write(self, oprot):
21528 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
21529 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
21530 
      return
21531 
    oprot.writeStructBegin('getSettlementForCod_args')
21532 
    if self.orderId is not None:
21533 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
21534 
      oprot.writeI64(self.orderId)
21535 
      oprot.writeFieldEnd()
5189 varun.gupt 21536 
    if self.isRefund is not None:
5386 phani.kuma 21537 
      oprot.writeFieldBegin('isRefund', TType.BOOL, 2)
5189 varun.gupt 21538 
      oprot.writeBool(self.isRefund)
21539 
      oprot.writeFieldEnd()
4600 varun.gupt 21540 
    oprot.writeFieldStop()
21541 
    oprot.writeStructEnd()
21542 
 
21543 
  def validate(self):
21544 
    return
21545 
 
21546 
 
21547 
  def __repr__(self):
21548 
    L = ['%s=%r' % (key, value)
21549 
      for key, value in self.__dict__.iteritems()]
21550 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
21551 
 
21552 
  def __eq__(self, other):
21553 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
21554 
 
21555 
  def __ne__(self, other):
21556 
    return not (self == other)
21557 
 
5386 phani.kuma 21558 
class getSettlementForCod_result:
4600 varun.gupt 21559 
  """
21560 
  Attributes:
21561 
   - success
21562 
   - ex
21563 
  """
21564 
 
21565 
  thrift_spec = (
21566 
    (0, TType.STRUCT, 'success', (PaymentSettlement, PaymentSettlement.thrift_spec), None, ), # 0
21567 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
21568 
  )
21569 
 
21570 
  def __init__(self, success=None, ex=None,):
21571 
    self.success = success
21572 
    self.ex = ex
21573 
 
21574 
  def read(self, iprot):
21575 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
21576 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
21577 
      return
21578 
    iprot.readStructBegin()
21579 
    while True:
21580 
      (fname, ftype, fid) = iprot.readFieldBegin()
21581 
      if ftype == TType.STOP:
21582 
        break
21583 
      if fid == 0:
21584 
        if ftype == TType.STRUCT:
21585 
          self.success = PaymentSettlement()
21586 
          self.success.read(iprot)
21587 
        else:
21588 
          iprot.skip(ftype)
21589 
      elif fid == 1:
21590 
        if ftype == TType.STRUCT:
21591 
          self.ex = TransactionServiceException()
21592 
          self.ex.read(iprot)
21593 
        else:
21594 
          iprot.skip(ftype)
21595 
      else:
21596 
        iprot.skip(ftype)
21597 
      iprot.readFieldEnd()
21598 
    iprot.readStructEnd()
21599 
 
21600 
  def write(self, oprot):
21601 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
21602 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
21603 
      return
5386 phani.kuma 21604 
    oprot.writeStructBegin('getSettlementForCod_result')
4600 varun.gupt 21605 
    if self.success is not None:
21606 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
21607 
      self.success.write(oprot)
21608 
      oprot.writeFieldEnd()
21609 
    if self.ex is not None:
21610 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
21611 
      self.ex.write(oprot)
21612 
      oprot.writeFieldEnd()
21613 
    oprot.writeFieldStop()
21614 
    oprot.writeStructEnd()
21615 
 
21616 
  def validate(self):
21617 
    return
21618 
 
21619 
 
21620 
  def __repr__(self):
21621 
    L = ['%s=%r' % (key, value)
21622 
      for key, value in self.__dict__.iteritems()]
21623 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
21624 
 
21625 
  def __eq__(self, other):
21626 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
21627 
 
21628 
  def __ne__(self, other):
21629 
    return not (self == other)
21630 
 
21631 
class getEBSSettlementSummaries_args:
21632 
 
21633 
  thrift_spec = (
21634 
  )
21635 
 
21636 
  def read(self, iprot):
21637 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
21638 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
21639 
      return
21640 
    iprot.readStructBegin()
21641 
    while True:
21642 
      (fname, ftype, fid) = iprot.readFieldBegin()
21643 
      if ftype == TType.STOP:
21644 
        break
21645 
      else:
21646 
        iprot.skip(ftype)
21647 
      iprot.readFieldEnd()
21648 
    iprot.readStructEnd()
21649 
 
21650 
  def write(self, oprot):
21651 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
21652 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
21653 
      return
21654 
    oprot.writeStructBegin('getEBSSettlementSummaries_args')
21655 
    oprot.writeFieldStop()
21656 
    oprot.writeStructEnd()
21657 
 
21658 
  def validate(self):
21659 
    return
21660 
 
21661 
 
21662 
  def __repr__(self):
21663 
    L = ['%s=%r' % (key, value)
21664 
      for key, value in self.__dict__.iteritems()]
21665 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
21666 
 
21667 
  def __eq__(self, other):
21668 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
21669 
 
21670 
  def __ne__(self, other):
21671 
    return not (self == other)
21672 
 
21673 
class getEBSSettlementSummaries_result:
21674 
  """
21675 
  Attributes:
21676 
   - success
21677 
   - ex
21678 
  """
21679 
 
21680 
  thrift_spec = (
21681 
    (0, TType.MAP, 'success', (TType.I64,None,TType.STRING,None), None, ), # 0
21682 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
21683 
  )
21684 
 
21685 
  def __init__(self, success=None, ex=None,):
21686 
    self.success = success
21687 
    self.ex = ex
21688 
 
21689 
  def read(self, iprot):
21690 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
21691 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
21692 
      return
21693 
    iprot.readStructBegin()
21694 
    while True:
21695 
      (fname, ftype, fid) = iprot.readFieldBegin()
21696 
      if ftype == TType.STOP:
21697 
        break
21698 
      if fid == 0:
21699 
        if ftype == TType.MAP:
21700 
          self.success = {}
5481 phani.kuma 21701 
          (_ktype498, _vtype499, _size497 ) = iprot.readMapBegin()
21702 
          for _i501 in xrange(_size497):
21703 
            _key502 = iprot.readI64();
21704 
            _val503 = iprot.readString();
21705 
            self.success[_key502] = _val503
4600 varun.gupt 21706 
          iprot.readMapEnd()
21707 
        else:
21708 
          iprot.skip(ftype)
21709 
      elif fid == 1:
21710 
        if ftype == TType.STRUCT:
21711 
          self.ex = TransactionServiceException()
21712 
          self.ex.read(iprot)
21713 
        else:
21714 
          iprot.skip(ftype)
21715 
      else:
21716 
        iprot.skip(ftype)
21717 
      iprot.readFieldEnd()
21718 
    iprot.readStructEnd()
21719 
 
21720 
  def write(self, oprot):
21721 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
21722 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
21723 
      return
21724 
    oprot.writeStructBegin('getEBSSettlementSummaries_result')
21725 
    if self.success is not None:
21726 
      oprot.writeFieldBegin('success', TType.MAP, 0)
21727 
      oprot.writeMapBegin(TType.I64, TType.STRING, len(self.success))
5481 phani.kuma 21728 
      for kiter504,viter505 in self.success.items():
21729 
        oprot.writeI64(kiter504)
21730 
        oprot.writeString(viter505)
4600 varun.gupt 21731 
      oprot.writeMapEnd()
21732 
      oprot.writeFieldEnd()
21733 
    if self.ex is not None:
21734 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
21735 
      self.ex.write(oprot)
21736 
      oprot.writeFieldEnd()
21737 
    oprot.writeFieldStop()
21738 
    oprot.writeStructEnd()
21739 
 
21740 
  def validate(self):
21741 
    return
21742 
 
21743 
 
21744 
  def __repr__(self):
21745 
    L = ['%s=%r' % (key, value)
21746 
      for key, value in self.__dict__.iteritems()]
21747 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
21748 
 
21749 
  def __eq__(self, other):
21750 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
21751 
 
21752 
  def __ne__(self, other):
21753 
    return not (self == other)
21754 
 
21755 
class markEBSSettlementUploaded_args:
21756 
  """
21757 
  Attributes:
21758 
   - settlementId
21759 
  """
21760 
 
21761 
  thrift_spec = (
21762 
    None, # 0
21763 
    (1, TType.I64, 'settlementId', None, None, ), # 1
21764 
  )
21765 
 
21766 
  def __init__(self, settlementId=None,):
21767 
    self.settlementId = settlementId
21768 
 
21769 
  def read(self, iprot):
21770 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
21771 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
21772 
      return
21773 
    iprot.readStructBegin()
21774 
    while True:
21775 
      (fname, ftype, fid) = iprot.readFieldBegin()
21776 
      if ftype == TType.STOP:
21777 
        break
21778 
      if fid == 1:
21779 
        if ftype == TType.I64:
21780 
          self.settlementId = iprot.readI64();
21781 
        else:
21782 
          iprot.skip(ftype)
21783 
      else:
21784 
        iprot.skip(ftype)
21785 
      iprot.readFieldEnd()
21786 
    iprot.readStructEnd()
21787 
 
21788 
  def write(self, oprot):
21789 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
21790 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
21791 
      return
21792 
    oprot.writeStructBegin('markEBSSettlementUploaded_args')
21793 
    if self.settlementId is not None:
21794 
      oprot.writeFieldBegin('settlementId', TType.I64, 1)
21795 
      oprot.writeI64(self.settlementId)
21796 
      oprot.writeFieldEnd()
21797 
    oprot.writeFieldStop()
21798 
    oprot.writeStructEnd()
21799 
 
21800 
  def validate(self):
21801 
    return
21802 
 
21803 
 
21804 
  def __repr__(self):
21805 
    L = ['%s=%r' % (key, value)
21806 
      for key, value in self.__dict__.iteritems()]
21807 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
21808 
 
21809 
  def __eq__(self, other):
21810 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
21811 
 
21812 
  def __ne__(self, other):
21813 
    return not (self == other)
21814 
 
21815 
class markEBSSettlementUploaded_result:
21816 
  """
21817 
  Attributes:
21818 
   - ex
21819 
  """
21820 
 
21821 
  thrift_spec = (
21822 
    None, # 0
21823 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
21824 
  )
21825 
 
21826 
  def __init__(self, ex=None,):
21827 
    self.ex = ex
21828 
 
21829 
  def read(self, iprot):
21830 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
21831 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
21832 
      return
21833 
    iprot.readStructBegin()
21834 
    while True:
21835 
      (fname, ftype, fid) = iprot.readFieldBegin()
21836 
      if ftype == TType.STOP:
21837 
        break
21838 
      if fid == 1:
21839 
        if ftype == TType.STRUCT:
21840 
          self.ex = TransactionServiceException()
21841 
          self.ex.read(iprot)
21842 
        else:
21843 
          iprot.skip(ftype)
21844 
      else:
21845 
        iprot.skip(ftype)
21846 
      iprot.readFieldEnd()
21847 
    iprot.readStructEnd()
21848 
 
21849 
  def write(self, oprot):
21850 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
21851 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
21852 
      return
21853 
    oprot.writeStructBegin('markEBSSettlementUploaded_result')
21854 
    if self.ex is not None:
21855 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
21856 
      self.ex.write(oprot)
21857 
      oprot.writeFieldEnd()
21858 
    oprot.writeFieldStop()
21859 
    oprot.writeStructEnd()
21860 
 
21861 
  def validate(self):
21862 
    return
21863 
 
21864 
 
21865 
  def __repr__(self):
21866 
    L = ['%s=%r' % (key, value)
21867 
      for key, value in self.__dict__.iteritems()]
21868 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
21869 
 
21870 
  def __eq__(self, other):
21871 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
21872 
 
21873 
  def __ne__(self, other):
21874 
    return not (self == other)
21875 
 
21876 
class getEBSSettlementDate_args:
21877 
  """
21878 
  Attributes:
21879 
   - settlementId
21880 
  """
21881 
 
21882 
  thrift_spec = (
21883 
    None, # 0
21884 
    (1, TType.I64, 'settlementId', None, None, ), # 1
21885 
  )
21886 
 
21887 
  def __init__(self, settlementId=None,):
21888 
    self.settlementId = settlementId
21889 
 
21890 
  def read(self, iprot):
21891 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
21892 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
21893 
      return
21894 
    iprot.readStructBegin()
21895 
    while True:
21896 
      (fname, ftype, fid) = iprot.readFieldBegin()
21897 
      if ftype == TType.STOP:
21898 
        break
21899 
      if fid == 1:
21900 
        if ftype == TType.I64:
21901 
          self.settlementId = iprot.readI64();
21902 
        else:
21903 
          iprot.skip(ftype)
21904 
      else:
21905 
        iprot.skip(ftype)
21906 
      iprot.readFieldEnd()
21907 
    iprot.readStructEnd()
21908 
 
21909 
  def write(self, oprot):
21910 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
21911 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
21912 
      return
21913 
    oprot.writeStructBegin('getEBSSettlementDate_args')
21914 
    if self.settlementId is not None:
21915 
      oprot.writeFieldBegin('settlementId', TType.I64, 1)
21916 
      oprot.writeI64(self.settlementId)
21917 
      oprot.writeFieldEnd()
21918 
    oprot.writeFieldStop()
21919 
    oprot.writeStructEnd()
21920 
 
21921 
  def validate(self):
21922 
    return
21923 
 
21924 
 
21925 
  def __repr__(self):
21926 
    L = ['%s=%r' % (key, value)
21927 
      for key, value in self.__dict__.iteritems()]
21928 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
21929 
 
21930 
  def __eq__(self, other):
21931 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
21932 
 
21933 
  def __ne__(self, other):
21934 
    return not (self == other)
21935 
 
21936 
class getEBSSettlementDate_result:
21937 
  """
21938 
  Attributes:
21939 
   - success
21940 
   - ex
21941 
  """
21942 
 
21943 
  thrift_spec = (
21944 
    (0, TType.I64, 'success', None, None, ), # 0
21945 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
21946 
  )
21947 
 
21948 
  def __init__(self, success=None, ex=None,):
21949 
    self.success = success
21950 
    self.ex = ex
21951 
 
21952 
  def read(self, iprot):
21953 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
21954 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
21955 
      return
21956 
    iprot.readStructBegin()
21957 
    while True:
21958 
      (fname, ftype, fid) = iprot.readFieldBegin()
21959 
      if ftype == TType.STOP:
21960 
        break
21961 
      if fid == 0:
21962 
        if ftype == TType.I64:
21963 
          self.success = iprot.readI64();
21964 
        else:
21965 
          iprot.skip(ftype)
21966 
      elif fid == 1:
21967 
        if ftype == TType.STRUCT:
21968 
          self.ex = TransactionServiceException()
21969 
          self.ex.read(iprot)
21970 
        else:
21971 
          iprot.skip(ftype)
21972 
      else:
21973 
        iprot.skip(ftype)
21974 
      iprot.readFieldEnd()
21975 
    iprot.readStructEnd()
21976 
 
21977 
  def write(self, oprot):
21978 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
21979 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
21980 
      return
21981 
    oprot.writeStructBegin('getEBSSettlementDate_result')
21982 
    if self.success is not None:
21983 
      oprot.writeFieldBegin('success', TType.I64, 0)
21984 
      oprot.writeI64(self.success)
21985 
      oprot.writeFieldEnd()
21986 
    if self.ex is not None:
21987 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
21988 
      self.ex.write(oprot)
21989 
      oprot.writeFieldEnd()
21990 
    oprot.writeFieldStop()
21991 
    oprot.writeStructEnd()
21992 
 
21993 
  def validate(self):
21994 
    return
21995 
 
21996 
 
21997 
  def __repr__(self):
21998 
    L = ['%s=%r' % (key, value)
21999 
      for key, value in self.__dict__.iteritems()]
22000 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
22001 
 
22002 
  def __eq__(self, other):
22003 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
22004 
 
22005 
  def __ne__(self, other):
22006 
    return not (self == other)
4715 varun.gupt 22007 
 
22008 
class getSettlementsByDate_args:
22009 
  """
22010 
  Attributes:
22011 
   - settlementDateFrom
22012 
   - settlementDateTo
22013 
   - isRefund
22014 
  """
22015 
 
22016 
  thrift_spec = (
22017 
    None, # 0
22018 
    (1, TType.I64, 'settlementDateFrom', None, None, ), # 1
22019 
    (2, TType.I64, 'settlementDateTo', None, None, ), # 2
22020 
    (3, TType.BOOL, 'isRefund', None, None, ), # 3
22021 
  )
22022 
 
22023 
  def __init__(self, settlementDateFrom=None, settlementDateTo=None, isRefund=None,):
22024 
    self.settlementDateFrom = settlementDateFrom
22025 
    self.settlementDateTo = settlementDateTo
22026 
    self.isRefund = isRefund
22027 
 
22028 
  def read(self, iprot):
22029 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
22030 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
22031 
      return
22032 
    iprot.readStructBegin()
22033 
    while True:
22034 
      (fname, ftype, fid) = iprot.readFieldBegin()
22035 
      if ftype == TType.STOP:
22036 
        break
22037 
      if fid == 1:
22038 
        if ftype == TType.I64:
22039 
          self.settlementDateFrom = iprot.readI64();
22040 
        else:
22041 
          iprot.skip(ftype)
22042 
      elif fid == 2:
22043 
        if ftype == TType.I64:
22044 
          self.settlementDateTo = iprot.readI64();
22045 
        else:
22046 
          iprot.skip(ftype)
22047 
      elif fid == 3:
22048 
        if ftype == TType.BOOL:
22049 
          self.isRefund = iprot.readBool();
22050 
        else:
22051 
          iprot.skip(ftype)
22052 
      else:
22053 
        iprot.skip(ftype)
22054 
      iprot.readFieldEnd()
22055 
    iprot.readStructEnd()
22056 
 
22057 
  def write(self, oprot):
22058 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
22059 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
22060 
      return
22061 
    oprot.writeStructBegin('getSettlementsByDate_args')
22062 
    if self.settlementDateFrom is not None:
22063 
      oprot.writeFieldBegin('settlementDateFrom', TType.I64, 1)
22064 
      oprot.writeI64(self.settlementDateFrom)
22065 
      oprot.writeFieldEnd()
22066 
    if self.settlementDateTo is not None:
22067 
      oprot.writeFieldBegin('settlementDateTo', TType.I64, 2)
22068 
      oprot.writeI64(self.settlementDateTo)
22069 
      oprot.writeFieldEnd()
22070 
    if self.isRefund is not None:
22071 
      oprot.writeFieldBegin('isRefund', TType.BOOL, 3)
22072 
      oprot.writeBool(self.isRefund)
22073 
      oprot.writeFieldEnd()
22074 
    oprot.writeFieldStop()
22075 
    oprot.writeStructEnd()
22076 
 
22077 
  def validate(self):
22078 
    return
22079 
 
22080 
 
22081 
  def __repr__(self):
22082 
    L = ['%s=%r' % (key, value)
22083 
      for key, value in self.__dict__.iteritems()]
22084 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
22085 
 
22086 
  def __eq__(self, other):
22087 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
22088 
 
22089 
  def __ne__(self, other):
22090 
    return not (self == other)
22091 
 
22092 
class getSettlementsByDate_result:
22093 
  """
22094 
  Attributes:
22095 
   - success
22096 
   - ex
22097 
  """
22098 
 
22099 
  thrift_spec = (
22100 
    (0, TType.LIST, 'success', (TType.STRUCT,(PaymentSettlement, PaymentSettlement.thrift_spec)), None, ), # 0
22101 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
22102 
  )
22103 
 
22104 
  def __init__(self, success=None, ex=None,):
22105 
    self.success = success
22106 
    self.ex = ex
22107 
 
22108 
  def read(self, iprot):
22109 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
22110 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
22111 
      return
22112 
    iprot.readStructBegin()
22113 
    while True:
22114 
      (fname, ftype, fid) = iprot.readFieldBegin()
22115 
      if ftype == TType.STOP:
22116 
        break
22117 
      if fid == 0:
22118 
        if ftype == TType.LIST:
22119 
          self.success = []
5481 phani.kuma 22120 
          (_etype509, _size506) = iprot.readListBegin()
22121 
          for _i510 in xrange(_size506):
22122 
            _elem511 = PaymentSettlement()
22123 
            _elem511.read(iprot)
22124 
            self.success.append(_elem511)
4715 varun.gupt 22125 
          iprot.readListEnd()
22126 
        else:
22127 
          iprot.skip(ftype)
22128 
      elif fid == 1:
22129 
        if ftype == TType.STRUCT:
22130 
          self.ex = TransactionServiceException()
22131 
          self.ex.read(iprot)
22132 
        else:
22133 
          iprot.skip(ftype)
22134 
      else:
22135 
        iprot.skip(ftype)
22136 
      iprot.readFieldEnd()
22137 
    iprot.readStructEnd()
22138 
 
22139 
  def write(self, oprot):
22140 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
22141 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
22142 
      return
22143 
    oprot.writeStructBegin('getSettlementsByDate_result')
22144 
    if self.success is not None:
22145 
      oprot.writeFieldBegin('success', TType.LIST, 0)
22146 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
5481 phani.kuma 22147 
      for iter512 in self.success:
22148 
        iter512.write(oprot)
4715 varun.gupt 22149 
      oprot.writeListEnd()
22150 
      oprot.writeFieldEnd()
22151 
    if self.ex is not None:
22152 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
22153 
      self.ex.write(oprot)
22154 
      oprot.writeFieldEnd()
22155 
    oprot.writeFieldStop()
22156 
    oprot.writeStructEnd()
22157 
 
22158 
  def validate(self):
22159 
    return
22160 
 
22161 
 
22162 
  def __repr__(self):
22163 
    L = ['%s=%r' % (key, value)
22164 
      for key, value in self.__dict__.iteritems()]
22165 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
22166 
 
22167 
  def __eq__(self, other):
22168 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
22169 
 
22170 
  def __ne__(self, other):
22171 
    return not (self == other)
22172 
 
22173 
class getReshippedOrderIds_args:
22174 
  """
22175 
  Attributes:
22176 
   - orderIds
22177 
  """
22178 
 
22179 
  thrift_spec = (
22180 
    None, # 0
22181 
    (1, TType.LIST, 'orderIds', (TType.I64,None), None, ), # 1
22182 
  )
22183 
 
22184 
  def __init__(self, orderIds=None,):
22185 
    self.orderIds = orderIds
22186 
 
22187 
  def read(self, iprot):
22188 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
22189 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
22190 
      return
22191 
    iprot.readStructBegin()
22192 
    while True:
22193 
      (fname, ftype, fid) = iprot.readFieldBegin()
22194 
      if ftype == TType.STOP:
22195 
        break
22196 
      if fid == 1:
22197 
        if ftype == TType.LIST:
22198 
          self.orderIds = []
5481 phani.kuma 22199 
          (_etype516, _size513) = iprot.readListBegin()
22200 
          for _i517 in xrange(_size513):
22201 
            _elem518 = iprot.readI64();
22202 
            self.orderIds.append(_elem518)
4715 varun.gupt 22203 
          iprot.readListEnd()
22204 
        else:
22205 
          iprot.skip(ftype)
22206 
      else:
22207 
        iprot.skip(ftype)
22208 
      iprot.readFieldEnd()
22209 
    iprot.readStructEnd()
22210 
 
22211 
  def write(self, oprot):
22212 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
22213 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
22214 
      return
22215 
    oprot.writeStructBegin('getReshippedOrderIds_args')
22216 
    if self.orderIds is not None:
22217 
      oprot.writeFieldBegin('orderIds', TType.LIST, 1)
22218 
      oprot.writeListBegin(TType.I64, len(self.orderIds))
5481 phani.kuma 22219 
      for iter519 in self.orderIds:
22220 
        oprot.writeI64(iter519)
4715 varun.gupt 22221 
      oprot.writeListEnd()
22222 
      oprot.writeFieldEnd()
22223 
    oprot.writeFieldStop()
22224 
    oprot.writeStructEnd()
22225 
 
22226 
  def validate(self):
22227 
    return
22228 
 
22229 
 
22230 
  def __repr__(self):
22231 
    L = ['%s=%r' % (key, value)
22232 
      for key, value in self.__dict__.iteritems()]
22233 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
22234 
 
22235 
  def __eq__(self, other):
22236 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
22237 
 
22238 
  def __ne__(self, other):
22239 
    return not (self == other)
22240 
 
22241 
class getReshippedOrderIds_result:
22242 
  """
22243 
  Attributes:
22244 
   - success
22245 
   - ex
22246 
  """
22247 
 
22248 
  thrift_spec = (
22249 
    (0, TType.LIST, 'success', (TType.I64,None), None, ), # 0
22250 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
22251 
  )
22252 
 
22253 
  def __init__(self, success=None, ex=None,):
22254 
    self.success = success
22255 
    self.ex = ex
22256 
 
22257 
  def read(self, iprot):
22258 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
22259 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
22260 
      return
22261 
    iprot.readStructBegin()
22262 
    while True:
22263 
      (fname, ftype, fid) = iprot.readFieldBegin()
22264 
      if ftype == TType.STOP:
22265 
        break
22266 
      if fid == 0:
22267 
        if ftype == TType.LIST:
22268 
          self.success = []
5481 phani.kuma 22269 
          (_etype523, _size520) = iprot.readListBegin()
22270 
          for _i524 in xrange(_size520):
22271 
            _elem525 = iprot.readI64();
22272 
            self.success.append(_elem525)
4715 varun.gupt 22273 
          iprot.readListEnd()
22274 
        else:
22275 
          iprot.skip(ftype)
22276 
      elif fid == 1:
22277 
        if ftype == TType.STRUCT:
22278 
          self.ex = TransactionServiceException()
22279 
          self.ex.read(iprot)
22280 
        else:
22281 
          iprot.skip(ftype)
22282 
      else:
22283 
        iprot.skip(ftype)
22284 
      iprot.readFieldEnd()
22285 
    iprot.readStructEnd()
22286 
 
22287 
  def write(self, oprot):
22288 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
22289 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
22290 
      return
22291 
    oprot.writeStructBegin('getReshippedOrderIds_result')
22292 
    if self.success is not None:
22293 
      oprot.writeFieldBegin('success', TType.LIST, 0)
22294 
      oprot.writeListBegin(TType.I64, len(self.success))
5481 phani.kuma 22295 
      for iter526 in self.success:
22296 
        oprot.writeI64(iter526)
4715 varun.gupt 22297 
      oprot.writeListEnd()
22298 
      oprot.writeFieldEnd()
22299 
    if self.ex is not None:
22300 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
22301 
      self.ex.write(oprot)
22302 
      oprot.writeFieldEnd()
22303 
    oprot.writeFieldStop()
22304 
    oprot.writeStructEnd()
22305 
 
22306 
  def validate(self):
22307 
    return
22308 
 
22309 
 
22310 
  def __repr__(self):
22311 
    L = ['%s=%r' % (key, value)
22312 
      for key, value in self.__dict__.iteritems()]
22313 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
22314 
 
22315 
  def __eq__(self, other):
22316 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
22317 
 
22318 
  def __ne__(self, other):
22319 
    return not (self == other)
4757 mandeep.dh 22320 
 
5481 phani.kuma 22321 
class getBilledOrders_args:
4875 varun.gupt 22322 
  """
22323 
  Attributes:
22324 
   - vendorId
5481 phani.kuma 22325 
   - onlyVendorNotPaid
22326 
   - billingDateFrom
22327 
   - billingDateTo
4875 varun.gupt 22328 
  """
22329 
 
22330 
  thrift_spec = (
22331 
    None, # 0
22332 
    (1, TType.I64, 'vendorId', None, None, ), # 1
5481 phani.kuma 22333 
    (2, TType.BOOL, 'onlyVendorNotPaid', None, None, ), # 2
22334 
    (3, TType.I64, 'billingDateFrom', None, None, ), # 3
22335 
    (4, TType.I64, 'billingDateTo', None, None, ), # 4
4875 varun.gupt 22336 
  )
22337 
 
5481 phani.kuma 22338 
  def __init__(self, vendorId=None, onlyVendorNotPaid=None, billingDateFrom=None, billingDateTo=None,):
4875 varun.gupt 22339 
    self.vendorId = vendorId
5481 phani.kuma 22340 
    self.onlyVendorNotPaid = onlyVendorNotPaid
22341 
    self.billingDateFrom = billingDateFrom
22342 
    self.billingDateTo = billingDateTo
4875 varun.gupt 22343 
 
22344 
  def read(self, iprot):
22345 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
22346 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
22347 
      return
22348 
    iprot.readStructBegin()
22349 
    while True:
22350 
      (fname, ftype, fid) = iprot.readFieldBegin()
22351 
      if ftype == TType.STOP:
22352 
        break
22353 
      if fid == 1:
22354 
        if ftype == TType.I64:
22355 
          self.vendorId = iprot.readI64();
22356 
        else:
22357 
          iprot.skip(ftype)
5481 phani.kuma 22358 
      elif fid == 2:
22359 
        if ftype == TType.BOOL:
22360 
          self.onlyVendorNotPaid = iprot.readBool();
22361 
        else:
22362 
          iprot.skip(ftype)
22363 
      elif fid == 3:
22364 
        if ftype == TType.I64:
22365 
          self.billingDateFrom = iprot.readI64();
22366 
        else:
22367 
          iprot.skip(ftype)
22368 
      elif fid == 4:
22369 
        if ftype == TType.I64:
22370 
          self.billingDateTo = iprot.readI64();
22371 
        else:
22372 
          iprot.skip(ftype)
4875 varun.gupt 22373 
      else:
22374 
        iprot.skip(ftype)
22375 
      iprot.readFieldEnd()
22376 
    iprot.readStructEnd()
22377 
 
22378 
  def write(self, oprot):
22379 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
22380 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
22381 
      return
5481 phani.kuma 22382 
    oprot.writeStructBegin('getBilledOrders_args')
4875 varun.gupt 22383 
    if self.vendorId is not None:
22384 
      oprot.writeFieldBegin('vendorId', TType.I64, 1)
22385 
      oprot.writeI64(self.vendorId)
22386 
      oprot.writeFieldEnd()
5481 phani.kuma 22387 
    if self.onlyVendorNotPaid is not None:
22388 
      oprot.writeFieldBegin('onlyVendorNotPaid', TType.BOOL, 2)
22389 
      oprot.writeBool(self.onlyVendorNotPaid)
22390 
      oprot.writeFieldEnd()
22391 
    if self.billingDateFrom is not None:
22392 
      oprot.writeFieldBegin('billingDateFrom', TType.I64, 3)
22393 
      oprot.writeI64(self.billingDateFrom)
22394 
      oprot.writeFieldEnd()
22395 
    if self.billingDateTo is not None:
22396 
      oprot.writeFieldBegin('billingDateTo', TType.I64, 4)
22397 
      oprot.writeI64(self.billingDateTo)
22398 
      oprot.writeFieldEnd()
4875 varun.gupt 22399 
    oprot.writeFieldStop()
22400 
    oprot.writeStructEnd()
22401 
 
22402 
  def validate(self):
22403 
    return
22404 
 
22405 
 
22406 
  def __repr__(self):
22407 
    L = ['%s=%r' % (key, value)
22408 
      for key, value in self.__dict__.iteritems()]
22409 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
22410 
 
22411 
  def __eq__(self, other):
22412 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
22413 
 
22414 
  def __ne__(self, other):
22415 
    return not (self == other)
22416 
 
5481 phani.kuma 22417 
class getBilledOrders_result:
4875 varun.gupt 22418 
  """
22419 
  Attributes:
22420 
   - success
22421 
   - ex
22422 
  """
22423 
 
22424 
  thrift_spec = (
22425 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
22426 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
22427 
  )
22428 
 
22429 
  def __init__(self, success=None, ex=None,):
22430 
    self.success = success
22431 
    self.ex = ex
22432 
 
22433 
  def read(self, iprot):
22434 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
22435 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
22436 
      return
22437 
    iprot.readStructBegin()
22438 
    while True:
22439 
      (fname, ftype, fid) = iprot.readFieldBegin()
22440 
      if ftype == TType.STOP:
22441 
        break
22442 
      if fid == 0:
22443 
        if ftype == TType.LIST:
22444 
          self.success = []
5481 phani.kuma 22445 
          (_etype530, _size527) = iprot.readListBegin()
22446 
          for _i531 in xrange(_size527):
22447 
            _elem532 = Order()
22448 
            _elem532.read(iprot)
22449 
            self.success.append(_elem532)
4875 varun.gupt 22450 
          iprot.readListEnd()
22451 
        else:
22452 
          iprot.skip(ftype)
22453 
      elif fid == 1:
22454 
        if ftype == TType.STRUCT:
22455 
          self.ex = TransactionServiceException()
22456 
          self.ex.read(iprot)
22457 
        else:
22458 
          iprot.skip(ftype)
22459 
      else:
22460 
        iprot.skip(ftype)
22461 
      iprot.readFieldEnd()
22462 
    iprot.readStructEnd()
22463 
 
22464 
  def write(self, oprot):
22465 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
22466 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
22467 
      return
5481 phani.kuma 22468 
    oprot.writeStructBegin('getBilledOrders_result')
4875 varun.gupt 22469 
    if self.success is not None:
22470 
      oprot.writeFieldBegin('success', TType.LIST, 0)
22471 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
5481 phani.kuma 22472 
      for iter533 in self.success:
22473 
        iter533.write(oprot)
4875 varun.gupt 22474 
      oprot.writeListEnd()
22475 
      oprot.writeFieldEnd()
22476 
    if self.ex is not None:
22477 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
22478 
      self.ex.write(oprot)
22479 
      oprot.writeFieldEnd()
22480 
    oprot.writeFieldStop()
22481 
    oprot.writeStructEnd()
22482 
 
22483 
  def validate(self):
22484 
    return
22485 
 
22486 
 
22487 
  def __repr__(self):
22488 
    L = ['%s=%r' % (key, value)
22489 
      for key, value in self.__dict__.iteritems()]
22490 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
22491 
 
22492 
  def __eq__(self, other):
22493 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
22494 
 
22495 
  def __ne__(self, other):
22496 
    return not (self == other)
5031 varun.gupt 22497 
 
22498 
class getStatusDistributionOfOrders_args:
22499 
  """
22500 
  Attributes:
22501 
   - startDate
22502 
   - endDate
22503 
  """
22504 
 
22505 
  thrift_spec = (
22506 
    None, # 0
22507 
    (1, TType.I64, 'startDate', None, None, ), # 1
22508 
    (2, TType.I64, 'endDate', None, None, ), # 2
22509 
  )
22510 
 
22511 
  def __init__(self, startDate=None, endDate=None,):
22512 
    self.startDate = startDate
22513 
    self.endDate = endDate
22514 
 
22515 
  def read(self, iprot):
22516 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
22517 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
22518 
      return
22519 
    iprot.readStructBegin()
22520 
    while True:
22521 
      (fname, ftype, fid) = iprot.readFieldBegin()
22522 
      if ftype == TType.STOP:
22523 
        break
22524 
      if fid == 1:
22525 
        if ftype == TType.I64:
22526 
          self.startDate = iprot.readI64();
22527 
        else:
22528 
          iprot.skip(ftype)
22529 
      elif fid == 2:
22530 
        if ftype == TType.I64:
22531 
          self.endDate = iprot.readI64();
22532 
        else:
22533 
          iprot.skip(ftype)
22534 
      else:
22535 
        iprot.skip(ftype)
22536 
      iprot.readFieldEnd()
22537 
    iprot.readStructEnd()
22538 
 
22539 
  def write(self, oprot):
22540 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
22541 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
22542 
      return
22543 
    oprot.writeStructBegin('getStatusDistributionOfOrders_args')
22544 
    if self.startDate is not None:
22545 
      oprot.writeFieldBegin('startDate', TType.I64, 1)
22546 
      oprot.writeI64(self.startDate)
22547 
      oprot.writeFieldEnd()
22548 
    if self.endDate is not None:
22549 
      oprot.writeFieldBegin('endDate', TType.I64, 2)
22550 
      oprot.writeI64(self.endDate)
22551 
      oprot.writeFieldEnd()
22552 
    oprot.writeFieldStop()
22553 
    oprot.writeStructEnd()
22554 
 
22555 
  def validate(self):
22556 
    return
22557 
 
22558 
 
22559 
  def __repr__(self):
22560 
    L = ['%s=%r' % (key, value)
22561 
      for key, value in self.__dict__.iteritems()]
22562 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
22563 
 
22564 
  def __eq__(self, other):
22565 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
22566 
 
22567 
  def __ne__(self, other):
22568 
    return not (self == other)
22569 
 
22570 
class getStatusDistributionOfOrders_result:
22571 
  """
22572 
  Attributes:
22573 
   - success
22574 
   - ex
22575 
  """
22576 
 
22577 
  thrift_spec = (
22578 
    (0, TType.MAP, 'success', (TType.I64,None,TType.I64,None), None, ), # 0
22579 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
22580 
  )
22581 
 
22582 
  def __init__(self, success=None, ex=None,):
22583 
    self.success = success
22584 
    self.ex = ex
22585 
 
22586 
  def read(self, iprot):
22587 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
22588 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
22589 
      return
22590 
    iprot.readStructBegin()
22591 
    while True:
22592 
      (fname, ftype, fid) = iprot.readFieldBegin()
22593 
      if ftype == TType.STOP:
22594 
        break
22595 
      if fid == 0:
22596 
        if ftype == TType.MAP:
22597 
          self.success = {}
5481 phani.kuma 22598 
          (_ktype535, _vtype536, _size534 ) = iprot.readMapBegin()
22599 
          for _i538 in xrange(_size534):
22600 
            _key539 = iprot.readI64();
22601 
            _val540 = iprot.readI64();
22602 
            self.success[_key539] = _val540
5031 varun.gupt 22603 
          iprot.readMapEnd()
22604 
        else:
22605 
          iprot.skip(ftype)
22606 
      elif fid == 1:
22607 
        if ftype == TType.STRUCT:
22608 
          self.ex = TransactionServiceException()
22609 
          self.ex.read(iprot)
22610 
        else:
22611 
          iprot.skip(ftype)
22612 
      else:
22613 
        iprot.skip(ftype)
22614 
      iprot.readFieldEnd()
22615 
    iprot.readStructEnd()
22616 
 
22617 
  def write(self, oprot):
22618 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
22619 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
22620 
      return
22621 
    oprot.writeStructBegin('getStatusDistributionOfOrders_result')
22622 
    if self.success is not None:
22623 
      oprot.writeFieldBegin('success', TType.MAP, 0)
22624 
      oprot.writeMapBegin(TType.I64, TType.I64, len(self.success))
5481 phani.kuma 22625 
      for kiter541,viter542 in self.success.items():
22626 
        oprot.writeI64(kiter541)
22627 
        oprot.writeI64(viter542)
5031 varun.gupt 22628 
      oprot.writeMapEnd()
22629 
      oprot.writeFieldEnd()
22630 
    if self.ex is not None:
22631 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
22632 
      self.ex.write(oprot)
22633 
      oprot.writeFieldEnd()
22634 
    oprot.writeFieldStop()
22635 
    oprot.writeStructEnd()
22636 
 
22637 
  def validate(self):
22638 
    return
22639 
 
22640 
 
22641 
  def __repr__(self):
22642 
    L = ['%s=%r' % (key, value)
22643 
      for key, value in self.__dict__.iteritems()]
22644 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
22645 
 
22646 
  def __eq__(self, other):
22647 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
22648 
 
22649 
  def __ne__(self, other):
22650 
    return not (self == other)
5067 varun.gupt 22651 
 
22652 
class getOrderIdsForStatus_args:
22653 
  """
22654 
  Attributes:
22655 
   - status
22656 
   - startDatetime
22657 
   - endDatetime
22658 
  """
22659 
 
22660 
  thrift_spec = (
22661 
    None, # 0
22662 
    (1, TType.I64, 'status', None, None, ), # 1
22663 
    (2, TType.I64, 'startDatetime', None, None, ), # 2
22664 
    (3, TType.I64, 'endDatetime', None, None, ), # 3
22665 
  )
22666 
 
22667 
  def __init__(self, status=None, startDatetime=None, endDatetime=None,):
22668 
    self.status = status
22669 
    self.startDatetime = startDatetime
22670 
    self.endDatetime = endDatetime
22671 
 
22672 
  def read(self, iprot):
22673 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
22674 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
22675 
      return
22676 
    iprot.readStructBegin()
22677 
    while True:
22678 
      (fname, ftype, fid) = iprot.readFieldBegin()
22679 
      if ftype == TType.STOP:
22680 
        break
22681 
      if fid == 1:
22682 
        if ftype == TType.I64:
22683 
          self.status = iprot.readI64();
22684 
        else:
22685 
          iprot.skip(ftype)
22686 
      elif fid == 2:
22687 
        if ftype == TType.I64:
22688 
          self.startDatetime = iprot.readI64();
22689 
        else:
22690 
          iprot.skip(ftype)
22691 
      elif fid == 3:
22692 
        if ftype == TType.I64:
22693 
          self.endDatetime = iprot.readI64();
22694 
        else:
22695 
          iprot.skip(ftype)
22696 
      else:
22697 
        iprot.skip(ftype)
22698 
      iprot.readFieldEnd()
22699 
    iprot.readStructEnd()
22700 
 
22701 
  def write(self, oprot):
22702 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
22703 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
22704 
      return
22705 
    oprot.writeStructBegin('getOrderIdsForStatus_args')
22706 
    if self.status is not None:
22707 
      oprot.writeFieldBegin('status', TType.I64, 1)
22708 
      oprot.writeI64(self.status)
22709 
      oprot.writeFieldEnd()
22710 
    if self.startDatetime is not None:
22711 
      oprot.writeFieldBegin('startDatetime', TType.I64, 2)
22712 
      oprot.writeI64(self.startDatetime)
22713 
      oprot.writeFieldEnd()
22714 
    if self.endDatetime is not None:
22715 
      oprot.writeFieldBegin('endDatetime', TType.I64, 3)
22716 
      oprot.writeI64(self.endDatetime)
22717 
      oprot.writeFieldEnd()
22718 
    oprot.writeFieldStop()
22719 
    oprot.writeStructEnd()
22720 
 
22721 
  def validate(self):
22722 
    return
22723 
 
22724 
 
22725 
  def __repr__(self):
22726 
    L = ['%s=%r' % (key, value)
22727 
      for key, value in self.__dict__.iteritems()]
22728 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
22729 
 
22730 
  def __eq__(self, other):
22731 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
22732 
 
22733 
  def __ne__(self, other):
22734 
    return not (self == other)
22735 
 
22736 
class getOrderIdsForStatus_result:
22737 
  """
22738 
  Attributes:
22739 
   - success
22740 
   - ex
22741 
  """
22742 
 
22743 
  thrift_spec = (
22744 
    (0, TType.LIST, 'success', (TType.I64,None), None, ), # 0
22745 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
22746 
  )
22747 
 
22748 
  def __init__(self, success=None, ex=None,):
22749 
    self.success = success
22750 
    self.ex = ex
22751 
 
22752 
  def read(self, iprot):
22753 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
22754 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
22755 
      return
22756 
    iprot.readStructBegin()
22757 
    while True:
22758 
      (fname, ftype, fid) = iprot.readFieldBegin()
22759 
      if ftype == TType.STOP:
22760 
        break
22761 
      if fid == 0:
22762 
        if ftype == TType.LIST:
22763 
          self.success = []
5481 phani.kuma 22764 
          (_etype546, _size543) = iprot.readListBegin()
22765 
          for _i547 in xrange(_size543):
22766 
            _elem548 = iprot.readI64();
22767 
            self.success.append(_elem548)
5067 varun.gupt 22768 
          iprot.readListEnd()
22769 
        else:
22770 
          iprot.skip(ftype)
22771 
      elif fid == 1:
22772 
        if ftype == TType.STRUCT:
22773 
          self.ex = TransactionServiceException()
22774 
          self.ex.read(iprot)
22775 
        else:
22776 
          iprot.skip(ftype)
22777 
      else:
22778 
        iprot.skip(ftype)
22779 
      iprot.readFieldEnd()
22780 
    iprot.readStructEnd()
22781 
 
22782 
  def write(self, oprot):
22783 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
22784 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
22785 
      return
22786 
    oprot.writeStructBegin('getOrderIdsForStatus_result')
22787 
    if self.success is not None:
22788 
      oprot.writeFieldBegin('success', TType.LIST, 0)
22789 
      oprot.writeListBegin(TType.I64, len(self.success))
5481 phani.kuma 22790 
      for iter549 in self.success:
22791 
        oprot.writeI64(iter549)
5067 varun.gupt 22792 
      oprot.writeListEnd()
22793 
      oprot.writeFieldEnd()
22794 
    if self.ex is not None:
22795 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
22796 
      self.ex.write(oprot)
22797 
      oprot.writeFieldEnd()
22798 
    oprot.writeFieldStop()
22799 
    oprot.writeStructEnd()
22800 
 
22801 
  def validate(self):
22802 
    return
22803 
 
22804 
 
22805 
  def __repr__(self):
22806 
    L = ['%s=%r' % (key, value)
22807 
      for key, value in self.__dict__.iteritems()]
22808 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
22809 
 
22810 
  def __eq__(self, other):
22811 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
22812 
 
22813 
  def __ne__(self, other):
22814 
    return not (self == other)
5099 varun.gupt 22815 
 
5348 anupam.sin 22816 
class updateCODAgent_args:
22817 
  """
22818 
  Attributes:
22819 
   - agent
22820 
   - orderId
22821 
  """
22822 
 
22823 
  thrift_spec = (
22824 
    None, # 0
22825 
    (1, TType.STRING, 'agent', None, None, ), # 1
22826 
    (2, TType.I64, 'orderId', None, None, ), # 2
22827 
  )
22828 
 
22829 
  def __init__(self, agent=None, orderId=None,):
22830 
    self.agent = agent
22831 
    self.orderId = orderId
22832 
 
22833 
  def read(self, iprot):
22834 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
22835 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
22836 
      return
22837 
    iprot.readStructBegin()
22838 
    while True:
22839 
      (fname, ftype, fid) = iprot.readFieldBegin()
22840 
      if ftype == TType.STOP:
22841 
        break
22842 
      if fid == 1:
22843 
        if ftype == TType.STRING:
22844 
          self.agent = iprot.readString();
22845 
        else:
22846 
          iprot.skip(ftype)
22847 
      elif fid == 2:
22848 
        if ftype == TType.I64:
22849 
          self.orderId = iprot.readI64();
22850 
        else:
22851 
          iprot.skip(ftype)
22852 
      else:
22853 
        iprot.skip(ftype)
22854 
      iprot.readFieldEnd()
22855 
    iprot.readStructEnd()
22856 
 
22857 
  def write(self, oprot):
22858 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
22859 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
22860 
      return
22861 
    oprot.writeStructBegin('updateCODAgent_args')
22862 
    if self.agent is not None:
22863 
      oprot.writeFieldBegin('agent', TType.STRING, 1)
22864 
      oprot.writeString(self.agent)
22865 
      oprot.writeFieldEnd()
22866 
    if self.orderId is not None:
22867 
      oprot.writeFieldBegin('orderId', TType.I64, 2)
22868 
      oprot.writeI64(self.orderId)
22869 
      oprot.writeFieldEnd()
22870 
    oprot.writeFieldStop()
22871 
    oprot.writeStructEnd()
22872 
 
22873 
  def validate(self):
22874 
    return
22875 
 
22876 
 
22877 
  def __repr__(self):
22878 
    L = ['%s=%r' % (key, value)
22879 
      for key, value in self.__dict__.iteritems()]
22880 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
22881 
 
22882 
  def __eq__(self, other):
22883 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
22884 
 
22885 
  def __ne__(self, other):
22886 
    return not (self == other)
22887 
 
22888 
class updateCODAgent_result:
22889 
  """
22890 
  Attributes:
22891 
   - ex
22892 
  """
22893 
 
22894 
  thrift_spec = (
22895 
    None, # 0
22896 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
22897 
  )
22898 
 
22899 
  def __init__(self, ex=None,):
22900 
    self.ex = ex
22901 
 
22902 
  def read(self, iprot):
22903 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
22904 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
22905 
      return
22906 
    iprot.readStructBegin()
22907 
    while True:
22908 
      (fname, ftype, fid) = iprot.readFieldBegin()
22909 
      if ftype == TType.STOP:
22910 
        break
22911 
      if fid == 1:
22912 
        if ftype == TType.STRUCT:
22913 
          self.ex = TransactionServiceException()
22914 
          self.ex.read(iprot)
22915 
        else:
22916 
          iprot.skip(ftype)
22917 
      else:
22918 
        iprot.skip(ftype)
22919 
      iprot.readFieldEnd()
22920 
    iprot.readStructEnd()
22921 
 
22922 
  def write(self, oprot):
22923 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
22924 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
22925 
      return
22926 
    oprot.writeStructBegin('updateCODAgent_result')
22927 
    if self.ex is not None:
22928 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
22929 
      self.ex.write(oprot)
22930 
      oprot.writeFieldEnd()
22931 
    oprot.writeFieldStop()
22932 
    oprot.writeStructEnd()
22933 
 
22934 
  def validate(self):
22935 
    return
22936 
 
22937 
 
22938 
  def __repr__(self):
22939 
    L = ['%s=%r' % (key, value)
22940 
      for key, value in self.__dict__.iteritems()]
22941 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
22942 
 
22943 
  def __eq__(self, other):
22944 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
22945 
 
22946 
  def __ne__(self, other):
22947 
    return not (self == other)
22948 
 
5099 varun.gupt 22949 
class updateOrderAsPaidToVendor_args:
22950 
  """
22951 
  Attributes:
22952 
   - orderId
22953 
  """
22954 
 
22955 
  thrift_spec = (
22956 
    None, # 0
22957 
    (1, TType.I64, 'orderId', None, None, ), # 1
22958 
  )
22959 
 
22960 
  def __init__(self, orderId=None,):
22961 
    self.orderId = orderId
22962 
 
22963 
  def read(self, iprot):
22964 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
22965 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
22966 
      return
22967 
    iprot.readStructBegin()
22968 
    while True:
22969 
      (fname, ftype, fid) = iprot.readFieldBegin()
22970 
      if ftype == TType.STOP:
22971 
        break
22972 
      if fid == 1:
22973 
        if ftype == TType.I64:
22974 
          self.orderId = iprot.readI64();
22975 
        else:
22976 
          iprot.skip(ftype)
22977 
      else:
22978 
        iprot.skip(ftype)
22979 
      iprot.readFieldEnd()
22980 
    iprot.readStructEnd()
22981 
 
22982 
  def write(self, oprot):
22983 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
22984 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
22985 
      return
22986 
    oprot.writeStructBegin('updateOrderAsPaidToVendor_args')
22987 
    if self.orderId is not None:
22988 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
22989 
      oprot.writeI64(self.orderId)
22990 
      oprot.writeFieldEnd()
22991 
    oprot.writeFieldStop()
22992 
    oprot.writeStructEnd()
22993 
 
22994 
  def validate(self):
22995 
    return
22996 
 
22997 
 
22998 
  def __repr__(self):
22999 
    L = ['%s=%r' % (key, value)
23000 
      for key, value in self.__dict__.iteritems()]
23001 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
23002 
 
23003 
  def __eq__(self, other):
23004 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
23005 
 
23006 
  def __ne__(self, other):
23007 
    return not (self == other)
23008 
 
23009 
class updateOrderAsPaidToVendor_result:
23010 
  """
23011 
  Attributes:
23012 
   - ex
23013 
  """
23014 
 
23015 
  thrift_spec = (
23016 
    None, # 0
23017 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
23018 
  )
23019 
 
23020 
  def __init__(self, ex=None,):
23021 
    self.ex = ex
23022 
 
23023 
  def read(self, iprot):
23024 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
23025 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
23026 
      return
23027 
    iprot.readStructBegin()
23028 
    while True:
23029 
      (fname, ftype, fid) = iprot.readFieldBegin()
23030 
      if ftype == TType.STOP:
23031 
        break
23032 
      if fid == 1:
23033 
        if ftype == TType.STRUCT:
23034 
          self.ex = TransactionServiceException()
23035 
          self.ex.read(iprot)
23036 
        else:
23037 
          iprot.skip(ftype)
23038 
      else:
23039 
        iprot.skip(ftype)
23040 
      iprot.readFieldEnd()
23041 
    iprot.readStructEnd()
23042 
 
23043 
  def write(self, oprot):
23044 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
23045 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
23046 
      return
23047 
    oprot.writeStructBegin('updateOrderAsPaidToVendor_result')
23048 
    if self.ex is not None:
23049 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
23050 
      self.ex.write(oprot)
23051 
      oprot.writeFieldEnd()
23052 
    oprot.writeFieldStop()
23053 
    oprot.writeStructEnd()
23054 
 
23055 
  def validate(self):
23056 
    return
23057 
 
23058 
 
23059 
  def __repr__(self):
23060 
    L = ['%s=%r' % (key, value)
23061 
      for key, value in self.__dict__.iteritems()]
23062 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
23063 
 
23064 
  def __eq__(self, other):
23065 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
23066 
 
23067 
  def __ne__(self, other):
23068 
    return not (self == other)
5208 varun.gupt 23069 
 
5386 phani.kuma 23070 
class updateOrderOnlyAsPaidToVendor_args:
23071 
  """
23072 
  Attributes:
23073 
   - orderId
23074 
  """
23075 
 
23076 
  thrift_spec = (
23077 
    None, # 0
23078 
    (1, TType.I64, 'orderId', None, None, ), # 1
23079 
  )
23080 
 
23081 
  def __init__(self, orderId=None,):
23082 
    self.orderId = orderId
23083 
 
23084 
  def read(self, iprot):
23085 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
23086 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
23087 
      return
23088 
    iprot.readStructBegin()
23089 
    while True:
23090 
      (fname, ftype, fid) = iprot.readFieldBegin()
23091 
      if ftype == TType.STOP:
23092 
        break
23093 
      if fid == 1:
23094 
        if ftype == TType.I64:
23095 
          self.orderId = iprot.readI64();
23096 
        else:
23097 
          iprot.skip(ftype)
23098 
      else:
23099 
        iprot.skip(ftype)
23100 
      iprot.readFieldEnd()
23101 
    iprot.readStructEnd()
23102 
 
23103 
  def write(self, oprot):
23104 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
23105 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
23106 
      return
23107 
    oprot.writeStructBegin('updateOrderOnlyAsPaidToVendor_args')
23108 
    if self.orderId is not None:
23109 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
23110 
      oprot.writeI64(self.orderId)
23111 
      oprot.writeFieldEnd()
23112 
    oprot.writeFieldStop()
23113 
    oprot.writeStructEnd()
23114 
 
23115 
  def validate(self):
23116 
    return
23117 
 
23118 
 
23119 
  def __repr__(self):
23120 
    L = ['%s=%r' % (key, value)
23121 
      for key, value in self.__dict__.iteritems()]
23122 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
23123 
 
23124 
  def __eq__(self, other):
23125 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
23126 
 
23127 
  def __ne__(self, other):
23128 
    return not (self == other)
23129 
 
23130 
class updateOrderOnlyAsPaidToVendor_result:
23131 
  """
23132 
  Attributes:
23133 
   - ex
23134 
  """
23135 
 
23136 
  thrift_spec = (
23137 
    None, # 0
23138 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
23139 
  )
23140 
 
23141 
  def __init__(self, ex=None,):
23142 
    self.ex = ex
23143 
 
23144 
  def read(self, iprot):
23145 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
23146 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
23147 
      return
23148 
    iprot.readStructBegin()
23149 
    while True:
23150 
      (fname, ftype, fid) = iprot.readFieldBegin()
23151 
      if ftype == TType.STOP:
23152 
        break
23153 
      if fid == 1:
23154 
        if ftype == TType.STRUCT:
23155 
          self.ex = TransactionServiceException()
23156 
          self.ex.read(iprot)
23157 
        else:
23158 
          iprot.skip(ftype)
23159 
      else:
23160 
        iprot.skip(ftype)
23161 
      iprot.readFieldEnd()
23162 
    iprot.readStructEnd()
23163 
 
23164 
  def write(self, oprot):
23165 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
23166 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
23167 
      return
23168 
    oprot.writeStructBegin('updateOrderOnlyAsPaidToVendor_result')
23169 
    if self.ex is not None:
23170 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
23171 
      self.ex.write(oprot)
23172 
      oprot.writeFieldEnd()
23173 
    oprot.writeFieldStop()
23174 
    oprot.writeStructEnd()
23175 
 
23176 
  def validate(self):
23177 
    return
23178 
 
23179 
 
23180 
  def __repr__(self):
23181 
    L = ['%s=%r' % (key, value)
23182 
      for key, value in self.__dict__.iteritems()]
23183 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
23184 
 
23185 
  def __eq__(self, other):
23186 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
23187 
 
23188 
  def __ne__(self, other):
23189 
    return not (self == other)
23190 
 
5208 varun.gupt 23191 
class getRefundedOrdersMarkedPaid_args:
23192 
 
23193 
  thrift_spec = (
23194 
  )
23195 
 
23196 
  def read(self, iprot):
23197 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
23198 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
23199 
      return
23200 
    iprot.readStructBegin()
23201 
    while True:
23202 
      (fname, ftype, fid) = iprot.readFieldBegin()
23203 
      if ftype == TType.STOP:
23204 
        break
23205 
      else:
23206 
        iprot.skip(ftype)
23207 
      iprot.readFieldEnd()
23208 
    iprot.readStructEnd()
23209 
 
23210 
  def write(self, oprot):
23211 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
23212 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
23213 
      return
23214 
    oprot.writeStructBegin('getRefundedOrdersMarkedPaid_args')
23215 
    oprot.writeFieldStop()
23216 
    oprot.writeStructEnd()
23217 
 
23218 
  def validate(self):
23219 
    return
23220 
 
23221 
 
23222 
  def __repr__(self):
23223 
    L = ['%s=%r' % (key, value)
23224 
      for key, value in self.__dict__.iteritems()]
23225 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
23226 
 
23227 
  def __eq__(self, other):
23228 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
23229 
 
23230 
  def __ne__(self, other):
23231 
    return not (self == other)
23232 
 
23233 
class getRefundedOrdersMarkedPaid_result:
23234 
  """
23235 
  Attributes:
23236 
   - success
23237 
   - ex
23238 
  """
23239 
 
23240 
  thrift_spec = (
23241 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
23242 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
23243 
  )
23244 
 
23245 
  def __init__(self, success=None, ex=None,):
23246 
    self.success = success
23247 
    self.ex = ex
23248 
 
23249 
  def read(self, iprot):
23250 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
23251 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
23252 
      return
23253 
    iprot.readStructBegin()
23254 
    while True:
23255 
      (fname, ftype, fid) = iprot.readFieldBegin()
23256 
      if ftype == TType.STOP:
23257 
        break
23258 
      if fid == 0:
23259 
        if ftype == TType.LIST:
23260 
          self.success = []
5481 phani.kuma 23261 
          (_etype553, _size550) = iprot.readListBegin()
23262 
          for _i554 in xrange(_size550):
23263 
            _elem555 = Order()
23264 
            _elem555.read(iprot)
23265 
            self.success.append(_elem555)
5208 varun.gupt 23266 
          iprot.readListEnd()
23267 
        else:
23268 
          iprot.skip(ftype)
23269 
      elif fid == 1:
23270 
        if ftype == TType.STRUCT:
23271 
          self.ex = TransactionServiceException()
23272 
          self.ex.read(iprot)
23273 
        else:
23274 
          iprot.skip(ftype)
23275 
      else:
23276 
        iprot.skip(ftype)
23277 
      iprot.readFieldEnd()
23278 
    iprot.readStructEnd()
23279 
 
23280 
  def write(self, oprot):
23281 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
23282 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
23283 
      return
23284 
    oprot.writeStructBegin('getRefundedOrdersMarkedPaid_result')
23285 
    if self.success is not None:
23286 
      oprot.writeFieldBegin('success', TType.LIST, 0)
23287 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
5481 phani.kuma 23288 
      for iter556 in self.success:
23289 
        iter556.write(oprot)
5208 varun.gupt 23290 
      oprot.writeListEnd()
23291 
      oprot.writeFieldEnd()
23292 
    if self.ex is not None:
23293 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
23294 
      self.ex.write(oprot)
23295 
      oprot.writeFieldEnd()
23296 
    oprot.writeFieldStop()
23297 
    oprot.writeStructEnd()
23298 
 
23299 
  def validate(self):
23300 
    return
23301 
 
23302 
 
23303 
  def __repr__(self):
23304 
    L = ['%s=%r' % (key, value)
23305 
      for key, value in self.__dict__.iteritems()]
23306 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
23307 
 
23308 
  def __eq__(self, other):
23309 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
23310 
 
23311 
  def __ne__(self, other):
23312 
    return not (self == other)
5447 anupam.sin 23313 
 
23314 
class getAllVerificationAgents_args:
23315 
  """
23316 
  Attributes:
23317 
   - minOrderId
23318 
   - maxOrderId
23319 
  """
23320 
 
23321 
  thrift_spec = (
23322 
    None, # 0
23323 
    (1, TType.I64, 'minOrderId', None, None, ), # 1
23324 
    (2, TType.I64, 'maxOrderId', None, None, ), # 2
23325 
  )
23326 
 
23327 
  def __init__(self, minOrderId=None, maxOrderId=None,):
23328 
    self.minOrderId = minOrderId
23329 
    self.maxOrderId = maxOrderId
23330 
 
23331 
  def read(self, iprot):
23332 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
23333 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
23334 
      return
23335 
    iprot.readStructBegin()
23336 
    while True:
23337 
      (fname, ftype, fid) = iprot.readFieldBegin()
23338 
      if ftype == TType.STOP:
23339 
        break
23340 
      if fid == 1:
23341 
        if ftype == TType.I64:
23342 
          self.minOrderId = iprot.readI64();
23343 
        else:
23344 
          iprot.skip(ftype)
23345 
      elif fid == 2:
23346 
        if ftype == TType.I64:
23347 
          self.maxOrderId = iprot.readI64();
23348 
        else:
23349 
          iprot.skip(ftype)
23350 
      else:
23351 
        iprot.skip(ftype)
23352 
      iprot.readFieldEnd()
23353 
    iprot.readStructEnd()
23354 
 
23355 
  def write(self, oprot):
23356 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
23357 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
23358 
      return
23359 
    oprot.writeStructBegin('getAllVerificationAgents_args')
23360 
    if self.minOrderId is not None:
23361 
      oprot.writeFieldBegin('minOrderId', TType.I64, 1)
23362 
      oprot.writeI64(self.minOrderId)
23363 
      oprot.writeFieldEnd()
23364 
    if self.maxOrderId is not None:
23365 
      oprot.writeFieldBegin('maxOrderId', TType.I64, 2)
23366 
      oprot.writeI64(self.maxOrderId)
23367 
      oprot.writeFieldEnd()
23368 
    oprot.writeFieldStop()
23369 
    oprot.writeStructEnd()
23370 
 
23371 
  def validate(self):
23372 
    return
23373 
 
23374 
 
23375 
  def __repr__(self):
23376 
    L = ['%s=%r' % (key, value)
23377 
      for key, value in self.__dict__.iteritems()]
23378 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
23379 
 
23380 
  def __eq__(self, other):
23381 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
23382 
 
23383 
  def __ne__(self, other):
23384 
    return not (self == other)
23385 
 
23386 
class getAllVerificationAgents_result:
23387 
  """
23388 
  Attributes:
23389 
   - success
23390 
  """
23391 
 
23392 
  thrift_spec = (
23393 
    (0, TType.LIST, 'success', (TType.STRUCT,(CODVerificationAgent, CODVerificationAgent.thrift_spec)), None, ), # 0
23394 
  )
23395 
 
23396 
  def __init__(self, success=None,):
23397 
    self.success = success
23398 
 
23399 
  def read(self, iprot):
23400 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
23401 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
23402 
      return
23403 
    iprot.readStructBegin()
23404 
    while True:
23405 
      (fname, ftype, fid) = iprot.readFieldBegin()
23406 
      if ftype == TType.STOP:
23407 
        break
23408 
      if fid == 0:
23409 
        if ftype == TType.LIST:
23410 
          self.success = []
5481 phani.kuma 23411 
          (_etype560, _size557) = iprot.readListBegin()
23412 
          for _i561 in xrange(_size557):
23413 
            _elem562 = CODVerificationAgent()
23414 
            _elem562.read(iprot)
23415 
            self.success.append(_elem562)
5447 anupam.sin 23416 
          iprot.readListEnd()
23417 
        else:
23418 
          iprot.skip(ftype)
23419 
      else:
23420 
        iprot.skip(ftype)
23421 
      iprot.readFieldEnd()
23422 
    iprot.readStructEnd()
23423 
 
23424 
  def write(self, oprot):
23425 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
23426 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
23427 
      return
23428 
    oprot.writeStructBegin('getAllVerificationAgents_result')
23429 
    if self.success is not None:
23430 
      oprot.writeFieldBegin('success', TType.LIST, 0)
23431 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
5481 phani.kuma 23432 
      for iter563 in self.success:
23433 
        iter563.write(oprot)
5447 anupam.sin 23434 
      oprot.writeListEnd()
23435 
      oprot.writeFieldEnd()
23436 
    oprot.writeFieldStop()
23437 
    oprot.writeStructEnd()
23438 
 
23439 
  def validate(self):
23440 
    return
23441 
 
23442 
 
23443 
  def __repr__(self):
23444 
    L = ['%s=%r' % (key, value)
23445 
      for key, value in self.__dict__.iteritems()]
23446 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
23447 
 
23448 
  def __eq__(self, other):
23449 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
23450 
 
23451 
  def __ne__(self, other):
23452 
    return not (self == other)
5527 anupam.sin 23453 
 
23454 
class getAllAttributesForOrderId_args:
23455 
  """
23456 
  Attributes:
23457 
   - orderId
23458 
  """
23459 
 
23460 
  thrift_spec = (
23461 
    None, # 0
23462 
    (1, TType.I64, 'orderId', None, None, ), # 1
23463 
  )
23464 
 
23465 
  def __init__(self, orderId=None,):
23466 
    self.orderId = orderId
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.orderId = iprot.readI64();
23480 
        else:
23481 
          iprot.skip(ftype)
23482 
      else:
23483 
        iprot.skip(ftype)
23484 
      iprot.readFieldEnd()
23485 
    iprot.readStructEnd()
23486 
 
23487 
  def write(self, oprot):
23488 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
23489 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
23490 
      return
23491 
    oprot.writeStructBegin('getAllAttributesForOrderId_args')
23492 
    if self.orderId is not None:
23493 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
23494 
      oprot.writeI64(self.orderId)
23495 
      oprot.writeFieldEnd()
23496 
    oprot.writeFieldStop()
23497 
    oprot.writeStructEnd()
23498 
 
23499 
  def validate(self):
23500 
    return
23501 
 
23502 
 
23503 
  def __repr__(self):
23504 
    L = ['%s=%r' % (key, value)
23505 
      for key, value in self.__dict__.iteritems()]
23506 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
23507 
 
23508 
  def __eq__(self, other):
23509 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
23510 
 
23511 
  def __ne__(self, other):
23512 
    return not (self == other)
23513 
 
23514 
class getAllAttributesForOrderId_result:
23515 
  """
23516 
  Attributes:
23517 
   - success
23518 
  """
23519 
 
23520 
  thrift_spec = (
23521 
    (0, TType.LIST, 'success', (TType.STRUCT,(Attribute, Attribute.thrift_spec)), None, ), # 0
23522 
  )
23523 
 
23524 
  def __init__(self, success=None,):
23525 
    self.success = success
23526 
 
23527 
  def read(self, iprot):
23528 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
23529 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
23530 
      return
23531 
    iprot.readStructBegin()
23532 
    while True:
23533 
      (fname, ftype, fid) = iprot.readFieldBegin()
23534 
      if ftype == TType.STOP:
23535 
        break
23536 
      if fid == 0:
23537 
        if ftype == TType.LIST:
23538 
          self.success = []
23539 
          (_etype560, _size557) = iprot.readListBegin()
23540 
          for _i561 in xrange(_size557):
23541 
            _elem562 = Attribute()
23542 
            _elem562.read(iprot)
23543 
            self.success.append(_elem562)
23544 
          iprot.readListEnd()
23545 
        else:
23546 
          iprot.skip(ftype)
23547 
      else:
23548 
        iprot.skip(ftype)
23549 
      iprot.readFieldEnd()
23550 
    iprot.readStructEnd()
23551 
 
23552 
  def write(self, oprot):
23553 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
23554 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
23555 
      return
23556 
    oprot.writeStructBegin('getAllAttributesForOrderId_result')
23557 
    if self.success is not None:
23558 
      oprot.writeFieldBegin('success', TType.LIST, 0)
23559 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
23560 
      for iter563 in self.success:
23561 
        iter563.write(oprot)
23562 
      oprot.writeListEnd()
23563 
      oprot.writeFieldEnd()
23564 
    oprot.writeFieldStop()
23565 
    oprot.writeStructEnd()
23566 
 
23567 
  def validate(self):
23568 
    return
23569 
 
23570 
 
23571 
  def __repr__(self):
23572 
    L = ['%s=%r' % (key, value)
23573 
      for key, value in self.__dict__.iteritems()]
23574 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
23575 
 
23576 
  def __eq__(self, other):
23577 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
23578 
 
23579 
  def __ne__(self, other):
23580 
    return not (self == other)
23581 
 
23582 
class setOrderAttributeForTransaction_args:
23583 
  """
23584 
  Attributes:
23585 
   - transactionId
23586 
   - attribute
23587 
  """
23588 
 
23589 
  thrift_spec = None
23590 
  def __init__(self, transactionId=None, attribute=None,):
23591 
    self.transactionId = transactionId
23592 
    self.attribute = attribute
23593 
 
23594 
  def read(self, iprot):
23595 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
23596 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
23597 
      return
23598 
    iprot.readStructBegin()
23599 
    while True:
23600 
      (fname, ftype, fid) = iprot.readFieldBegin()
23601 
      if ftype == TType.STOP:
23602 
        break
23603 
      if fid == 1:
23604 
        if ftype == TType.I64:
23605 
          self.transactionId = iprot.readI64();
23606 
        else:
23607 
          iprot.skip(ftype)
23608 
      elif fid == -1:
23609 
        if ftype == TType.STRUCT:
23610 
          self.attribute = Attribute()
23611 
          self.attribute.read(iprot)
23612 
        else:
23613 
          iprot.skip(ftype)
23614 
      else:
23615 
        iprot.skip(ftype)
23616 
      iprot.readFieldEnd()
23617 
    iprot.readStructEnd()
23618 
 
23619 
  def write(self, oprot):
23620 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
23621 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
23622 
      return
23623 
    oprot.writeStructBegin('setOrderAttributeForTransaction_args')
23624 
    if self.attribute is not None:
23625 
      oprot.writeFieldBegin('attribute', TType.STRUCT, -1)
23626 
      self.attribute.write(oprot)
23627 
      oprot.writeFieldEnd()
23628 
    if self.transactionId is not None:
23629 
      oprot.writeFieldBegin('transactionId', TType.I64, 1)
23630 
      oprot.writeI64(self.transactionId)
23631 
      oprot.writeFieldEnd()
23632 
    oprot.writeFieldStop()
23633 
    oprot.writeStructEnd()
23634 
 
23635 
  def validate(self):
23636 
    return
23637 
 
23638 
 
23639 
  def __repr__(self):
23640 
    L = ['%s=%r' % (key, value)
23641 
      for key, value in self.__dict__.iteritems()]
23642 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
23643 
 
23644 
  def __eq__(self, other):
23645 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
23646 
 
23647 
  def __ne__(self, other):
23648 
    return not (self == other)
23649 
 
23650 
class setOrderAttributeForTransaction_result:
23651 
 
23652 
  thrift_spec = (
23653 
  )
23654 
 
23655 
  def read(self, iprot):
23656 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
23657 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
23658 
      return
23659 
    iprot.readStructBegin()
23660 
    while True:
23661 
      (fname, ftype, fid) = iprot.readFieldBegin()
23662 
      if ftype == TType.STOP:
23663 
        break
23664 
      else:
23665 
        iprot.skip(ftype)
23666 
      iprot.readFieldEnd()
23667 
    iprot.readStructEnd()
23668 
 
23669 
  def write(self, oprot):
23670 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
23671 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
23672 
      return
23673 
    oprot.writeStructBegin('setOrderAttributeForTransaction_result')
23674 
    oprot.writeFieldStop()
23675 
    oprot.writeStructEnd()
23676 
 
23677 
  def validate(self):
23678 
    return
23679 
 
23680 
 
23681 
  def __repr__(self):
23682 
    L = ['%s=%r' % (key, value)
23683 
      for key, value in self.__dict__.iteritems()]
23684 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
23685 
 
23686 
  def __eq__(self, other):
23687 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
23688 
 
23689 
  def __ne__(self, other):
23690 
    return not (self == other)